diff --git a/Cargo.lock b/Cargo.lock index 1469baa3c..a3e28dd31 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -404,10 +404,12 @@ dependencies = [ "aionui-conversation", "aionui-cron", "aionui-db", + "aionui-development", "aionui-extension", "aionui-file", "aionui-mcp", "aionui-office", + "aionui-project", "aionui-realtime", "aionui-runtime", "aionui-shell", @@ -533,6 +535,7 @@ dependencies = [ "rustls-native-certs", "serde", "serde_json", + "sha2 0.10.9", "thiserror 2.0.18", "tokio", "tokio-tungstenite 0.26.2", @@ -627,6 +630,34 @@ dependencies = [ "tracing", ] +[[package]] +name = "aionui-development" +version = "0.1.50" +dependencies = [ + "aionui-api-types", + "aionui-auth", + "aionui-common", + "aionui-db", + "aionui-runtime", + "async-trait", + "axum", + "ed25519-dalek", + "git2", + "hex", + "http-body-util", + "serde", + "serde_json", + "sha2 0.10.9", + "sqlx", + "tempfile", + "thiserror 2.0.18", + "tokio", + "tower", + "tracing", + "uuid", + "zeroize", +] + [[package]] name = "aionui-extension" version = "0.1.50" @@ -740,6 +771,31 @@ dependencies = [ "which 7.0.3", ] +[[package]] +name = "aionui-project" +version = "0.1.50" +dependencies = [ + "aionui-api-types", + "aionui-auth", + "aionui-common", + "aionui-db", + "aionui-runtime", + "async-trait", + "axum", + "git2", + "http-body-util", + "serde", + "serde_json", + "sqlx", + "tempfile", + "thiserror 2.0.18", + "tokio", + "tower", + "uuid", + "walkdir", + "which 7.0.3", +] + [[package]] name = "aionui-realtime" version = "0.1.50" diff --git a/Cargo.toml b/Cargo.toml index 7587f965b..2c641ac54 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -20,6 +20,8 @@ members = [ "crates/aionui-team-prompts", "crates/aionui-team", "crates/aionui-cron", + "crates/aionui-project", + "crates/aionui-development", "crates/aionui-assistant", "crates/aionui-app", ] @@ -50,6 +52,8 @@ aionui-channel = { path = "crates/aionui-channel" } aionui-team-prompts = { path = "crates/aionui-team-prompts" } aionui-team = { path = "crates/aionui-team" } aionui-cron = { path = "crates/aionui-cron" } +aionui-project = { path = "crates/aionui-project" } +aionui-development = { path = "crates/aionui-development" } aionui-assistant = { path = "crates/aionui-assistant" } aionui-app = { path = "crates/aionui-app" } @@ -98,6 +102,7 @@ rusqlite = { version = "0.32", features = ["bundled"] } jsonwebtoken = "9" bcrypt = "0.17" aes-gcm = "0.10" +zeroize = "1" # UUID uuid = { version = "1", features = ["v7"] } diff --git a/crates/aionui-ai-agent/src/capability/cli_process/spawn_sdk.rs b/crates/aionui-ai-agent/src/capability/cli_process/spawn_sdk.rs index 1b9c68846..f97958ffd 100644 --- a/crates/aionui-ai-agent/src/capability/cli_process/spawn_sdk.rs +++ b/crates/aionui-ai-agent/src/capability/cli_process/spawn_sdk.rs @@ -1,10 +1,9 @@ use aionui_common::{CommandSpec, ErrorChain}; -use aionui_runtime::Builder as CmdBuilder; -#[cfg(test)] +use aionui_runtime::{Builder as CmdBuilder, ProcessLeaseSpec}; use std::path::Path; use std::sync::Arc; +use std::time::Duration; use tokio::io::{AsyncBufReadExt, BufReader}; -use tokio::process::Child; use tokio::sync::{Mutex, watch}; use tracing::{debug, error, info, warn}; @@ -23,12 +22,17 @@ impl CliAgentProcess { /// - stderr buffering /// - Process exit monitoring pub async fn spawn_for_sdk(config: CommandSpec) -> Result { - let mut cmd = CmdBuilder::new(&config.command); + Self::spawn_for_sdk_in_data_dir(config, &std::env::temp_dir()).await + } + + pub async fn spawn_for_sdk_in_data_dir(config: CommandSpec, data_dir: &Path) -> Result { + let (mut cmd, environment_kind, environment_id, lease_id) = Self::sdk_runner_command(&config)?; let agent_env = aionui_runtime::agent_process_env().await; - cmd.args(&config.args) - .env_clear() + cmd.env_clear() .envs(agent_env) + .envs(Self::agent_spawn_env(data_dir)) .envs(config.env.iter().map(|e| (&e.name, &e.value))) + .env("AIONUI_RUNNER_ENVIRONMENT_ID", &environment_id) .stdin(std::process::Stdio::piped()) .stdout(std::process::Stdio::piped()) .stderr(std::process::Stdio::piped()); @@ -37,32 +41,61 @@ impl CliAgentProcess { cmd.current_dir(prepare_command_cwd(cwd)?); } let preview = Self::sdk_spawn_preview(&config); - info!(command = %preview, "Spawning CLI process (SDK mode)"); - let mut child: Child = cmd.spawn().map_err(|e| { - error!(command = %preview, error = %ErrorChain(&e), "Failed to spawn CLI process"); - AgentError::internal(format!("Failed to spawn CLI process '{preview}': {e}")) - })?; - - let pid = child.id().ok_or_else(|| { - error!(command = %preview, "Failed to obtain PID from spawned process"); - AgentError::internal("Failed to obtain PID from spawned process") - })?; - info!(pid, command = %preview, "CLI process spawned (SDK mode)"); - - let stdout = child.stdout.take().ok_or_else(|| { - error!(pid, "Failed to capture stdout from child process"); - AgentError::internal("Failed to capture stdout from child process") - })?; - let stderr = child.stderr.take().ok_or_else(|| { - error!(pid, "Failed to capture stderr from child process"); - AgentError::internal("Failed to capture stderr from child process") - })?; - let stdin = child.stdin.take().ok_or_else(|| { - error!(pid, "Failed to capture stdin for child process"); - AgentError::internal("Failed to capture stdin for child process") - })?; + info!( + lease_id, + environment_kind, environment_id, "spawning leased ACP process" + ); + let mut child = cmd + .spawn_leased(ProcessLeaseSpec::new( + &lease_id, + &environment_id, + Duration::from_secs(24 * 60 * 60), + )) + .map_err(|e| { + error!(lease_id, environment_kind, error = %ErrorChain(&e), "failed to spawn leased ACP process"); + AgentError::internal(format!("Failed to spawn CLI process '{preview}': {e}")) + })?; + + let pid = match child.id() { + Some(pid) => pid, + None => { + error!(lease_id, environment_kind, "failed to obtain leased ACP process id"); + let _ = child.terminate_tree().await; + return Err(AgentError::internal("Failed to obtain PID from spawned process")); + } + }; + info!( + pid, + lease_id, environment_kind, environment_id, "leased ACP process spawned" + ); + + let stdout = match child.stdout.take() { + Some(stdout) => stdout, + None => { + error!(pid, "Failed to capture stdout from child process"); + let _ = child.terminate_tree().await; + return Err(AgentError::internal("Failed to capture stdout from child process")); + } + }; + let stderr = match child.stderr.take() { + Some(stderr) => stderr, + None => { + error!(pid, "Failed to capture stderr from child process"); + let _ = child.terminate_tree().await; + return Err(AgentError::internal("Failed to capture stderr from child process")); + } + }; + let stdin = match child.stdin.take() { + Some(stdin) => stdin, + None => { + error!(pid, "Failed to capture stdin for child process"); + let _ = child.terminate_tree().await; + return Err(AgentError::internal("Failed to capture stdin from child process")); + } + }; let (exit_tx, exit_rx) = watch::channel(None); + let process_lease = child.lease().clone(); // Background task: read stderr → ring buffer + log let stderr_buffer = Arc::new(Mutex::new(String::new())); @@ -74,7 +107,7 @@ impl CliAgentProcess { while let Ok(Some(line)) = lines.next_line().await { let trimmed = line.trim(); if !trimmed.is_empty() { - warn!(pid, stderr = trimmed, "CLI process stderr"); + warn!(pid, stderr_bytes = line.len(), "ACP process emitted stderr"); } let mut buf = stderr_buf_clone.lock().await; buf.push_str(&line); @@ -85,12 +118,20 @@ impl CliAgentProcess { debug!(pid, "Stderr reader finished"); }); + tokio::spawn(async move { + let mut interval = tokio::time::interval(Duration::from_secs(30)); + while !process_lease.is_terminal() { + interval.tick().await; + process_lease.heartbeat(); + } + }); + // Background task: monitor process exit let exit_handle = tokio::spawn(async move { - match child.wait().await { - Ok(status) => { - info!(pid, ?status, "CLI process exited"); - let _ = exit_tx.send(Some(status)); + match child.wait_with_timeout().await { + Ok(exit) => { + info!(pid, lease_id, timed_out = exit.timed_out, "leased ACP process exited"); + let _ = exit_tx.send(exit.status); } Err(e) => { error!(pid, error = %ErrorChain(&e), "Failed to wait on CLI process"); @@ -111,6 +152,96 @@ impl CliAgentProcess { }) } + fn sdk_runner_command(config: &CommandSpec) -> Result<(CmdBuilder, String, String, String), AgentError> { + let environment_kind = config_env(config, "AIONUI_RUNNER_ENVIRONMENT_KIND").unwrap_or("host"); + let environment_id = config_env(config, "AIONUI_RUNNER_ENVIRONMENT_ID") + .map(str::to_owned) + .unwrap_or_else(|| "host:local".into()); + let lease_id = config_env(config, "AIONUI_EXECUTION_LEASE_ID") + .map(str::to_owned) + .unwrap_or_else(|| format!("agent:{}", uuid::Uuid::now_v7())); + let command = match environment_kind { + "host" => { + let mut command = CmdBuilder::new(&config.command); + command.args(&config.args); + command + } + "docker" => { + let image = config_env(config, "AIONUI_RUNNER_CONTAINER_IMAGE") + .filter(|value| !value.trim().is_empty()) + .ok_or_else(|| AgentError::bad_request("Docker Agent execution requires a container image"))?; + let cwd = config + .cwd + .as_deref() + .ok_or_else(|| AgentError::bad_request("Docker Agent execution requires a workspace"))?; + let container_name = format!("aion-agent-{}", safe_runner_id(&lease_id)); + let mut args = vec![ + "run".into(), + "--rm".into(), + "--init".into(), + "-i".into(), + "--name".into(), + container_name, + "--workdir".into(), + "/workspace".into(), + "--volume".into(), + format!("{cwd}:/workspace:rw"), + ]; + for entry in config.env.iter().filter(|entry| !entry.name.starts_with("AIONUI_")) { + args.push("--env".into()); + args.push(entry.name.clone()); + } + args.push(image.into()); + args.push(config.command.to_string_lossy().into_owned()); + args.extend(config.args.clone()); + let mut command = CmdBuilder::new("docker"); + command.args(args); + command + } + "devcontainer" => { + let cwd = config + .cwd + .as_deref() + .ok_or_else(|| AgentError::bad_request("Dev Container Agent execution requires a workspace"))?; + let devcontainer_config = config_env(config, "AIONUI_RUNNER_DEVCONTAINER_CONFIG") + .filter(|value| !value.trim().is_empty()) + .ok_or_else(|| AgentError::bad_request("Dev Container Agent execution requires a config path"))?; + if config.env.iter().any(|entry| !entry.name.starts_with("AIONUI_")) { + return Err(AgentError::bad_request( + "Dev Container Agent credentials must be provisioned inside the selected container", + )); + } + let mut args = vec![ + "exec".into(), + "--workspace-folder".into(), + cwd.into(), + "--config".into(), + devcontainer_config.into(), + config.command.to_string_lossy().into_owned(), + ]; + args.extend(config.args.clone()); + let mut command = CmdBuilder::new("devcontainer"); + command.args(args); + command + } + other => { + return Err(AgentError::bad_request(format!( + "Unsupported Agent execution environment: {other}" + ))); + } + }; + Ok((command, environment_kind.into(), environment_id, lease_id)) + } + + fn agent_spawn_env(data_dir: &Path) -> Vec<(String, String)> { + let bun_cache = data_dir.join("bun-cache"); + let bun_tmp = data_dir.join("bun-tmp"); + vec![ + ("BUN_INSTALL_CACHE_DIR".into(), bun_cache.to_string_lossy().into_owned()), + ("BUN_TMPDIR".into(), bun_tmp.to_string_lossy().into_owned()), + ] + } + fn sdk_spawn_preview(config: &CommandSpec) -> String { let explicit_env_key_names: Vec<&str> = config.env.iter().map(|entry| entry.name.as_str()).collect(); format!( @@ -124,6 +255,28 @@ impl CliAgentProcess { } } +fn config_env<'a>(config: &'a CommandSpec, name: &str) -> Option<&'a str> { + config + .env + .iter() + .find(|entry| entry.name == name) + .map(|entry| entry.value.as_str()) +} + +fn safe_runner_id(value: &str) -> String { + let value = value + .chars() + .map(|character| { + if character.is_ascii_alphanumeric() || matches!(character, '-' | '_') { + character.to_ascii_lowercase() + } else { + '-' + } + }) + .collect::(); + value.trim_matches('-').chars().take(48).collect() +} + #[cfg(test)] mod tests { use super::super::tests::simple_script_config; diff --git a/crates/aionui-ai-agent/src/capability/mod.rs b/crates/aionui-ai-agent/src/capability/mod.rs index eb9511447..a705539da 100644 --- a/crates/aionui-ai-agent/src/capability/mod.rs +++ b/crates/aionui-ai-agent/src/capability/mod.rs @@ -6,7 +6,7 @@ pub(crate) mod backend_output_sink; pub(crate) mod backend_protocol_sink; -pub(crate) mod cli_process; +pub mod cli_process; pub(crate) mod first_message_injector; pub(crate) mod image_input; pub mod prompt_pipeline; diff --git a/crates/aionui-ai-agent/src/lib.rs b/crates/aionui-ai-agent/src/lib.rs index c468481bd..f59bb2b5f 100644 --- a/crates/aionui-ai-agent/src/lib.rs +++ b/crates/aionui-ai-agent/src/lib.rs @@ -53,6 +53,7 @@ pub use runtime_token::{ pub use services::AgentAvailabilityFeedbackPort; pub use services::AgentService; pub use services::RemoteAgentService; +pub use services::{DynamicAgentProbe, DynamicProbeFailure, DynamicProbeSession, DynamicProbeSessionFactory}; pub use session_context::{ AcpSessionBuildContext, AgentSessionContext, AgentSessionKind, AionrsSessionBuildContext, ConversationContext, WorkspaceContext, diff --git a/crates/aionui-ai-agent/src/manager/acp/agent.rs b/crates/aionui-ai-agent/src/manager/acp/agent.rs index 20415606e..04c8c3628 100644 --- a/crates/aionui-ai-agent/src/manager/acp/agent.rs +++ b/crates/aionui-ai-agent/src/manager/acp/agent.rs @@ -24,7 +24,8 @@ use aionui_api_types::{ SlashCommandCompletionBehavior, SlashCommandItem, }; use aionui_common::{ - AgentKillReason, AgentType, ConversationStatus, ErrorChain, TimestampMs, normalize_keys_to_snake_case, now_ms, + AgentKillReason, AgentType, ConversationStatus, EnvVar, ErrorChain, TimestampMs, normalize_keys_to_snake_case, + now_ms, }; use serde_json::Value; use std::collections::HashMap; @@ -182,8 +183,25 @@ async fn spawn_and_connect_acp_once( params: &AcpSessionParams, runtime: &AgentRuntime, ) -> Result { + let mut command_spec = params.command_spec.clone(); + ensure_runner_env( + &mut command_spec.env, + "AIONUI_EXECUTION_LEASE_ID", + format!("conversation:{}", params.conversation_id), + ); + ensure_runner_env( + &mut command_spec.env, + "AIONUI_EXECUTION_TURN_ID", + params.conversation_id.clone(), + ); + ensure_runner_env(&mut command_spec.env, "AIONUI_RUNNER_ENVIRONMENT_KIND", "host".into()); + ensure_runner_env( + &mut command_spec.env, + "AIONUI_RUNNER_ENVIRONMENT_ID", + "host:local".into(), + ); let process = Arc::new( - CliAgentProcess::spawn_for_sdk(params.command_spec.clone()) + CliAgentProcess::spawn_for_sdk_in_data_dir(command_spec, ¶ms.data_dir) .await .map_err(AcpStartupConnectError::Agent)?, ); @@ -635,6 +653,15 @@ impl AcpAgentManager { } } +fn ensure_runner_env(environment: &mut Vec, name: &str, value: String) { + if !environment.iter().any(|entry| entry.name == name) { + environment.push(EnvVar { + name: name.into(), + value, + }); + } +} + impl AcpAgentManager { fn record_user_cancel_request(runtime: &AgentRuntime, session: &mut AcpSession) { session.record_close_reason(Some(CloseReason::UserCancel)); diff --git a/crates/aionui-ai-agent/src/manager/acp/agent_session_flow.rs b/crates/aionui-ai-agent/src/manager/acp/agent_session_flow.rs index 4b010509b..12463f983 100644 --- a/crates/aionui-ai-agent/src/manager/acp/agent_session_flow.rs +++ b/crates/aionui-ai-agent/src/manager/acp/agent_session_flow.rs @@ -3,8 +3,8 @@ use crate::manager::acp::AcpAgentManager; use crate::manager::acp::mode_normalize::agent_metadata_uses_meta_resume; use crate::protocol::error::AcpError; use crate::protocol::events::{ - AgentStreamEvent, AvailableCommandsEventData, ErrorEventData, SessionAssignedEventData, StartEventData, TipType, - TipsEventData, + AgentStreamEvent, AvailableCommandsEventData, ErrorEventData, SessionAssignedEventData, StartEventData, + TextEventData, TipType, TipsEventData, }; use crate::protocol::send_error::AgentSendError; use crate::shared_kernel::SessionId as DomainSessionId; @@ -14,13 +14,59 @@ use agent_client_protocol::schema::{ }; use aionui_api_types::SlashCommandItem; use serde_json::Value; +use std::collections::HashMap; +use std::fs::File; +use std::io::{BufRead, BufReader, Seek, SeekFrom}; +use std::path::{Path, PathBuf}; +use std::time::{Duration, Instant}; use tokio::sync::broadcast::error::TryRecvError; +use tokio::time::sleep; use super::agent::sdk_to_snake_value; use super::agent_close::STDERR_PEEK_LINES; use super::error_mapping::{AcpSendFailure, is_acp_session_not_found, is_missing_resumed_session}; use tracing::warn; +const OPENCLAW_ACP_FALLBACK_TIMEOUT: Duration = Duration::from_secs(600); +const OPENCLAW_ACP_FALLBACK_POLL_INTERVAL: Duration = Duration::from_secs(1); + +#[derive(Debug, Clone, Default)] +struct OpenClawTrajectoryCheckpoint { + offsets: HashMap, +} + +impl OpenClawTrajectoryCheckpoint { + fn capture() -> Self { + let mut checkpoint = Self::default(); + let Some(sessions_dir) = openclaw_sessions_dir() else { + return checkpoint; + }; + let Ok(entries) = std::fs::read_dir(sessions_dir) else { + return checkpoint; + }; + + for entry in entries.flatten() { + let path = entry.path(); + let Some(file_name) = path.file_name().and_then(|name| name.to_str()) else { + continue; + }; + if !file_name.ends_with(".trajectory.jsonl") { + continue; + } + let Ok(metadata) = entry.metadata() else { + continue; + }; + checkpoint.offsets.insert(path, metadata.len()); + } + + checkpoint + } + + fn offset_for(&self, path: &Path) -> u64 { + self.offsets.get(path).copied().unwrap_or(0) + } +} + #[derive(Debug)] pub(super) enum PromptOutcome { Completed { session_id: String }, @@ -255,15 +301,36 @@ impl AcpAgentManager { // Scope stderr classification to this prompt so stale lines from an // earlier turn cannot override a later benign empty turn. self.process.clear_stderr().await; - - let prompt_response = self - .protocol - .prompt(PromptRequest::new( - SessionId::new(sid), - vec![ContentBlock::from(content)], - )) - .await - .map_err(AcpSendFailure::from)?; + let openclaw_checkpoint = self.is_openclaw_backend().then(OpenClawTrajectoryCheckpoint::capture); + + let prompt_request = PromptRequest::new(SessionId::new(sid), vec![ContentBlock::from(content)]); + let prompt_fut = self.protocol.prompt(prompt_request); + tokio::pin!(prompt_fut); + + let prompt_response = if self.is_openclaw_backend() { + let fallback_fut = self.wait_for_openclaw_final_text(sid, openclaw_checkpoint.unwrap_or_default()); + tokio::pin!(fallback_fut); + + tokio::select! { + res = &mut prompt_fut => res.map_err(AcpSendFailure::from)?, + fallback_text = &mut fallback_fut => { + if let Some(text) = fallback_text { + warn!( + conversation_id = %self.params.conversation_id, + session_id = %sid, + "OpenClaw ACP prompt did not return before runtime completed; using OpenClaw session log fallback" + ); + self.runtime.emit(AgentStreamEvent::Text(TextEventData { content: text })); + return Ok(PromptOutcome::Completed { + session_id: sid.to_owned(), + }); + } + prompt_fut.await.map_err(AcpSendFailure::from)? + } + } + } else { + prompt_fut.await.map_err(AcpSendFailure::from)? + }; let empty_turn = is_empty_turn(&mut probe_rx); if empty_turn && let Some(error) = self.empty_turn_terminal_error().await { @@ -294,6 +361,38 @@ impl AcpAgentManager { )) } + fn is_openclaw_backend(&self) -> bool { + self.params.metadata.backend.as_deref() == Some("openclaw") + } + + async fn wait_for_openclaw_final_text( + &self, + session_id: &str, + checkpoint: OpenClawTrajectoryCheckpoint, + ) -> Option { + let deadline = Instant::now() + OPENCLAW_ACP_FALLBACK_TIMEOUT; + while Instant::now() < deadline { + let sid = session_id.to_owned(); + let checkpoint = checkpoint.clone(); + match tokio::task::spawn_blocking(move || find_openclaw_final_text_for_acp_session_after(&sid, &checkpoint)) + .await + { + Ok(Some(text)) => return Some(text), + Ok(None) => {} + Err(err) => { + warn!( + conversation_id = %self.params.conversation_id, + error = %err, + "OpenClaw session log fallback task failed" + ); + return None; + } + } + sleep(OPENCLAW_ACP_FALLBACK_POLL_INTERVAL).await; + } + None + } + /// Emit model/mode/config events from the session aggregate so the frontend /// receives the initial session state via WebSocket immediately after /// session creation or load. @@ -358,6 +457,93 @@ impl AcpAgentManager { } } +fn find_openclaw_final_text_for_acp_session_after( + session_id: &str, + checkpoint: &OpenClawTrajectoryCheckpoint, +) -> Option { + let sessions_dir = openclaw_sessions_dir()?; + let mut entries = std::fs::read_dir(sessions_dir) + .ok()? + .filter_map(Result::ok) + .filter(|entry| { + entry + .file_name() + .to_str() + .map(|name| name.ends_with(".trajectory.jsonl")) + .unwrap_or(false) + }) + .filter_map(|entry| { + let modified = entry.metadata().ok()?.modified().ok()?; + Some((modified, entry.path())) + }) + .collect::>(); + + entries.sort_by(|(a, _), (b, _)| b.cmp(a)); + + for (_, path) in entries { + if let Some(text) = + extract_openclaw_final_text_from_trajectory_after(&path, session_id, checkpoint.offset_for(&path)) + { + return Some(text); + } + } + None +} + +fn openclaw_sessions_dir() -> Option { + if let Ok(state_dir) = std::env::var("OPENCLAW_STATE_DIR") + && !state_dir.trim().is_empty() + { + return Some(PathBuf::from(state_dir).join("agents/main/sessions")); + } + let home = std::env::var("HOME").ok()?; + Some(PathBuf::from(home).join(".openclaw/agents/main/sessions")) +} + +fn extract_openclaw_final_text_from_trajectory_after(path: &Path, session_id: &str, offset: u64) -> Option { + let mut file = File::open(path).ok()?; + let file_len = file.metadata().ok().map(|metadata| metadata.len()).unwrap_or(0); + let start = if offset <= file_len { offset } else { 0 }; + file.seek(SeekFrom::Start(start)).ok()?; + let reader = BufReader::new(file); + for line in reader.lines().map_while(Result::ok) { + if !line.contains(session_id) || !line.contains("model.completed") { + continue; + } + if let Some(text) = extract_openclaw_final_text_from_trajectory_line(&line, session_id) { + return Some(text); + } + } + None +} + +fn extract_openclaw_final_text_from_trajectory_line(line: &str, session_id: &str) -> Option { + let value: Value = serde_json::from_str(line).ok()?; + if value.get("type").and_then(Value::as_str) != Some("model.completed") { + return None; + } + let session_key = value.get("sessionKey").and_then(Value::as_str)?; + if !session_key.contains(session_id) { + return None; + } + let texts = value + .get("data") + .and_then(|data| data.get("assistantTexts")) + .and_then(Value::as_array)? + .iter() + .filter_map(Value::as_str) + .map(str::trim) + .filter(|text| !text.is_empty()) + .map(ToOwned::to_owned) + .collect::>(); + + if texts.is_empty() { + None + } else { + Some(texts.join("\n\n")) + } +} + /// Drain the supplied turn-scoped receiver and return `true` when the turn /// produced neither agent text nor any tool-call activity. /// @@ -654,10 +840,9 @@ mod tests { } /// The `is_acp_session_not_found` discriminator powers - /// `open_session_resume`'s rescue path. Match strictly on the - /// structured `AcpError::SessionNotFound` variant; other ACP failures - /// must surface to callers instead of triggering a phantom session - /// rebuild. + /// `open_session_resume`'s rescue path. Some ACP backends report a + /// stale `session/load` target with the structured SessionNotFound + /// variant. Other failures must not trigger a phantom rebuild. #[test] fn is_acp_session_not_found_matches_session_not_found_only() { let session_err = AcpError::SessionNotFound { @@ -942,4 +1127,79 @@ mod tests { assert_eq!(error.retryable, Some(false)); assert_eq!(error.feedback_recommended, Some(false)); } + + #[test] + fn openclaw_final_text_extracts_matching_completed_session() { + let line = serde_json::json!({ + "type": "model.completed", + "sessionKey": "agent:main:acp:sess-123", + "data": { "assistantTexts": ["OpenClaw OK", "Second paragraph"] } + }) + .to_string(); + + assert_eq!( + super::extract_openclaw_final_text_from_trajectory_line(&line, "sess-123"), + Some("OpenClaw OK\n\nSecond paragraph".to_owned()) + ); + } + + #[test] + fn openclaw_final_text_ignores_other_sessions_and_events() { + let other_session = serde_json::json!({ + "type": "model.completed", + "sessionKey": "agent:main:acp:other-session", + "data": { "assistantTexts": ["Wrong"] } + }) + .to_string(); + let other_event = serde_json::json!({ + "type": "session.ended", + "sessionKey": "agent:main:acp:sess-123", + "data": { "assistantTexts": ["Wrong"] } + }) + .to_string(); + + assert_eq!( + super::extract_openclaw_final_text_from_trajectory_line(&other_session, "sess-123"), + None + ); + assert_eq!( + super::extract_openclaw_final_text_from_trajectory_line(&other_event, "sess-123"), + None + ); + } + + #[test] + fn openclaw_final_text_after_checkpoint_ignores_old_completed_events() { + let path = std::env::temp_dir().join(format!( + "aionui-openclaw-checkpoint-{}-sess-123.trajectory.jsonl", + std::process::id() + )); + let old_line = serde_json::json!({ + "type": "model.completed", + "sessionKey": "agent:main:acp:sess-123", + "data": { "assistantTexts": ["Old answer"] } + }) + .to_string(); + std::fs::write(&path, format!("{old_line}\n")).unwrap(); + let checkpoint = std::fs::metadata(&path).unwrap().len(); + + let new_line = serde_json::json!({ + "type": "model.completed", + "sessionKey": "agent:main:acp:sess-123", + "data": { "assistantTexts": ["New answer"] } + }) + .to_string(); + { + use std::io::Write; + let mut file = std::fs::OpenOptions::new().append(true).open(&path).unwrap(); + writeln!(file, "{new_line}").unwrap(); + } + + assert_eq!( + super::extract_openclaw_final_text_from_trajectory_after(&path, "sess-123", checkpoint), + Some("New answer".to_owned()) + ); + + let _ = std::fs::remove_file(path); + } } diff --git a/crates/aionui-ai-agent/src/protocol/acp.rs b/crates/aionui-ai-agent/src/protocol/acp.rs index de6c31807..fc20a97be 100644 --- a/crates/aionui-ai-agent/src/protocol/acp.rs +++ b/crates/aionui-ai-agent/src/protocol/acp.rs @@ -36,6 +36,7 @@ use agent_client_protocol::{ Agent, ByteStreams, Client, ConnectionTo, Responder, on_receive_notification, on_receive_request, }; use aionui_common::ErrorChain; +use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader, DuplexStream}; use tokio::process::{ChildStdin, ChildStdout}; use tokio::sync::{broadcast, mpsc, oneshot}; use tokio_util::compat::{TokioAsyncReadCompatExt, TokioAsyncWriteCompatExt}; @@ -514,6 +515,7 @@ async fn run_sdk_background( alive: Arc, replay_suppression: Arc, ) { + let stdout = filter_acp_stdout(stdout); let transport = ByteStreams::new(stdin.compat_write(), stdout.compat()); // `init_tx` / `ready_tx` are consumed inside the main_fn closure; wrap @@ -617,6 +619,71 @@ async fn run_sdk_background( } } +fn filter_acp_stdout(stdout: ChildStdout) -> DuplexStream { + let (reader, mut writer) = tokio::io::duplex(64 * 1024); + tokio::spawn(async move { + let mut lines = BufReader::new(stdout).lines(); + let mut json_buffer = String::new(); + while let Ok(Some(line)) = lines.next_line().await { + if json_buffer.is_empty() && !is_jsonrpc_stdout_start_line(&line) { + if !line.trim().is_empty() { + warn!(line = %line, "Dropping non-JSON ACP stdout line"); + } + continue; + } + + json_buffer.push_str(&line); + json_buffer.push('\n'); + + match serde_json::from_str::(&json_buffer) { + Ok(_) => { + if writer.write_all(json_buffer.as_bytes()).await.is_err() { + break; + } + json_buffer.clear(); + } + Err(err) if err.is_eof() => { + // Multi-line JSON-RPC frame: keep accumulating until the + // full object is available, then forward the whole frame + // unchanged to the SDK transport. + } + Err(err) => { + warn!( + error = %err, + line = %line, + "Dropping malformed ACP stdout JSON frame" + ); + json_buffer.clear(); + } + } + + if json_buffer.len() > 1024 * 1024 { + warn!("Dropping oversized ACP stdout JSON frame"); + json_buffer.clear(); + } + } + + if !json_buffer.trim().is_empty() { + match serde_json::from_str::(&json_buffer) { + Ok(_) => { + let _ = writer.write_all(json_buffer.as_bytes()).await; + } + Err(err) => { + warn!( + error = %err, + "Dropping incomplete ACP stdout JSON frame at EOF" + ); + } + } + } + }); + reader +} + +fn is_jsonrpc_stdout_start_line(line: &str) -> bool { + line.trim_start().starts_with('{') +} + /// Fan out a CLI session notification to the event broadcast channel. async fn handle_session_notification( notification: SessionNotification, @@ -895,6 +962,71 @@ impl std::fmt::Debug for AcpProtocol { mod tests { use super::*; + #[tokio::test] + async fn filtered_acp_stdout_drops_non_json_preamble_lines() { + use std::process::Stdio; + use tokio::io::AsyncReadExt; + use tokio::process::Command; + + let mut child = Command::new("sh") + .arg("-c") + .arg("printf 'Config warnings:\\n- plugin not installed\\n{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":{}}\\n'") + .stdout(Stdio::piped()) + .spawn() + .expect("spawn child"); + let stdout = child.stdout.take().expect("child stdout"); + let mut filtered = filter_acp_stdout(stdout); + + let mut output = String::new(); + filtered + .read_to_string(&mut output) + .await + .expect("read filtered stdout"); + child.wait().await.expect("wait child"); + + assert_eq!(output, "{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":{}}\n"); + } + + #[tokio::test] + async fn filtered_acp_stdout_preserves_multiline_json_frames() { + use std::process::Stdio; + use tokio::io::AsyncReadExt; + use tokio::process::Command; + + let mut child = Command::new("sh") + .arg("-c") + .arg( + r#"cat <<'EOF' +Config warnings: +{ + "jsonrpc": "2.0", + "id": 2, + "result": { + "content": "OpenClaw OK" + } +} +EOF +"#, + ) + .stdout(Stdio::piped()) + .spawn() + .expect("spawn child"); + let stdout = child.stdout.take().expect("child stdout"); + let mut filtered = filter_acp_stdout(stdout); + + let mut output = String::new(); + filtered + .read_to_string(&mut output) + .await + .expect("read filtered stdout"); + child.wait().await.expect("wait child"); + + assert_eq!( + output, + "{\n \"jsonrpc\": \"2.0\",\n \"id\": 2,\n \"result\": {\n \"content\": \"OpenClaw OK\"\n }\n}\n" + ); + } + fn capture_logs(max_level: tracing::Level, f: impl FnOnce()) -> String { use std::io::Write; use std::sync::{Arc, Mutex}; diff --git a/crates/aionui-ai-agent/src/protocol/custom_agent_probe.rs b/crates/aionui-ai-agent/src/protocol/custom_agent_probe.rs index 7bf1e9413..db9c48ecf 100644 --- a/crates/aionui-ai-agent/src/protocol/custom_agent_probe.rs +++ b/crates/aionui-ai-agent/src/protocol/custom_agent_probe.rs @@ -13,9 +13,11 @@ //! Both paths produce identical outcomes / error text. use std::collections::HashMap; +use std::path::{Path, PathBuf}; +use std::sync::Arc; use std::time::Duration; -use aionui_api_types::TryConnectCustomAgentResponse; +use aionui_api_types::{AgentDynamicProbeResult, AgentProbeErrorCategory, TryConnectCustomAgentResponse}; use aionui_common::{CommandSpec, EnvVar}; use aionui_runtime::{NodeRuntimeProgressReporter, ResolvedCommand, ensure_runtime_command_with_reporter}; use tokio::sync::{broadcast, mpsc}; @@ -25,8 +27,11 @@ use crate::capability::cli_process::CliAgentProcess; use crate::protocol::acp::AcpProtocol; use crate::protocol::error::AcpError; use crate::protocol::npx_cache_repair::CorruptNpxCacheRepair; +use crate::services::{DynamicAgentProbe, DynamicProbeFailure, DynamicProbeSession, DynamicProbeSessionFactory}; -use agent_client_protocol::schema::NewSessionRequest; +use agent_client_protocol::schema::{ + CancelNotification, ContentBlock, NewSessionRequest, PromptRequest, ResumeSessionRequest, SessionId, TextContent, +}; /// Step 2 overall timeout. Belt-and-suspenders: `AcpProtocol::connect` /// already caps the initialize RPC at 30 s, but a CLI that hangs @@ -85,6 +90,43 @@ pub async fn try_connect_custom_agent( outcome } +/// Resolve and run the full dynamic preflight for a custom ACP Agent. +pub(crate) async fn dynamic_probe_custom_agent( + agent_id: &str, + command: &str, + args: &[String], + env: &HashMap, + data_dir: &Path, +) -> AgentDynamicProbeResult { + let resolved = match ensure_runtime_command_with_reporter(first_token(command), None).await { + Ok(resolved) => resolved, + Err(error) => { + return failed_dynamic_probe( + agent_id, + DynamicProbeFailure::new(AgentProbeErrorCategory::RuntimeMissing, error.to_string()), + ) + .await; + } + }; + let spec = build_probe_command_spec(resolved, args, env); + dynamic_probe_command_spec(agent_id, spec, data_dir).await +} + +async fn failed_dynamic_probe(agent_id: &str, failure: DynamicProbeFailure) -> AgentDynamicProbeResult { + struct FailedFactory(DynamicProbeFailure); + + #[async_trait::async_trait] + impl DynamicProbeSessionFactory for FailedFactory { + async fn spawn(&self, _agent_id: &str) -> Result, DynamicProbeFailure> { + Err(self.0.clone()) + } + } + + DynamicAgentProbe::new(Arc::new(FailedFactory(failure))) + .run(agent_id) + .await +} + fn first_token(command: &str) -> &str { command.split_whitespace().next().unwrap_or(command) } @@ -94,6 +136,14 @@ async fn spawn_probe_process( args: &[String], env: &HashMap, ) -> Result { + let spec = build_probe_command_spec(resolved, args, env); + + CliAgentProcess::spawn_for_sdk(spec) + .await + .map_err(|e| format!("spawn failed: {e}")) +} + +fn build_probe_command_spec(resolved: ResolvedCommand, args: &[String], env: &HashMap) -> CommandSpec { let mut final_args: Vec = resolved .args_prefix .iter() @@ -113,16 +163,12 @@ async fn spawn_probe_process( value: value.to_string_lossy().into_owned(), })); - let spec = CommandSpec { + CommandSpec { command: resolved.program, args: final_args, env: final_env, cwd: Some(std::env::temp_dir().to_string_lossy().into_owned()), - }; - - CliAgentProcess::spawn_for_sdk(spec) - .await - .map_err(|e| format!("spawn failed: {e}")) + } } /// RAII guard that force-kills a probe's process tree when dropped. @@ -183,6 +229,169 @@ async fn acp_probe_command_spec_once(spec: CommandSpec) -> ProbeOutcome { run_handshake(&proc).await } +/// Run the full six-stage dynamic probe against a pre-built ACP command. +/// The process and ACP session are throwaway and never enter conversation +/// persistence, so the fixed prompt cannot appear in user history. +pub(crate) async fn dynamic_probe_command_spec( + agent_id: &str, + spec: CommandSpec, + data_dir: &Path, +) -> AgentDynamicProbeResult { + let factory = Arc::new(AcpDynamicProbeFactory { + spec, + data_dir: data_dir.to_path_buf(), + }); + DynamicAgentProbe::new(factory).run(agent_id).await +} + +struct AcpDynamicProbeFactory { + spec: CommandSpec, + data_dir: PathBuf, +} + +#[async_trait::async_trait] +impl DynamicProbeSessionFactory for AcpDynamicProbeFactory { + async fn spawn(&self, _agent_id: &str) -> Result, DynamicProbeFailure> { + let process = CliAgentProcess::spawn_for_sdk_in_data_dir(self.spec.clone(), &self.data_dir) + .await + .map_err(|error| DynamicProbeFailure::new(AgentProbeErrorCategory::Startup, error.to_string()))?; + Ok(Box::new(AcpDynamicProbeSession { + process, + protocol: None, + session_id: None, + })) + } +} + +struct AcpDynamicProbeSession { + process: CliAgentProcess, + protocol: Option, + session_id: Option, +} + +impl Drop for AcpDynamicProbeSession { + fn drop(&mut self) { + self.process.force_kill_tree(); + } +} + +#[async_trait::async_trait] +impl DynamicProbeSession for AcpDynamicProbeSession { + async fn initialize(&mut self) -> Result<(), DynamicProbeFailure> { + let (stdin, stdout) = self.process.take_stdio().await.ok_or_else(|| { + DynamicProbeFailure::new(AgentProbeErrorCategory::Startup, "stdio unavailable after Agent spawn") + })?; + let (event_tx, _event_rx) = broadcast::channel(16); + let (permission_tx, _permission_rx) = mpsc::channel(4); + let (notification_tx, _notification_rx) = mpsc::channel(4); + self.protocol = Some( + AcpProtocol::connect(stdin, stdout, event_tx, permission_tx, notification_tx) + .await + .map_err(dynamic_probe_error)?, + ); + Ok(()) + } + + async fn models(&mut self) -> Result, DynamicProbeFailure> { + let response = self + .protocol()? + .new_session(NewSessionRequest::new(std::env::temp_dir())) + .await + .map_err(dynamic_probe_error)?; + self.session_id = Some(response.session_id.clone()); + Ok(response + .models + .map(|state| { + state + .available_models + .into_iter() + .map(|model| model.model_id.to_string()) + .collect() + }) + .unwrap_or_default()) + } + + async fn minimal_prompt(&mut self) -> Result<(), DynamicProbeFailure> { + let session_id = self.session_id()?; + let prompt = PromptRequest::new( + session_id, + vec![ContentBlock::Text(TextContent::new( + "Reply with exactly OK. Do not call tools or modify files.", + ))], + ); + self.protocol()? + .prompt(prompt) + .await + .map(|_| ()) + .map_err(dynamic_probe_error) + } + + async fn cancel(&mut self) -> Result<(), DynamicProbeFailure> { + let session_id = self.session_id()?; + let protocol = self.protocol()?; + if !protocol.is_connected() { + return Err(DynamicProbeFailure::new( + AgentProbeErrorCategory::Protocol, + "ACP connection closed before cancellation probe", + )); + } + protocol.cancel(CancelNotification::new(session_id)); + Ok(()) + } + + async fn resume(&mut self) -> Result<(), DynamicProbeFailure> { + let session_id = self.session_id()?; + self.protocol()? + .resume_session(ResumeSessionRequest::new(session_id, std::env::temp_dir())) + .await + .map(|_| ()) + .map_err(|error| match error { + AcpError::MethodNotFound { .. } => DynamicProbeFailure::unsupported(error.to_string()), + other => dynamic_probe_error(other), + }) + } +} + +impl AcpDynamicProbeSession { + fn protocol(&self) -> Result<&AcpProtocol, DynamicProbeFailure> { + self.protocol.as_ref().ok_or_else(|| { + DynamicProbeFailure::new(AgentProbeErrorCategory::Protocol, "ACP protocol is not initialized") + }) + } + + fn session_id(&self) -> Result { + self.session_id.clone().ok_or_else(|| { + DynamicProbeFailure::new(AgentProbeErrorCategory::Protocol, "ACP session is not initialized") + }) + } +} + +fn dynamic_probe_error(error: AcpError) -> DynamicProbeFailure { + let message = error.to_string(); + match error { + AcpError::AuthRequired => DynamicProbeFailure::new(AgentProbeErrorCategory::Authentication, message), + AcpError::SpawnFailed { .. } | AcpError::StartupCrash { .. } => { + DynamicProbeFailure::new(AgentProbeErrorCategory::Startup, message) + } + AcpError::InitTimeout { .. } => DynamicProbeFailure::timed_out(message), + AcpError::AgentInternal { ref message, .. } | AcpError::OtherProtocolError { ref message, .. } + if message.to_ascii_lowercase().contains("rate limit") => + { + DynamicProbeFailure::new(AgentProbeErrorCategory::RateLimited, message) + } + AcpError::AgentInternal { ref message, .. } | AcpError::OtherProtocolError { ref message, .. } + if message.to_ascii_lowercase().contains("model") => + { + DynamicProbeFailure::new(AgentProbeErrorCategory::ModelRejected, message) + } + AcpError::MethodNotFound { .. } + | AcpError::ProtocolParseError { .. } + | AcpError::InvalidRequest { .. } + | AcpError::InvalidParams { .. } => DynamicProbeFailure::new(AgentProbeErrorCategory::Protocol, message), + _ => DynamicProbeFailure::new(AgentProbeErrorCategory::Unknown, message), + } +} + /// Result of the Step 2 probe (`initialize` + `session/new`). /// /// The probe reaches `session/new` so it can tell "reachable but not diff --git a/crates/aionui-ai-agent/src/protocol/error.rs b/crates/aionui-ai-agent/src/protocol/error.rs index c6f579c00..01479c834 100644 --- a/crates/aionui-ai-agent/src/protocol/error.rs +++ b/crates/aionui-ai-agent/src/protocol/error.rs @@ -63,6 +63,7 @@ impl CloseReason { Some(AgentKillReason::RuntimeCapabilityChanged) => { "Agent killed: runtime capability changed".to_owned() } + Some(AgentKillReason::BudgetExceeded) => "Agent stopped: development budget exceeded".to_owned(), None => "Agent killed".to_owned(), }, CloseReason::ProcessExited { diff --git a/crates/aionui-ai-agent/src/protocol/events/permission.rs b/crates/aionui-ai-agent/src/protocol/events/permission.rs index 0ed2d1fcd..249437924 100644 --- a/crates/aionui-ai-agent/src/protocol/events/permission.rs +++ b/crates/aionui-ai-agent/src/protocol/events/permission.rs @@ -2,6 +2,7 @@ use agent_client_protocol::schema::Meta as SdkMeta; use aionui_common::{Confirmation, ConfirmationOption}; use serde::{Deserialize, Serialize}; use serde_json::Value; +use std::collections::HashMap; use super::tool_call::{AcpToolCallContentItem, AcpToolCallKind, AcpToolCallLocationItem, AcpToolCallStatus}; @@ -101,9 +102,58 @@ impl AcpPermissionRequestData { .map(|opt| ConfirmationOption { label: opt.name.clone(), value: Value::String(opt.option_id.clone()), - params: None, + params: match opt.kind { + AcpPermissionOptionKind::AllowAlways => { + Some(HashMap::from([("always_allow".into(), "true".into())])) + } + AcpPermissionOptionKind::RejectOnce | AcpPermissionOptionKind::RejectAlways => { + Some(HashMap::from([("decision".into(), "reject".into())])) + } + AcpPermissionOptionKind::AllowOnce => None, + }, }) .collect(), } } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn confirmation_preserves_approval_semantics() { + let request = AcpPermissionRequestData { + session_id: "session".into(), + tool_call: AcpPermissionToolCall { + tool_call_id: "call".into(), + status: None, + title: None, + kind: Some(AcpToolCallKind::Execute), + raw_input: None, + raw_output: None, + content: None, + locations: None, + meta: None, + }, + options: vec![ + AcpPermissionOptionData { + option_id: "always".into(), + name: "Always allow".into(), + kind: AcpPermissionOptionKind::AllowAlways, + meta: None, + }, + AcpPermissionOptionData { + option_id: "reject".into(), + name: "Reject".into(), + kind: AcpPermissionOptionKind::RejectOnce, + meta: None, + }, + ], + meta: None, + }; + let options = request.to_confirmation().options; + assert_eq!(options[0].params.as_ref().unwrap()["always_allow"], "true"); + assert_eq!(options[1].params.as_ref().unwrap()["decision"], "reject"); + } +} diff --git a/crates/aionui-ai-agent/src/registry.rs b/crates/aionui-ai-agent/src/registry.rs index 0f133e5de..b15116c4e 100644 --- a/crates/aionui-ai-agent/src/registry.rs +++ b/crates/aionui-ai-agent/src/registry.rs @@ -378,10 +378,13 @@ impl AgentRegistry { native_skills_dirs: meta.native_skills_dirs, behavior_policy: meta.behavior_policy, yolo_id: meta.yolo_id, + agent_capabilities: handshake.agent_capabilities.clone(), + auth_methods: handshake.auth_methods.clone(), config_options: handshake.config_options.clone(), available_modes: handshake.available_modes.clone(), available_models: handshake.available_models.clone(), available_commands: handshake.available_commands.clone(), + dynamic_probe: handshake.dynamic_probe.clone(), sort_order: meta.sort_order, team_capable: meta.team_capable, status, @@ -429,10 +432,13 @@ impl AgentRegistry { native_skills_dirs: meta.native_skills_dirs, behavior_policy: meta.behavior_policy, yolo_id: meta.yolo_id, + agent_capabilities: handshake.agent_capabilities.clone(), + auth_methods: handshake.auth_methods.clone(), config_options: handshake.config_options.clone(), available_modes: handshake.available_modes.clone(), available_models: handshake.available_models.clone(), available_commands: handshake.available_commands.clone(), + dynamic_probe: handshake.dynamic_probe.clone(), sort_order: meta.sort_order, team_capable: meta.team_capable, status, @@ -551,6 +557,7 @@ fn decode_row( available_modes: parse_json(row.available_modes.as_deref(), "available_modes"), available_models: parse_json(row.available_models.as_deref(), "available_models"), available_commands: parse_json(row.available_commands.as_deref(), "available_commands"), + dynamic_probe: decode_json_field(row.dynamic_probe_result.as_deref(), "dynamic_probe_result"), }; let backend_str = row.backend.as_deref().unwrap_or(""); @@ -1658,6 +1665,7 @@ mod tests { last_check_at: None, last_success_at: None, last_failure_at: None, + dynamic_probe_result: None, env_override: None, created_at: 0, updated_at: 0, @@ -1704,6 +1712,7 @@ mod tests { last_check_at: None, last_success_at: None, last_failure_at: None, + dynamic_probe_result: None, env_override: Some( r#"[{"name":"ANTHROPIC_API_KEY","value":"sk-x"},{"name":"PATH","value":"/evil"}]"#.to_string(), ), @@ -1759,6 +1768,7 @@ mod tests { last_check_at: None, last_success_at: None, last_failure_at: None, + dynamic_probe_result: None, env_override: Some( r#"[{"name":"ANTHROPIC_API_KEY","value":"sk-x","description":""},{"name":"PATH","value":"/evil","description":""}]"#.to_string(), ), diff --git a/crates/aionui-ai-agent/src/registry_tests.rs b/crates/aionui-ai-agent/src/registry_tests.rs index dea60850a..1a101ca40 100644 --- a/crates/aionui-ai-agent/src/registry_tests.rs +++ b/crates/aionui-ai-agent/src/registry_tests.rs @@ -433,8 +433,8 @@ async fn management_rows_project_runtime_catalogs_from_agent_metadata() { native_skills_dirs: None, behavior_policy: None, yolo_id: None, - agent_capabilities: None, - auth_methods: None, + agent_capabilities: Some(r#"{"loadSession":true,"promptCapabilities":{"image":true}}"#), + auth_methods: Some(r#"[{"id":"oauth","name":"OAuth"}]"#), config_options: Some( r#"{"config_options":[{"id":"model","type":"select","category":"model","options":[{"value":"claude-opus","label":"Claude Opus"}],"current_value":"claude-opus"}]}"#, ), diff --git a/crates/aionui-ai-agent/src/routes/agent.rs b/crates/aionui-ai-agent/src/routes/agent.rs index ad6614cd4..ef808694b 100644 --- a/crates/aionui-ai-agent/src/routes/agent.rs +++ b/crates/aionui-ai-agent/src/routes/agent.rs @@ -4,12 +4,13 @@ //! //! Endpoints: //! +//! - `GET /api/agents` — list picker-safe agent metadata rows //! - `GET /api/agents/management` — list diagnostics-first agent rows //! - `POST /api/agents/custom/try-connect` — test custom agent configuration (e.g. ACP connection) use axum::Router; use axum::extract::rejection::JsonRejection; -use axum::extract::{Extension, Json, Path, State}; +use axum::extract::{Extension, Json, Path, Query, State}; use axum::routing::{get, patch, post, put}; use aionui_api_types::{ @@ -23,8 +24,15 @@ use aionui_common::ApiError; use crate::routes::error_mapping::agent_error_to_api_error; use crate::routes::state::AgentRouterState; +#[derive(Debug, Default, serde::Deserialize)] +struct ListAgentsQuery { + #[serde(default)] + include_disabled: bool, +} + pub fn agent_routes(state: AgentRouterState) -> Router { Router::new() + .route("/api/agents", get(list_agents)) .route("/api/agents/logos", get(list_agent_logos)) .route("/api/agents/management", get(list_management_agents)) .route("/api/agents/{id}/health-check", post(health_check_by_id)) @@ -40,6 +48,20 @@ pub fn agent_routes(state: AgentRouterState) -> Router { .with_state(state) } +async fn list_agents( + State(state): State, + Extension(_user): Extension, + Query(query): Query, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .list_agents(query.include_disabled) + .await + .map_err(agent_error_to_api_error)?, + ))) +} + async fn list_agent_logos( State(state): State, Extension(_user): Extension, diff --git a/crates/aionui-ai-agent/src/services/agent.rs b/crates/aionui-ai-agent/src/services/agent.rs index c0789d81b..ddb2b319c 100644 --- a/crates/aionui-ai-agent/src/services/agent.rs +++ b/crates/aionui-ai-agent/src/services/agent.rs @@ -15,7 +15,9 @@ use std::path::PathBuf; use std::sync::Arc; -use aionui_api_types::{AgentLogoEntry, AgentManagementRow, ProviderHealthCheckRequest, ProviderHealthCheckResponse}; +use aionui_api_types::{ + AgentLogoEntry, AgentManagementRow, AgentMetadata, ProviderHealthCheckRequest, ProviderHealthCheckResponse, +}; use aionui_db::IProviderRepository; use aionui_realtime::EventBroadcaster; @@ -40,7 +42,7 @@ impl AgentService { data_dir: PathBuf, ) -> Arc { let provider_health = ProviderHealthCheckService::new(provider_repo.clone(), encryption_key, data_dir.clone()); - let availability = AgentAvailabilityService::new(registry.clone(), provider_repo); + let availability = AgentAvailabilityService::new(registry.clone(), provider_repo, data_dir); Arc::new(Self { registry, broadcaster, @@ -66,6 +68,18 @@ impl AgentService { // Agent operations impl AgentService { + pub async fn list_agents(&self, include_disabled: bool) -> Result, AgentError> { + let rows = if include_disabled { + self.registry.list_all_including_hidden().await + } else { + self.registry.list_all().await + }; + Ok(rows + .into_iter() + .filter(|agent| agent.agent_type.supports_new_conversation()) + .collect()) + } + pub async fn list_management_agents(&self) -> Result, AgentError> { Ok(self.availability.list_management_rows().await) } diff --git a/crates/aionui-ai-agent/src/services/availability/dynamic_probe.rs b/crates/aionui-ai-agent/src/services/availability/dynamic_probe.rs new file mode 100644 index 000000000..6c7f86de2 --- /dev/null +++ b/crates/aionui-ai-agent/src/services/availability/dynamic_probe.rs @@ -0,0 +1,258 @@ +use std::collections::HashSet; +use std::sync::Arc; +use std::time::Duration; +use std::time::Instant; + +use aionui_api_types::{ + AgentDynamicProbeResult, AgentProbeErrorCategory, AgentProbeStatus, AgentProbeStep, AgentProbeStepResult, +}; +use aionui_common::now_ms; + +/// A normalized failure safe to expose outside the Agent adapter boundary. +#[derive(Debug, Clone)] +pub struct DynamicProbeFailure { + pub category: AgentProbeErrorCategory, + pub status: AgentProbeStatus, + pub message: String, +} + +impl DynamicProbeFailure { + pub fn new(category: AgentProbeErrorCategory, message: impl Into) -> Self { + Self { + category, + status: AgentProbeStatus::Failed, + message: message.into(), + } + } + + pub fn unsupported(message: impl Into) -> Self { + Self { + category: AgentProbeErrorCategory::Protocol, + status: AgentProbeStatus::Unsupported, + message: message.into(), + } + } + + pub fn timed_out(message: impl Into) -> Self { + Self { + category: AgentProbeErrorCategory::Timeout, + status: AgentProbeStatus::TimedOut, + message: message.into(), + } + } +} + +/// Adapter boundary used by dynamic preflight. Implementations own their +/// throwaway process/session and must clean it up on drop. +#[async_trait::async_trait] +pub trait DynamicProbeSession: Send { + async fn initialize(&mut self) -> Result<(), DynamicProbeFailure>; + async fn models(&mut self) -> Result, DynamicProbeFailure>; + async fn minimal_prompt(&mut self) -> Result<(), DynamicProbeFailure>; + async fn cancel(&mut self) -> Result<(), DynamicProbeFailure>; + async fn resume(&mut self) -> Result<(), DynamicProbeFailure>; +} + +#[async_trait::async_trait] +pub trait DynamicProbeSessionFactory: Send + Sync { + async fn spawn(&self, agent_id: &str) -> Result, DynamicProbeFailure>; +} + +#[derive(Clone)] +pub struct DynamicAgentProbe { + factory: Arc, + step_timeout: Duration, +} + +impl DynamicAgentProbe { + pub fn new(factory: Arc) -> Self { + Self { + factory, + step_timeout: Duration::from_secs(30), + } + } + + pub fn with_step_timeout(mut self, step_timeout: Duration) -> Self { + self.step_timeout = step_timeout; + self + } + + pub async fn run(&self, agent_id: &str) -> AgentDynamicProbeResult { + let checked_at = now_ms(); + let mut steps = Vec::with_capacity(6); + let spawn_started = now_ms(); + let spawn_timer = Instant::now(); + let mut session = match tokio::time::timeout(self.step_timeout, self.factory.spawn(agent_id)).await { + Err(_) => { + steps.push(failed( + AgentProbeStep::Spawn, + spawn_started, + spawn_timer, + DynamicProbeFailure::timed_out("Agent spawn timed out"), + )); + return result(agent_id, checked_at, steps, Vec::new()); + } + Ok(session) => match session { + Ok(session) => { + steps.push(passed(AgentProbeStep::Spawn, spawn_started, spawn_timer)); + session + } + Err(error) => { + steps.push(failed(AgentProbeStep::Spawn, spawn_started, spawn_timer, error)); + return result(agent_id, checked_at, steps, Vec::new()); + } + }, + }; + + if run_step( + &mut steps, + AgentProbeStep::Initialize, + self.step_timeout, + session.initialize(), + ) + .await + .is_err() + { + return result(agent_id, checked_at, steps, Vec::new()); + } + + let models_started = now_ms(); + let models_timer = Instant::now(); + let mut available_models = match tokio::time::timeout(self.step_timeout, session.models()).await { + Ok(Ok(models)) => { + steps.push(passed(AgentProbeStep::Models, models_started, models_timer)); + deduplicate_models(models) + } + Ok(Err(error)) => { + steps.push(failed(AgentProbeStep::Models, models_started, models_timer, error)); + return result(agent_id, checked_at, steps, Vec::new()); + } + Err(_) => { + steps.push(failed( + AgentProbeStep::Models, + models_started, + models_timer, + DynamicProbeFailure::timed_out("Agent model discovery timed out"), + )); + return result(agent_id, checked_at, steps, Vec::new()); + } + }; + + if run_step( + &mut steps, + AgentProbeStep::MinimalPrompt, + self.step_timeout, + session.minimal_prompt(), + ) + .await + .is_err() + { + available_models.clear(); + return result(agent_id, checked_at, steps, available_models); + } + if run_step(&mut steps, AgentProbeStep::Cancel, self.step_timeout, session.cancel()) + .await + .is_err() + { + available_models.clear(); + return result(agent_id, checked_at, steps, available_models); + } + + // Resume is optional in ACP. Record unsupported explicitly without + // making an otherwise healthy Agent unusable. + let _ = run_step(&mut steps, AgentProbeStep::Resume, self.step_timeout, session.resume()).await; + result(agent_id, checked_at, steps, available_models) + } +} + +async fn run_step( + steps: &mut Vec, + step: AgentProbeStep, + timeout: Duration, + future: F, +) -> Result<(), ()> +where + F: std::future::Future>, +{ + let started_at = now_ms(); + let timer = Instant::now(); + match tokio::time::timeout(timeout, future).await { + Ok(Ok(())) => { + steps.push(passed(step, started_at, timer)); + Ok(()) + } + Ok(Err(error)) => { + steps.push(failed(step, started_at, timer, error)); + Err(()) + } + Err(_) => { + steps.push(failed( + step, + started_at, + timer, + DynamicProbeFailure::timed_out("Agent probe step timed out"), + )); + Err(()) + } + } +} + +fn passed(step: AgentProbeStep, started_at: i64, timer: Instant) -> AgentProbeStepResult { + AgentProbeStepResult { + step, + status: AgentProbeStatus::Passed, + started_at, + duration_ms: timer.elapsed().as_millis() as i64, + error_category: None, + error_message: None, + } +} + +fn failed(step: AgentProbeStep, started_at: i64, timer: Instant, error: DynamicProbeFailure) -> AgentProbeStepResult { + AgentProbeStepResult { + step, + status: error.status, + started_at, + duration_ms: timer.elapsed().as_millis() as i64, + error_category: Some(error.category), + error_message: Some(safe_message(error.category)), + } +} + +fn safe_message(category: AgentProbeErrorCategory) -> String { + match category { + AgentProbeErrorCategory::Authentication => "provider authentication failed", + AgentProbeErrorCategory::ModelRejected => "the selected model was rejected", + AgentProbeErrorCategory::Protocol => "the Agent does not support this protocol operation", + AgentProbeErrorCategory::Startup => "the Agent failed to start", + AgentProbeErrorCategory::Timeout => "the Agent operation timed out", + AgentProbeErrorCategory::RateLimited => "the provider rate limit was reached", + AgentProbeErrorCategory::Permission => "the Agent requires a permission that was not granted", + AgentProbeErrorCategory::RuntimeMissing => "the required Agent runtime is unavailable", + AgentProbeErrorCategory::Unknown => "the Agent probe failed", + } + .to_owned() +} + +fn deduplicate_models(models: Vec) -> Vec { + let mut seen = HashSet::new(); + models + .into_iter() + .filter(|model| !model.trim().is_empty()) + .filter(|model| seen.insert(model.clone())) + .collect() +} + +fn result( + agent_id: &str, + checked_at: i64, + steps: Vec, + available_models: Vec, +) -> AgentDynamicProbeResult { + AgentDynamicProbeResult { + agent_id: agent_id.to_owned(), + checked_at, + steps, + available_models, + } +} diff --git a/crates/aionui-ai-agent/src/services/availability/mod.rs b/crates/aionui-ai-agent/src/services/availability/mod.rs index c47acdf9b..a4ed66cc8 100644 --- a/crates/aionui-ai-agent/src/services/availability/mod.rs +++ b/crates/aionui-ai-agent/src/services/availability/mod.rs @@ -1,14 +1,15 @@ use std::collections::HashMap; +use std::path::PathBuf; use std::sync::Arc; use std::time::Instant; use aionui_api_types::{ - AgentManagementRow, AgentMetadata, AgentSnapshotCheckKind, AgentSnapshotCheckStatus, AgentSource, - TryConnectCustomAgentResponse, + AgentDynamicProbeResult, AgentManagementRow, AgentMetadata, AgentProbeStatus, AgentSnapshotCheckKind, + AgentSnapshotCheckStatus, AgentSource, TryConnectCustomAgentResponse, }; use aionui_common::now_ms; use aionui_common::{AgentType, CommandSpec, EnvVar}; -use aionui_db::{IProviderRepository, UpdateAgentAvailabilitySnapshotParams}; +use aionui_db::{IProviderRepository, UpdateAgentAvailabilitySnapshotParams, UpdateAgentHandshakeParams}; use aionui_runtime::{ ManagedAcpToolId, ensure_managed_acp_tool_with_reporter, ensure_node_runtime_with_reporter, resolve_command_path, }; @@ -18,6 +19,8 @@ use crate::error::AgentError; use crate::protocol::{cli_detect, custom_agent_probe}; use crate::registry::{AgentRegistry, guidance_for_snapshot_error_code}; +pub mod dynamic_probe; + #[async_trait::async_trait] pub trait AgentAvailabilityFeedbackPort: Send + Sync { async fn record_session_success(&self, agent_id: &str) -> Result<(), AgentError>; @@ -39,13 +42,15 @@ pub struct AgentAvailabilityService { // Used to decide aionrs (built-in, no external CLI) availability: it is // usable only when at least one model provider is configured & enabled. provider_repo: Arc, + data_dir: PathBuf, } impl AgentAvailabilityService { - pub fn new(registry: Arc, provider_repo: Arc) -> Self { + pub fn new(registry: Arc, provider_repo: Arc, data_dir: PathBuf) -> Self { Self { registry, provider_repo, + data_dir, } } @@ -67,14 +72,40 @@ impl AgentAvailabilityService { .ok_or_else(|| AgentError::not_found(format!("Agent '{id}' not found"))); } - let snapshot = run_probe( + let mut snapshot = run_probe( &self.registry, &self.provider_repo, &meta, AgentSnapshotCheckKind::Manual, ) .await; - self.persist_snapshot(id, &snapshot).await?; + let dynamic_probe = if snapshot.status == "online" { + run_dynamic_probe(&meta, &self.data_dir).await + } else { + None + }; + if let Some(result) = dynamic_probe.as_ref() { + if !result.is_usable() { + snapshot.status = "offline"; + snapshot.error_code = Some("dynamic_probe_failed".to_owned()); + snapshot.error_message = Some(dynamic_probe_failure_message(result)); + } else { + let models_json = serde_json::to_string(&result.available_models) + .map_err(|error| AgentError::internal(format!("encode probed models: {error}")))?; + self.registry + .repo_handle() + .apply_handshake( + id, + &UpdateAgentHandshakeParams { + available_models: Some(Some(&models_json)), + ..Default::default() + }, + ) + .await + .map_err(|error| AgentError::internal(format!("repo.apply_handshake: {error}")))?; + } + } + self.persist_snapshot(id, &snapshot, dynamic_probe.as_ref()).await?; self.management_row_by_id(id) .await .ok_or_else(|| AgentError::not_found(format!("Agent '{id}' not found"))) @@ -90,7 +121,7 @@ impl AgentAvailabilityService { latency_ms: 0, checked_at, }; - self.persist_snapshot(agent_id, &snapshot).await + self.persist_snapshot(agent_id, &snapshot, None).await } pub async fn record_session_success(&self, agent_id: &str) -> Result<(), AgentError> { @@ -103,14 +134,19 @@ impl AgentAvailabilityService { latency_ms: 0, checked_at, }; - self.persist_snapshot(agent_id, &snapshot).await + self.persist_snapshot(agent_id, &snapshot, None).await } pub async fn management_row_by_id(&self, id: &str) -> Option { self.registry.management_row_by_id(id).await } - async fn persist_snapshot(&self, id: &str, snapshot: &AvailabilitySnapshot) -> Result<(), AgentError> { + async fn persist_snapshot( + &self, + id: &str, + snapshot: &AvailabilitySnapshot, + dynamic_probe: Option<&AgentDynamicProbeResult>, + ) -> Result<(), AgentError> { let existing = self .registry .repo_handle() @@ -119,6 +155,8 @@ impl AgentAvailabilityService { .map_err(|error| AgentError::internal(format!("repo.get: {error}")))? .ok_or_else(|| AgentError::not_found(format!("Agent '{id}' not found")))?; + let dynamic_probe_json = probe_snapshot_to_persist(existing.dynamic_probe_result.as_deref(), dynamic_probe) + .map_err(|error| AgentError::internal(format!("encode dynamic probe: {error}")))?; let params = UpdateAgentAvailabilitySnapshotParams { last_check_status: Some(snapshot.status), last_check_kind: Some(snapshot.kind), @@ -140,6 +178,7 @@ impl AgentAvailabilityService { } else { existing.last_failure_at }, + dynamic_probe_result: dynamic_probe_json.as_deref(), }; self.registry .repo_handle() @@ -151,6 +190,37 @@ impl AgentAvailabilityService { } } +/// `dynamic_probe_result` is the last *successful* six-stage probe. The latest +/// failed attempt is represented by the availability error fields, while the +/// successful snapshot remains available for diagnostics and model menus. +fn probe_snapshot_to_persist( + existing: Option<&str>, + candidate: Option<&AgentDynamicProbeResult>, +) -> Result, serde_json::Error> { + match candidate.filter(|probe| probe.is_usable()) { + Some(probe) => serde_json::to_string(probe).map(Some), + None => Ok(existing.map(str::to_owned)), + } +} + +fn dynamic_probe_failure_message(result: &AgentDynamicProbeResult) -> String { + result + .steps + .iter() + .find(|step| !matches!(step.status, AgentProbeStatus::Passed | AgentProbeStatus::Unsupported)) + .map(|step| { + let message = step.error_message.as_deref().unwrap_or("no diagnostic message"); + match step.error_category.as_ref() { + Some(category) => format!( + "Agent dynamic preflight failed at {:?} ({category:?}): {message}", + step.step + ), + None => format!("Agent dynamic preflight failed at {:?}: {message}", step.step), + } + }) + .unwrap_or_else(|| "Agent failed the dynamic capability preflight".to_owned()) +} + async fn run_probe( registry: &Arc, provider_repo: &Arc, @@ -295,33 +365,77 @@ async fn probe_aionrs_provider_readiness( } } +async fn run_dynamic_probe(meta: &AgentMetadata, data_dir: &std::path::Path) -> Option { + if meta.agent_type != AgentType::Acp { + return None; + } + + if meta.agent_source == AgentSource::Builtin + && let Some(backend) = meta.backend.as_deref() + && let Some(tool) = ManagedAcpToolId::from_backend(backend) + { + let spec = build_builtin_managed_agent_spec(meta, tool).await.ok()?; + return Some(custom_agent_probe::dynamic_probe_command_spec(&meta.id, spec, data_dir).await); + } + + let command = meta.command.as_deref()?; + let env: HashMap = meta + .env + .iter() + .map(|entry| (entry.name.clone(), entry.value.clone())) + .collect(); + Some(custom_agent_probe::dynamic_probe_custom_agent(&meta.id, command, &meta.args, &env, data_dir).await) +} + async fn try_connect_builtin_managed_agent( meta: &AgentMetadata, tool: ManagedAcpToolId, ) -> TryConnectCustomAgentResponse { + let spec = match build_builtin_managed_agent_spec(meta, tool).await { + Ok(spec) => spec, + Err(error) => return error, + }; + + match tokio::time::timeout( + Duration::from_secs(35), + custom_agent_probe::acp_probe_command_spec(spec), + ) + .await + { + Ok(response) => response, + Err(_) => TryConnectCustomAgentResponse::FailAcp { + error: "ACP handshake did not complete within 35s".to_owned(), + }, + } +} + +async fn build_builtin_managed_agent_spec( + meta: &AgentMetadata, + tool: ManagedAcpToolId, +) -> Result { if let Some(primary) = meta.agent_source_info.binary_name.as_deref() && resolve_command_path(primary).is_none() { - return TryConnectCustomAgentResponse::FailCli { + return Err(TryConnectCustomAgentResponse::FailCli { error: format!("`{primary}` not found on PATH"), - }; + }); } let node_runtime = match ensure_node_runtime_with_reporter(None).await { Ok(runtime) => runtime, Err(error) => { - return TryConnectCustomAgentResponse::FailCli { + return Err(TryConnectCustomAgentResponse::FailCli { error: error.to_string(), - }; + }); } }; let managed_tool = match ensure_managed_acp_tool_with_reporter(tool, None).await { Ok(tool) => tool, Err(error) => { - return TryConnectCustomAgentResponse::FailCli { + return Err(TryConnectCustomAgentResponse::FailCli { error: error.to_string(), - }; + }); } }; @@ -339,7 +453,7 @@ async fn try_connect_builtin_managed_agent( value: value.to_string_lossy().into_owned(), })); - let spec = CommandSpec { + Ok(CommandSpec { command: resolved.program, args: resolved .args_prefix @@ -348,19 +462,7 @@ async fn try_connect_builtin_managed_agent( .collect(), env, cwd: Some(std::env::temp_dir().to_string_lossy().into_owned()), - }; - - match tokio::time::timeout( - Duration::from_secs(35), - custom_agent_probe::acp_probe_command_spec(spec), - ) - .await - { - Ok(response) => response, - Err(_) => TryConnectCustomAgentResponse::FailAcp { - error: "ACP handshake did not complete within 35s".to_owned(), - }, - } + }) } #[async_trait::async_trait] @@ -378,7 +480,10 @@ impl AgentAvailabilityFeedbackPort for AgentAvailabilityService { mod tests { use std::sync::Arc; - use super::{AgentAvailabilityService, explicit_probe_args, probe_aionrs_provider_readiness, run_probe}; + use super::{ + AgentAvailabilityService, dynamic_probe_failure_message, explicit_probe_args, probe_aionrs_provider_readiness, + probe_snapshot_to_persist, run_probe, + }; use crate::registry::AgentRegistry; use aionui_api_types::{ AgentHandshake, AgentManagementStatus, AgentMetadata, AgentSnapshotCheckKind, AgentSnapshotCheckStatus, @@ -410,6 +515,73 @@ mod tests { } } + #[test] + fn failed_probe_preserves_the_last_successful_probe_snapshot() { + use aionui_api_types::{AgentDynamicProbeResult, AgentProbeStatus, AgentProbeStep, AgentProbeStepResult}; + + let existing = r#"{"agent_id":"codex","checked_at":1,"steps":[],"available_models":["gpt-5"]}"#; + let failed = AgentDynamicProbeResult { + agent_id: "codex".into(), + checked_at: 2, + steps: vec![AgentProbeStepResult { + step: AgentProbeStep::Spawn, + status: AgentProbeStatus::Failed, + started_at: 2, + duration_ms: 1, + error_category: None, + error_message: None, + }], + available_models: vec![], + }; + + assert_eq!( + probe_snapshot_to_persist(Some(existing), Some(&failed)) + .unwrap() + .as_deref(), + Some(existing) + ); + assert_eq!( + probe_snapshot_to_persist(Some(existing), None).unwrap().as_deref(), + Some(existing) + ); + } + + #[test] + fn failed_probe_exposes_the_sanitized_failed_stage_diagnostic() { + use aionui_api_types::{ + AgentDynamicProbeResult, AgentProbeErrorCategory, AgentProbeStatus, AgentProbeStep, AgentProbeStepResult, + }; + + let failed = AgentDynamicProbeResult { + agent_id: "codex".into(), + checked_at: 2, + steps: vec![ + AgentProbeStepResult { + step: AgentProbeStep::Spawn, + status: AgentProbeStatus::Passed, + started_at: 2, + duration_ms: 1, + error_category: None, + error_message: None, + }, + AgentProbeStepResult { + step: AgentProbeStep::MinimalPrompt, + status: AgentProbeStatus::Failed, + started_at: 3, + duration_ms: 5, + error_category: Some(AgentProbeErrorCategory::ModelRejected), + error_message: Some("Agent rejected the configured model".into()), + }, + ], + available_models: vec![], + }; + + assert_eq!( + dynamic_probe_failure_message(&failed), + "Agent dynamic preflight failed at MinimalPrompt (ModelRejected): Agent rejected the configured model" + ); + } + #[tokio::test] async fn aionrs_is_offline_without_an_enabled_provider() { let db = init_database_memory().await.unwrap(); @@ -471,7 +643,7 @@ mod tests { registry.hydrate().await.unwrap(); let provider_repo: Arc = Arc::new(SqliteProviderRepository::new(db.pool().clone())); - let service = AgentAvailabilityService::new(registry.clone(), provider_repo); + let service = AgentAvailabilityService::new(registry.clone(), provider_repo, std::env::temp_dir()); service .record_session_failure( "agent-session-failure", @@ -543,7 +715,7 @@ mod tests { registry.hydrate().await.unwrap(); let provider_repo: Arc = Arc::new(SqliteProviderRepository::new(db.pool().clone())); - let service = AgentAvailabilityService::new(registry.clone(), provider_repo); + let service = AgentAvailabilityService::new(registry.clone(), provider_repo, std::env::temp_dir()); service .record_session_failure( "agent-session-success", diff --git a/crates/aionui-ai-agent/src/services/mod.rs b/crates/aionui-ai-agent/src/services/mod.rs index 48218d950..221a32c40 100644 --- a/crates/aionui-ai-agent/src/services/mod.rs +++ b/crates/aionui-ai-agent/src/services/mod.rs @@ -6,4 +6,7 @@ pub mod remote; pub use agent::AgentService; pub use availability::AgentAvailabilityFeedbackPort; +pub use availability::dynamic_probe::{ + DynamicAgentProbe, DynamicProbeFailure, DynamicProbeSession, DynamicProbeSessionFactory, +}; pub use remote::RemoteAgentService; diff --git a/crates/aionui-ai-agent/tests/agent_availability_integration.rs b/crates/aionui-ai-agent/tests/agent_availability_integration.rs index e799e0d8e..2908654c4 100644 --- a/crates/aionui-ai-agent/tests/agent_availability_integration.rs +++ b/crates/aionui-ai-agent/tests/agent_availability_integration.rs @@ -98,6 +98,7 @@ async fn management_rows_derive_missing_available_and_unavailable_statuses() { last_check_at: Some(1_750_000_000_000), last_success_at: None, last_failure_at: Some(1_750_000_000_000), + dynamic_probe_result: None, }, ) .await @@ -115,6 +116,7 @@ async fn management_rows_derive_missing_available_and_unavailable_statuses() { last_check_at: Some(1_750_000_100_000), last_success_at: Some(1_750_000_100_000), last_failure_at: None, + dynamic_probe_result: None, }, ) .await @@ -178,6 +180,7 @@ async fn hydrate_refreshes_installation_without_rerunning_health_check() { last_check_at: Some(1_750_000_100_000), last_success_at: Some(1_750_000_100_000), last_failure_at: None, + dynamic_probe_result: None, }, ) .await @@ -241,6 +244,7 @@ async fn hydrate_refreshes_commandless_managed_builtin_installation() { last_check_at: Some(1_750_000_100_000), last_success_at: Some(1_750_000_100_000), last_failure_at: None, + dynamic_probe_result: None, }, ) .await diff --git a/crates/aionui-ai-agent/tests/agent_dynamic_probe.rs b/crates/aionui-ai-agent/tests/agent_dynamic_probe.rs new file mode 100644 index 000000000..3c2a6c014 --- /dev/null +++ b/crates/aionui-ai-agent/tests/agent_dynamic_probe.rs @@ -0,0 +1,184 @@ +use std::sync::Arc; +use std::time::Duration; + +use aionui_ai_agent::{DynamicAgentProbe, DynamicProbeFailure, DynamicProbeSession, DynamicProbeSessionFactory}; +use aionui_api_types::{AgentProbeErrorCategory, AgentProbeStatus, AgentProbeStep}; + +struct HealthyFactory; + +struct HealthySession; + +#[async_trait::async_trait] +impl DynamicProbeSessionFactory for HealthyFactory { + async fn spawn(&self, _agent_id: &str) -> Result, DynamicProbeFailure> { + Ok(Box::new(HealthySession)) + } +} + +#[async_trait::async_trait] +impl DynamicProbeSession for HealthySession { + async fn initialize(&mut self) -> Result<(), DynamicProbeFailure> { + Ok(()) + } + + async fn models(&mut self) -> Result, DynamicProbeFailure> { + Ok(vec!["model-a".into(), "model-b".into()]) + } + + async fn minimal_prompt(&mut self) -> Result<(), DynamicProbeFailure> { + Ok(()) + } + + async fn cancel(&mut self) -> Result<(), DynamicProbeFailure> { + Ok(()) + } + + async fn resume(&mut self) -> Result<(), DynamicProbeFailure> { + Err(DynamicProbeFailure::unsupported("session/resume is not advertised")) + } +} + +#[tokio::test] +async fn probe_records_all_steps_in_order_and_only_observed_models() { + let probe = DynamicAgentProbe::new(Arc::new(HealthyFactory)); + + let result = probe.run("codex").await; + + assert_eq!(result.agent_id, "codex"); + assert_eq!(result.available_models, vec!["model-a", "model-b"]); + assert!(result.checked_at > 0); + assert_eq!( + result.steps.iter().map(|step| step.step).collect::>(), + vec![ + AgentProbeStep::Spawn, + AgentProbeStep::Initialize, + AgentProbeStep::Models, + AgentProbeStep::MinimalPrompt, + AgentProbeStep::Cancel, + AgentProbeStep::Resume, + ] + ); + assert!(result.steps.iter().all(|step| step.started_at > 0)); + assert!(result.steps.iter().all(|step| step.duration_ms >= 0)); + assert_eq!(result.steps[4].status, AgentProbeStatus::Passed); + assert_eq!(result.steps[5].status, AgentProbeStatus::Unsupported); + assert_eq!(result.steps[5].error_category, Some(AgentProbeErrorCategory::Protocol)); + assert!(result.is_usable()); +} + +struct AuthFailureFactory; + +#[async_trait::async_trait] +impl DynamicProbeSessionFactory for AuthFailureFactory { + async fn spawn(&self, _agent_id: &str) -> Result, DynamicProbeFailure> { + Err(DynamicProbeFailure::new( + AgentProbeErrorCategory::Authentication, + "token sk-live-secret was rejected", + )) + } +} + +#[tokio::test] +async fn probe_normalizes_failure_and_redacts_provider_output() { + let probe = DynamicAgentProbe::new(Arc::new(AuthFailureFactory)); + + let result = probe.run("claude").await; + + assert!(result.available_models.is_empty()); + assert_eq!(result.steps.len(), 1); + assert_eq!(result.steps[0].step, AgentProbeStep::Spawn); + assert_eq!(result.steps[0].status, AgentProbeStatus::Failed); + assert_eq!( + result.steps[0].error_category, + Some(AgentProbeErrorCategory::Authentication) + ); + assert_eq!( + result.steps[0].error_message.as_deref(), + Some("provider authentication failed") + ); + assert!(!result.is_usable()); +} + +struct SlowFactory; + +#[async_trait::async_trait] +impl DynamicProbeSessionFactory for SlowFactory { + async fn spawn(&self, _agent_id: &str) -> Result, DynamicProbeFailure> { + tokio::time::sleep(Duration::from_millis(50)).await; + Ok(Box::new(HealthySession)) + } +} + +#[tokio::test] +async fn probe_classifies_step_timeout_without_leaking_adapter_output() { + let probe = DynamicAgentProbe::new(Arc::new(SlowFactory)).with_step_timeout(Duration::from_millis(5)); + + let result = probe.run("slow-agent").await; + + assert_eq!(result.steps.len(), 1); + assert_eq!(result.steps[0].step, AgentProbeStep::Spawn); + assert_eq!(result.steps[0].status, AgentProbeStatus::TimedOut); + assert_eq!(result.steps[0].error_category, Some(AgentProbeErrorCategory::Timeout)); + assert_eq!( + result.steps[0].error_message.as_deref(), + Some("the Agent operation timed out") + ); + assert!(!result.is_usable()); +} + +struct RejectedModelFactory; + +struct RejectedModelSession; + +#[async_trait::async_trait] +impl DynamicProbeSessionFactory for RejectedModelFactory { + async fn spawn(&self, _agent_id: &str) -> Result, DynamicProbeFailure> { + Ok(Box::new(RejectedModelSession)) + } +} + +#[async_trait::async_trait] +impl DynamicProbeSession for RejectedModelSession { + async fn initialize(&mut self) -> Result<(), DynamicProbeFailure> { + Ok(()) + } + + async fn models(&mut self) -> Result, DynamicProbeFailure> { + Err(DynamicProbeFailure::new( + AgentProbeErrorCategory::ModelRejected, + "provider rejected model private-model-name", + )) + } + + async fn minimal_prompt(&mut self) -> Result<(), DynamicProbeFailure> { + unreachable!("model rejection must stop the probe") + } + + async fn cancel(&mut self) -> Result<(), DynamicProbeFailure> { + unreachable!("model rejection must stop the probe") + } + + async fn resume(&mut self) -> Result<(), DynamicProbeFailure> { + unreachable!("model rejection must stop the probe") + } +} + +#[tokio::test] +async fn probe_classifies_rejected_model_and_exposes_no_unverified_models() { + let probe = DynamicAgentProbe::new(Arc::new(RejectedModelFactory)); + + let result = probe.run("codex").await; + + assert!(result.available_models.is_empty()); + assert_eq!(result.steps.len(), 3); + assert_eq!(result.steps[2].step, AgentProbeStep::Models); + assert_eq!(result.steps[2].status, AgentProbeStatus::Failed); + assert_eq!( + result.steps[2].error_category, + Some(AgentProbeErrorCategory::ModelRejected) + ); + assert_eq!( + result.steps[2].error_message.as_deref(), + Some("the selected model was rejected") + ); +} diff --git a/crates/aionui-ai-agent/tests/agent_runner.rs b/crates/aionui-ai-agent/tests/agent_runner.rs new file mode 100644 index 000000000..900c693d4 --- /dev/null +++ b/crates/aionui-ai-agent/tests/agent_runner.rs @@ -0,0 +1,113 @@ +use std::time::Duration; + +use aionui_ai_agent::capability::cli_process::CliAgentProcess; +use aionui_common::{CommandSpec, EnvVar}; +use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader}; + +fn env(name: &str, value: &str) -> EnvVar { + EnvVar { + name: name.into(), + value: value.into(), + } +} + +#[tokio::test] +async fn acp_host_process_runs_through_a_named_execution_lease() { + let data_dir = tempfile::tempdir().unwrap(); + let process = CliAgentProcess::spawn_for_sdk_in_data_dir( + CommandSpec { + command: "sh".into(), + args: vec![ + "-c".into(), + "printf '%s\\n' \"$AIONUI_RUNNER_ENVIRONMENT_ID\"; read line".into(), + ], + env: vec![ + env("AIONUI_RUNNER_ENVIRONMENT_KIND", "host"), + env("AIONUI_RUNNER_ENVIRONMENT_ID", "host:test"), + env("AIONUI_EXECUTION_LEASE_ID", "lease-agent-test"), + ], + cwd: None, + }, + data_dir.path(), + ) + .await + .unwrap(); + let (mut stdin, stdout) = process.take_stdio().await.unwrap(); + let mut lines = BufReader::new(stdout).lines(); + assert_eq!(lines.next_line().await.unwrap().as_deref(), Some("host:test")); + stdin.write_all(b"stop\n").await.unwrap(); + drop(stdin); + tokio::time::timeout(Duration::from_secs(2), process.wait_for_exit()) + .await + .unwrap() + .unwrap(); +} + +#[tokio::test] +async fn container_agent_modes_fail_closed_when_the_selected_environment_is_incomplete() { + let data_dir = tempfile::tempdir().unwrap(); + let docker = match CliAgentProcess::spawn_for_sdk_in_data_dir( + CommandSpec { + command: "agent".into(), + args: Vec::new(), + env: vec![env("AIONUI_RUNNER_ENVIRONMENT_KIND", "docker")], + cwd: Some(data_dir.path().to_string_lossy().into_owned()), + }, + data_dir.path(), + ) + .await + { + Ok(process) => { + process.kill(Duration::from_millis(100)).await.unwrap(); + panic!("incomplete Docker runner configuration unexpectedly started") + } + Err(error) => error, + }; + assert!(docker.to_string().contains("container image")); + + let devcontainer = match CliAgentProcess::spawn_for_sdk_in_data_dir( + CommandSpec { + command: "agent".into(), + args: Vec::new(), + env: vec![env("AIONUI_RUNNER_ENVIRONMENT_KIND", "devcontainer")], + cwd: Some(data_dir.path().to_string_lossy().into_owned()), + }, + data_dir.path(), + ) + .await + { + Ok(process) => { + process.kill(Duration::from_millis(100)).await.unwrap(); + panic!("incomplete Dev Container runner configuration unexpectedly started") + } + Err(error) => error, + }; + assert!(devcontainer.to_string().contains("config path")); + + let devcontainer_with_host_secret = match CliAgentProcess::spawn_for_sdk_in_data_dir( + CommandSpec { + command: "agent".into(), + args: Vec::new(), + env: vec![ + env("AIONUI_RUNNER_ENVIRONMENT_KIND", "devcontainer"), + env("AIONUI_RUNNER_DEVCONTAINER_CONFIG", ".devcontainer/devcontainer.json"), + env("AGENT_TOKEN", "must-not-become-a-command-argument"), + ], + cwd: Some(data_dir.path().to_string_lossy().into_owned()), + }, + data_dir.path(), + ) + .await + { + Ok(process) => { + process.kill(Duration::from_millis(100)).await.unwrap(); + panic!("Dev Container runner unexpectedly forwarded a host secret") + } + Err(error) => error, + }; + assert!( + devcontainer_with_host_secret + .to_string() + .contains("provisioned inside the selected container") + ); +} diff --git a/crates/aionui-api-types/src/agent_discovery.rs b/crates/aionui-api-types/src/agent_discovery.rs index 29cfe49a2..d8cce57fc 100644 --- a/crates/aionui-api-types/src/agent_discovery.rs +++ b/crates/aionui-api-types/src/agent_discovery.rs @@ -113,6 +113,10 @@ pub struct AgentHandshake { pub available_models: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub available_commands: Option, + /// Last successful normalized dynamic preflight. Stored alongside + /// handshake data because it is runtime-observed Agent capability state. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub dynamic_probe: Option, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] @@ -140,6 +144,82 @@ pub enum AgentSnapshotCheckKind { Session, } +/// Ordered stages executed by the dynamic Agent preflight. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum AgentProbeStep { + Spawn, + Initialize, + Models, + MinimalPrompt, + Cancel, + Resume, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum AgentProbeStatus { + Passed, + Failed, + Unsupported, + TimedOut, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum AgentProbeErrorCategory { + Authentication, + ModelRejected, + Protocol, + Startup, + Timeout, + RateLimited, + Permission, + RuntimeMissing, + Unknown, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct AgentProbeStepResult { + pub step: AgentProbeStep, + pub status: AgentProbeStatus, + pub started_at: TimestampMs, + pub duration_ms: i64, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_category: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_message: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct AgentDynamicProbeResult { + pub agent_id: String, + pub checked_at: TimestampMs, + pub steps: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub available_models: Vec, +} + +impl AgentDynamicProbeResult { + /// Resume is optional in ACP; every other stage is required before an + /// Agent can be used for a formal development session. + pub fn is_usable(&self) -> bool { + const REQUIRED: [AgentProbeStep; 5] = [ + AgentProbeStep::Spawn, + AgentProbeStep::Initialize, + AgentProbeStep::Models, + AgentProbeStep::MinimalPrompt, + AgentProbeStep::Cancel, + ]; + + REQUIRED.iter().all(|required| { + self.steps + .iter() + .any(|result| result.step == *required && result.status == AgentProbeStatus::Passed) + }) + } +} + /// A single `backend → logo URL` pair in the agent logo catalog. /// /// Returned by `GET /api/agents/logos` so business surfaces can resolve @@ -288,6 +368,10 @@ pub struct AgentManagementRow { #[serde(default, skip_serializing_if = "Option::is_none")] pub yolo_id: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub agent_capabilities: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub auth_methods: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub config_options: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub available_modes: Option, @@ -295,6 +379,8 @@ pub struct AgentManagementRow { pub available_models: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub available_commands: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub dynamic_probe: Option, pub sort_order: i64, #[serde(default)] pub team_capable: bool, diff --git a/crates/aionui-api-types/src/conversation.rs b/crates/aionui-api-types/src/conversation.rs index 3f868750b..1098c9fce 100644 --- a/crates/aionui-api-types/src/conversation.rs +++ b/crates/aionui-api-types/src/conversation.rs @@ -62,6 +62,18 @@ pub struct CreateConversationRequest { pub assistant: Option, pub source: Option, pub channel_chat_id: Option, + #[serde(default)] + pub source_channel: Option, + #[serde(default)] + pub source_channel_id: Option, + #[serde(default)] + pub source_chat_id: Option, + #[serde(default)] + pub source_user_id: Option, + #[serde(default)] + pub source_label: Option, + #[serde(default)] + pub created_from: Option, pub extra: serde_json::Value, } @@ -226,6 +238,18 @@ pub struct ConversationResponse { #[serde(skip_serializing_if = "Option::is_none")] pub channel_chat_id: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_channel: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_channel_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_chat_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_user_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_label: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub created_from: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub assistant: Option, pub created_at: TimestampMs, pub modified_at: TimestampMs, @@ -339,6 +363,12 @@ mod tests { }, "source": "aionui", "channel_chat_id": "user:123", + "source_channel": "telegram", + "source_channel_id": "bot:main", + "source_chat_id": "chat:123", + "source_user_id": "user:456", + "source_label": "Telegram", + "created_from": "telegram", "extra": { "workspace": "/project" } }); let req: CreateConversationRequest = serde_json::from_value(raw).unwrap(); @@ -362,6 +392,12 @@ mod tests { ); assert_eq!(req.source, Some(ConversationSource::Aionui)); assert_eq!(req.channel_chat_id.as_deref(), Some("user:123")); + assert_eq!(req.source_channel.as_deref(), Some("telegram")); + assert_eq!(req.source_channel_id.as_deref(), Some("bot:main")); + assert_eq!(req.source_chat_id.as_deref(), Some("chat:123")); + assert_eq!(req.source_user_id.as_deref(), Some("user:456")); + assert_eq!(req.source_label.as_deref(), Some("Telegram")); + assert_eq!(req.created_from.as_deref(), Some("telegram")); assert_eq!(req.extra["workspace"], "/project"); } @@ -584,6 +620,12 @@ mod tests { pinned: false, pinned_at: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, assistant: None, created_at: 1712345678000, modified_at: 1712345678000, @@ -622,6 +664,12 @@ mod tests { pinned: false, pinned_at: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, assistant: None, created_at: 1, modified_at: 1, @@ -654,6 +702,12 @@ mod tests { pinned: true, pinned_at: Some(1712345678000), channel_chat_id: Some("group:42".into()), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, assistant: None, created_at: 1000, modified_at: 2000, @@ -738,6 +792,12 @@ mod tests { pinned: false, pinned_at: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, assistant: None, created_at: 1712345678000, modified_at: 1712345678000, @@ -775,6 +835,12 @@ mod tests { pinned: false, pinned_at: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, assistant: None, created_at: 9000, modified_at: 9000, @@ -846,6 +912,12 @@ mod tests { pinned: false, pinned_at: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, assistant: None, created_at: 1000, modified_at: 1000, @@ -898,6 +970,12 @@ mod tests { pinned: false, pinned_at: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, assistant: None, created_at: 5000, modified_at: 5000, diff --git a/crates/aionui-api-types/src/development.rs b/crates/aionui-api-types/src/development.rs new file mode 100644 index 000000000..f768454ba --- /dev/null +++ b/crates/aionui-api-types/src/development.rs @@ -0,0 +1,175 @@ +use serde::{Deserialize, Serialize}; +use serde_json::Value; +use std::collections::BTreeMap; + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct RequirementVersion { + pub id: String, + pub version: i64, + pub content: String, + pub change_summary: Option, + pub created_at: i64, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct AcceptanceCriterion { + pub id: String, + pub requirement_version_id: String, + pub ordinal: i64, + pub statement: String, + pub required: bool, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct PlanRevision { + pub id: String, + pub revision: i64, + pub summary: String, + pub content: String, + pub created_at: i64, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct CriterionCoverage { + pub criterion_id: String, + pub statement: String, + pub task_ids: Vec, + pub evidence_ids: Vec, + pub accepted: bool, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct RequirementsSnapshot { + pub run_id: String, + pub original_requirement: String, + pub requirement_versions: Vec, + pub active_criteria: Vec, + pub plan_revisions: Vec, + pub coverage: Vec, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct SingleRunWorkspace { + pub run_id: String, + pub baseline_commit: String, + pub initial_diff_checksum: String, + pub initial_diff_path: String, + pub workspace_lease_id: Option, + pub workspace_path: Option, + pub branch: Option, + pub candidate_commit: Option, + pub safe_point: String, + pub cleanup_status: String, + pub created_at: i64, + pub updated_at: i64, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DevelopmentSecretCreateRequest { + pub name: String, + pub value: String, + pub expires_at: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DevelopmentSecretReference { + pub id: String, + pub project_id: String, + pub name: String, + pub status: String, + pub expires_at: Option, + pub created_at: i64, + pub updated_at: i64, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DevelopmentSecretGrantRequest { + pub secret_id: String, + pub scope_type: String, + pub scope_id: String, + pub environment_key: String, + pub expires_at: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DevelopmentModelPriceRequest { + pub provider: String, + pub model: String, + pub input_per_million_microunits: i64, + pub output_per_million_microunits: i64, + pub cache_read_per_million_microunits: i64, + pub cache_write_per_million_microunits: i64, + pub source_id: String, + pub version: String, + pub effective_at: i64, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DevelopmentUsageCost { + pub cost_microunits: Option, + pub origin: String, + pub price_source_id: Option, + pub price_version: Option, + pub price_effective_at: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DevelopmentTagRequest { + pub name: String, + pub commit_sha: String, + #[serde(default)] + pub confirmed: bool, + #[serde(default)] + pub confirmation_count: u8, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DevelopmentDeploymentRequest { + pub environment: String, + pub deployment_key: String, + pub commit_sha: String, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DevelopmentConfirmationRequest { + #[serde(default)] + pub confirmed: bool, + #[serde(default)] + pub confirmation_count: u8, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct DevelopmentTimelineEvent { + pub id: String, + pub kind: String, + pub correlation_id: String, + pub task_id: Option, + pub title: String, + pub status: String, + pub actor_id: Option, + pub occurred_at: i64, + #[serde(default)] + pub metadata: Value, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct DevelopmentRunControlState { + pub run_id: String, + pub run_status: String, + pub allowed_run_actions: Vec, + pub allowed_task_actions: BTreeMap>, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct DevelopmentRunTimeline { + pub run_id: String, + pub events: Vec, + pub controls: DevelopmentRunControlState, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DevelopmentRunControlRequest { + pub action: String, + pub task_id: Option, + pub target_slot_id: Option, +} diff --git a/crates/aionui-api-types/src/lib.rs b/crates/aionui-api-types/src/lib.rs index 795667e22..8f837bf31 100644 --- a/crates/aionui-api-types/src/lib.rs +++ b/crates/aionui-api-types/src/lib.rs @@ -14,11 +14,13 @@ mod connection_test; mod conversation; mod cron; mod custom_agent; +mod development; mod extension; mod file; mod lifecycle; mod mcp; mod office; +mod project; mod provider; mod remote_agent; mod response; @@ -44,7 +46,8 @@ pub use agent_build_extra::{ SlashCommandCompletionBehavior, SlashCommandItem, }; pub use agent_discovery::{ - AgentEnvEntry, AgentHandshake, AgentLogoEntry, AgentManagementRow, AgentManagementStatus, AgentMetadata, + AgentDynamicProbeResult, AgentEnvEntry, AgentHandshake, AgentLogoEntry, AgentManagementRow, AgentManagementStatus, + AgentMetadata, AgentProbeErrorCategory, AgentProbeStatus, AgentProbeStep, AgentProbeStepResult, AgentSnapshotCheckKind, AgentSnapshotCheckStatus, AgentSource, AgentSourceInfo, BehaviorPolicy, }; pub use agent_error::{ @@ -94,6 +97,13 @@ pub use custom_agent::{ AgentOverridesResponse, CustomAgentAdvancedOverrides, CustomAgentUpsertRequest, DeleteCustomAgentResponse, SetAgentOverridesRequest, SetEnabledRequest, }; +pub use development::{ + AcceptanceCriterion, CriterionCoverage, DevelopmentConfirmationRequest, DevelopmentDeploymentRequest, + DevelopmentModelPriceRequest, DevelopmentRunControlRequest, DevelopmentRunControlState, DevelopmentRunTimeline, + DevelopmentSecretCreateRequest, DevelopmentSecretGrantRequest, DevelopmentSecretReference, DevelopmentTagRequest, + DevelopmentTimelineEvent, DevelopmentUsageCost, PlanRevision, RequirementVersion, RequirementsSnapshot, + SingleRunWorkspace, +}; pub use extension::{ DisableExtensionRequest, EnableExtensionRequest, ExtensionSummaryResponse, GetI18nRequest, GetPermissionsRequest, GetRiskLevelRequest, HubExtensionListItem, HubExtensionListResponse, HubOperationResponse, HubUpdateInfo, @@ -121,6 +131,14 @@ pub use office::{ PptSlideData, PreviewHistoryTargetDto, PreviewSnapshotInfoDto, PreviewState, PreviewStatusEvent, PreviewUrlResponse, SaveSnapshotRequest, SnapshotContentResponse, StartPreviewRequest, StopPreviewRequest, }; +pub use project::{ + DevelopmentEvaluation, DevelopmentRetentionPolicy, DirtyWorktreeChoice, EvaluationComparison, + EvaluationComparisonRequest, EvaluationRecordInput, EvaluationRegression, ImportProjectBundleRequest, + PlatformInstanceSummary, ProjectExportBundle, ProjectExportManifest, ProjectImportReport, ProjectKnowledgeFact, + ProjectKnowledgeStatus, ProjectRepositoryFacts, ProjectRepositoryOnboardingInput, ProjectTaskContext, + ProjectTaskContextRequest, RepositorySource, RepositorySubmodule, RetentionCleanupReport, RetentionCleanupRequest, + RetentionPolicyInput, +}; pub use provider::{ BedrockAuthMethod, BedrockConfig, CreateProviderRequest, DetectProtocolRequest, DetectionSuggestion, FetchModelsAnonymousRequest, FetchModelsRequest, FetchModelsResponse, HealthStatus, KeyTestResult, ModelCapability, @@ -158,14 +176,15 @@ pub use system::{ UpdateClientPreferencesRequest, UpdateSettingsRequest, }; pub use team::{ - AddAgentRequest, CancelTeamChildTurnRequest, CancelTeamRunRequest, CreateTeamRequest, PauseTeamSlotRequest, - RenameAgentRequest, RenameTeamRequest, SendAgentMessageRequest, SendTeamMessageRequest, TeamAgentInput, - TeamAgentRemovedPayload, TeamAgentRenamedPayload, TeamAgentResponse, TeamAgentRuntimeStatus, - TeamAgentRuntimeStatusPayload, TeamAgentSpawnedPayload, TeamAgentStatusPayload, TeamChildTurnPayload, - TeamListResponse, TeamMcpRuntimeConfig, TeamMessageEnqueueStatus, TeamResponse, TeamRunAckResponse, TeamRunPayload, - TeamRunSource, TeamRunStateResponse, TeamRunStatus, TeamRunTargetRole, TeamRuntimeSeed, - TeamSendMessageQueuedResponse, TeamSessionBinding, TeamSessionPhase, TeamSessionStatus, TeamSessionStatusPayload, - TeamSlotBlockedReason, TeamSlotWorkPayload, TeamSlotWorkState, TeammateMessagePayload, + AddAgentRequest, AgentWorkspaceLeaseResponse, CancelTeamChildTurnRequest, CancelTeamRunRequest, + CreateTeamHttpRequest, CreateTeamRequest, PauseTeamSlotRequest, RenameAgentRequest, RenameTeamRequest, + SendAgentMessageRequest, SendTeamMessageRequest, TeamAgentInput, TeamAgentRemovedPayload, TeamAgentRenamedPayload, + TeamAgentResponse, TeamAgentRuntimeStatus, TeamAgentRuntimeStatusPayload, TeamAgentSpawnedPayload, + TeamAgentStatusPayload, TeamChildTurnPayload, TeamListResponse, TeamMcpRuntimeConfig, TeamMessageEnqueueStatus, + TeamResponse, TeamRunAckResponse, TeamRunPayload, TeamRunSource, TeamRunStateResponse, TeamRunStatus, + TeamRunTargetRole, TeamRuntimeSeed, TeamSendMessageQueuedResponse, TeamSessionBinding, TeamSessionPhase, + TeamSessionStatus, TeamSessionStatusPayload, TeamSlotBlockedReason, TeamSlotWorkPayload, TeamSlotWorkState, + TeamWorkspaceMode, TeammateMessagePayload, }; pub use team_mcp::{TEAM_MCP_SERVER_NAME, TeamMcpStdioConfig}; pub use team_tools::{ diff --git a/crates/aionui-api-types/src/project.rs b/crates/aionui-api-types/src/project.rs new file mode 100644 index 000000000..cb8ae7dcb --- /dev/null +++ b/crates/aionui-api-types/src/project.rs @@ -0,0 +1,254 @@ +use aionui_common::TimestampMs; +use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)] +#[serde(rename_all = "snake_case")] +pub enum DirtyWorktreeChoice { + Preserve, + Snapshot, + #[default] + Reject, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "kind", rename_all = "snake_case")] +pub enum RepositorySource { + Local { + path: String, + }, + Clone { + url: String, + destination_name: String, + #[serde(default)] + branch: Option, + #[serde(default)] + credential_reference: Option, + }, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ProjectRepositoryOnboardingInput { + pub name: String, + pub source: RepositorySource, + #[serde(default)] + pub dirty_worktree_choice: DirtyWorktreeChoice, + #[serde(default = "default_project_type")] + pub project_type: String, +} + +fn default_project_type() -> String { + "unknown".into() +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct RepositorySubmodule { + pub path: String, + pub url: Option, + pub initialized: bool, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ProjectRepositoryFacts { + pub local_path: String, + pub repository_url: Option, + pub default_branch: Option, + pub baseline_commit: Option, + pub dirty: bool, + pub dirty_worktree_choice: DirtyWorktreeChoice, + pub dirty_snapshot_ref: Option, + pub credential_reference: Option, + pub languages: Vec, + pub package_managers: Vec, + pub rules_files: Vec, + pub monorepo_packages: Vec, + pub submodules: Vec, + pub lfs_detected: bool, + pub detected_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ProjectKnowledgeFact { + pub kind: String, + pub name: String, + pub qualified_name: Option, + pub source_path: String, + pub source_line: Option, + pub indexed_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ProjectKnowledgeStatus { + pub project_id: String, + pub provider: String, + pub provider_project_name: String, + pub provider_version: Option, + pub status: String, + pub generation: i64, + pub source_commit: Option, + pub indexed_at: Option, + pub changed_paths: Vec, + pub error_category: Option, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ProjectTaskContext { + pub id: String, + pub project_id: String, + pub provider_project_name: String, + pub generation: i64, + pub query: String, + pub symbols: Vec, + pub callers: Vec, + pub tests: Vec, + pub routes: Vec, + pub data_entities: Vec, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ProjectTaskContextRequest { + pub query: String, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct ProjectExportManifest { + pub format_version: u32, + pub schema_version: i64, + pub app_version: String, + pub source_instance_id: String, + pub exported_at: TimestampMs, + pub project_id: String, + pub record_counts: BTreeMap, + pub payload_checksum: String, + pub signer_public_key: String, + pub signature: String, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct ProjectExportBundle { + pub manifest: ProjectExportManifest, + pub records: BTreeMap>, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct ImportProjectBundleRequest { + pub bundle: ProjectExportBundle, + pub local_path: String, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ProjectImportReport { + pub project_id: String, + pub owner_id: String, + pub imported: bool, + pub imported_counts: BTreeMap, + pub conflicts: Vec, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct RetentionPolicyInput { + pub conversation_history_days: i64, + pub artifact_days: i64, + pub evaluation_days: i64, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DevelopmentRetentionPolicy { + pub user_id: String, + pub project_id: String, + pub conversation_history_days: i64, + pub artifact_days: i64, + pub evaluation_days: i64, + pub immutable_audit_log: bool, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct RetentionCleanupRequest { + #[serde(default)] + pub dry_run: bool, + #[serde(default)] + pub confirmation_count: u8, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct RetentionCleanupReport { + pub execution_id: Option, + pub project_id: String, + pub dry_run: bool, + pub message_count: i64, + pub artifact_count: i64, + pub evaluation_count: i64, + pub audit_events_retained: i64, + pub completed_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct PlatformInstanceSummary { + pub instance_id: String, + pub schema_version: i64, + pub app_version: String, + pub first_started_at: TimestampMs, + pub last_started_at: TimestampMs, + pub data_size_bytes: i64, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct EvaluationRecordInput { + pub project_id: String, + pub release_id: String, + pub scenario_id: String, + pub result: String, + pub duration_ms: i64, + pub failure_category: Option, + pub input_tokens: i64, + pub output_tokens: i64, + pub cost_microunits: i64, + pub cost_source: String, + #[serde(default)] + pub accepted_baseline: bool, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DevelopmentEvaluation { + pub id: String, + pub user_id: String, + pub project_id: String, + pub release_id: String, + pub scenario_id: String, + pub result: String, + pub duration_ms: i64, + pub failure_category: Option, + pub input_tokens: i64, + pub output_tokens: i64, + pub cost_microunits: i64, + pub cost_source: String, + pub accepted_baseline: bool, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct EvaluationComparisonRequest { + pub project_id: String, + pub release_id: String, + pub required_scenarios: Vec, + pub max_duration_regression_percent: i64, + pub max_cost_regression_percent: i64, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct EvaluationRegression { + pub scenario_id: String, + pub category: String, + pub message: String, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct EvaluationComparison { + pub allowed: bool, + pub release_id: String, + pub baseline_release_ids: Vec, + pub regressions: Vec, +} diff --git a/crates/aionui-api-types/src/team.rs b/crates/aionui-api-types/src/team.rs index efc3dd362..87fa19fa1 100644 --- a/crates/aionui-api-types/src/team.rs +++ b/crates/aionui-api-types/src/team.rs @@ -28,9 +28,8 @@ pub struct TeamAgentInput { } #[derive(Debug, Clone, Deserialize)] -#[serde(deny_unknown_fields)] struct TeamAgentInputCompat { - #[serde(default)] + #[serde(default, alias = "assistantId", alias = "custom_agent_id", alias = "customAgentId")] pub assistant_id: Option, pub name: String, pub role: String, @@ -76,6 +75,47 @@ pub struct CreateTeamRequest { pub agents: Vec, #[serde(default)] pub workspace: Option, + #[serde(default)] + pub source_channel: Option, + #[serde(default)] + pub source_channel_id: Option, + #[serde(default)] + pub source_chat_id: Option, + #[serde(default)] + pub source_user_id: Option, + #[serde(default)] + pub source_label: Option, + #[serde(default)] + pub created_from: Option, +} + +#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq, Eq)] +#[serde(rename_all = "snake_case")] +pub enum TeamWorkspaceMode { + #[default] + Shared, + #[serde(alias = "isolated")] + IsolatedWorktree, +} + +impl TeamWorkspaceMode { + pub const fn as_str(self) -> &'static str { + match self { + Self::Shared => "shared", + Self::IsolatedWorktree => "isolated_worktree", + } + } +} + +/// HTTP request contract for Team creation. `CreateTeamRequest` remains the +/// reusable source/agent payload used by channel integrations, while the Web +/// endpoint adds the workspace lifecycle selection. +#[derive(Debug, Deserialize)] +pub struct CreateTeamHttpRequest { + #[serde(flatten)] + pub team: CreateTeamRequest, + #[serde(default)] + pub workspace_mode: TeamWorkspaceMode, } /// Request body for `PATCH /api/teams/:id/name`. @@ -112,7 +152,7 @@ struct AddAgentRequestCompat { role: Option, #[serde(default)] model: Option, - #[serde(default)] + #[serde(default, alias = "assistantId", alias = "custom_agent_id", alias = "customAgentId")] assistant_id: Option, } @@ -443,14 +483,46 @@ pub struct TeamResponse { pub name: String, #[serde(default)] pub workspace: String, + #[serde(default)] + pub workspace_mode: TeamWorkspaceMode, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub workspace_leases: Vec, #[serde(alias = "agents")] pub assistants: Vec, #[serde(skip_serializing_if = "Option::is_none", alias = "lead_agent_id")] pub leader_assistant_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_channel: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_channel_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_chat_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_user_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_label: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub created_from: Option, pub created_at: TimestampMs, pub updated_at: TimestampMs, } +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct AgentWorkspaceLeaseResponse { + pub id: String, + pub slot_id: String, + pub worktree_path: String, + pub branch_name: String, + pub base_commit: String, + pub allowed_paths: Vec, + pub lease_status: String, + pub cleanup_status: String, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub conflict_files: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub last_error: Option, +} + /// Type alias for team list responses. pub type TeamListResponse = Vec; @@ -584,6 +656,40 @@ mod tests { // -- A. Team management requests ------------------------------------------ + #[test] + fn create_team_http_request_defaults_to_shared_workspace() { + let req: CreateTeamHttpRequest = serde_json::from_value(json!({ + "name": "Legacy", + "agents": [{ + "name": "Lead", + "role": "lead", + "model": "default", + "assistant_id": "assistant-x" + }] + })) + .unwrap(); + assert_eq!(req.workspace_mode, TeamWorkspaceMode::Shared); + } + + #[test] + fn create_team_http_request_canonicalizes_isolated_alias() { + for value in ["isolated", "isolated_worktree"] { + let req: CreateTeamHttpRequest = serde_json::from_value(json!({ + "name": "Isolated", + "workspace_mode": value, + "agents": [{ + "name": "Lead", + "role": "lead", + "model": "default", + "assistant_id": "assistant-x" + }] + })) + .unwrap(); + assert_eq!(req.workspace_mode, TeamWorkspaceMode::IsolatedWorktree); + assert_eq!(req.workspace_mode.as_str(), "isolated_worktree"); + } + } + #[test] fn deserialize_create_team_request_full() { let raw = json!({ @@ -650,7 +756,7 @@ mod tests { } #[test] - fn deserialize_team_agent_input_rejects_legacy_custom_agent_id() { + fn deserialize_team_agent_input_accepts_legacy_custom_agent_id() { let raw = json!({ "name": "Lead", "role": "lead", @@ -658,8 +764,9 @@ mod tests { "model": "claude", "custom_agent_id": "assistant-legacy" }); - let result = serde_json::from_value::(raw); - assert!(result.is_err()); + let input = serde_json::from_value::(raw).unwrap(); + assert_eq!(input.assistant_id.as_deref(), Some("assistant-legacy")); + assert!(input.backend.is_none()); } #[test] @@ -688,7 +795,7 @@ mod tests { } #[test] - fn deserialize_team_agent_input_rejects_backend_field() { + fn deserialize_team_agent_input_ignores_legacy_backend_field() { let raw = json!({ "name": "Lead", "role": "lead", @@ -696,8 +803,30 @@ mod tests { "model": "claude", "assistant_id": "assistant-x" }); - let result = serde_json::from_value::(raw); - assert!(result.is_err()); + let input = serde_json::from_value::(raw).unwrap(); + assert_eq!(input.assistant_id.as_deref(), Some("assistant-x")); + assert!(input.backend.is_none()); + } + + #[test] + fn deserialize_team_agent_input_accepts_cached_webui_legacy_shape() { + let raw = json!({ + "slot_id": "leader", + "name": "Aion CLI", + "role": "leader", + "backend": "acp", + "agent_type": "acp", + "conversation_type": "acp", + "status": "idle", + "model": "default", + "custom_agent_id": "bare:632f31d2" + }); + let input = serde_json::from_value::(raw).unwrap(); + assert_eq!(input.name, "Aion CLI"); + assert_eq!(input.role, "leader"); + assert_eq!(input.model, "default"); + assert_eq!(input.assistant_id.as_deref(), Some("bare:632f31d2")); + assert!(input.backend.is_none()); } #[test] @@ -766,15 +895,16 @@ mod tests { } #[test] - fn deserialize_add_agent_request_rejects_custom_agent_id() { + fn deserialize_add_agent_request_accepts_legacy_custom_agent_id() { let raw = json!({ "name": "Custom", "role": "teammate", "model": "claude", "custom_agent_id": "custom-1" }); - let result = serde_json::from_value::(raw); - assert!(result.is_err()); + let req = serde_json::from_value::(raw).unwrap(); + assert_eq!(req.assistant_id.as_deref(), Some("custom-1")); + assert!(req.backend.is_none()); } #[test] @@ -957,6 +1087,8 @@ mod tests { id: "team-1".into(), name: "Alpha".into(), workspace: "/workspace/team-1".into(), + workspace_mode: TeamWorkspaceMode::Shared, + workspace_leases: vec![], assistants: vec![TeamAgentResponse { slot_id: "slot-1".into(), assistant_name: "Lead".into(), @@ -972,6 +1104,12 @@ mod tests { pending_confirmations: 0, }], leader_assistant_id: Some("slot-1".into()), + source_channel: Some("telegram".into()), + source_channel_id: Some("bot-1".into()), + source_chat_id: Some("chat-1".into()), + source_user_id: Some("user-1".into()), + source_label: Some("Telegram".into()), + created_from: Some("telegram".into()), created_at: 1700000000000, updated_at: 1700001000000, }; @@ -980,6 +1118,8 @@ mod tests { assert_eq!(json["name"], "Alpha"); assert_eq!(json["workspace"], "/workspace/team-1"); assert_eq!(json["leader_assistant_id"], "slot-1"); + assert_eq!(json["source_channel"], "telegram"); + assert_eq!(json["source_label"], "Telegram"); assert_eq!(json["created_at"], 1700000000000_i64); assert_eq!(json["updated_at"], 1700001000000_i64); assert_eq!(json["assistants"].as_array().unwrap().len(), 1); @@ -992,13 +1132,22 @@ mod tests { id: "team-2".into(), name: "Beta".into(), workspace: String::new(), + workspace_mode: TeamWorkspaceMode::Shared, + workspace_leases: vec![], assistants: vec![], leader_assistant_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, created_at: 1700000000000, updated_at: 1700000000000, }; let json = serde_json::to_value(&team).unwrap(); assert!(json.get("leader_assistant_id").is_none()); + assert!(json.get("source_channel").is_none()); assert!(json["assistants"].as_array().unwrap().is_empty()); } @@ -1097,6 +1246,8 @@ mod tests { id: "team-1".into(), name: "Alpha".into(), workspace: "/workspace/team-1".into(), + workspace_mode: TeamWorkspaceMode::Shared, + workspace_leases: vec![], assistants: vec![ TeamAgentResponse { slot_id: "s1".into(), @@ -1128,6 +1279,12 @@ mod tests { }, ], leader_assistant_id: Some("s1".into()), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, created_at: 1000, updated_at: 2000, }; diff --git a/crates/aionui-app/Cargo.toml b/crates/aionui-app/Cargo.toml index 2f8d755af..d67901d9d 100644 --- a/crates/aionui-app/Cargo.toml +++ b/crates/aionui-app/Cargo.toml @@ -34,6 +34,8 @@ aionui-channel.workspace = true aionui-team.workspace = true aionui-team-prompts.workspace = true aionui-cron.workspace = true +aionui-project.workspace = true +aionui-development.workspace = true aionui-assistant.workspace = true aionui-runtime.workspace = true axum.workspace = true diff --git a/crates/aionui-app/src/router/development_usage.rs b/crates/aionui-app/src/router/development_usage.rs new file mode 100644 index 000000000..ea66f9f3c --- /dev/null +++ b/crates/aionui-app/src/router/development_usage.rs @@ -0,0 +1,430 @@ +use std::sync::Arc; + +use aionui_ai_agent::IWorkerTaskManager; +use aionui_api_types::{ConfigOptionConfirmation, SetConfigOptionRequest, SetConfigOptionResponse}; +use aionui_common::{AgentKillReason, ErrorChain}; +use aionui_conversation::{ + ConversationService, ConversationTurnAdmission, ConversationTurnAdmissionRequest, ConversationTurnGuard, + ConversationTurnObservation, ConversationTurnObserver, +}; +use aionui_development::{ + BudgetEvaluation, DevelopmentBudgetAdmission, DevelopmentOperationsService, DevelopmentUsageIngestor, + ObservedAgentTurnUsage, +}; +use tracing::{info, warn}; + +#[derive(Debug, Clone, PartialEq, Eq)] +enum BudgetRuntimeAction { + None, + DowngradeModel(String), + StopAgent, +} + +fn runtime_action(evaluation: Option<&BudgetEvaluation>) -> BudgetRuntimeAction { + let Some(evaluation) = evaluation.filter(|evaluation| !evaluation.reasons.is_empty()) else { + return BudgetRuntimeAction::None; + }; + match evaluation.action.as_str() { + "downgrade_model" => evaluation + .replacement_model + .as_deref() + .map(str::trim) + .filter(|model| !model.is_empty()) + .map(|model| BudgetRuntimeAction::DowngradeModel(model.to_owned())) + .unwrap_or(BudgetRuntimeAction::StopAgent), + "pause" | "terminate" => BudgetRuntimeAction::StopAgent, + "notify" => BudgetRuntimeAction::None, + _ => BudgetRuntimeAction::StopAgent, + } +} + +fn turn_admission(admission: Option<&DevelopmentBudgetAdmission>) -> ConversationTurnAdmission { + let Some(admission) = admission else { + return ConversationTurnAdmission::Allowed; + }; + if matches!(admission.run_status.as_str(), "paused" | "cancelled" | "integrating") { + return ConversationTurnAdmission::Denied { + reason: format!( + "Development run {} is {}; wait for recovery/completion or create a new run before sending more Agent work", + admission.run_id, admission.run_status + ), + }; + } + if admission.evaluation.reasons.is_empty() + || matches!(admission.evaluation.action.as_str(), "notify" | "downgrade_model") + { + ConversationTurnAdmission::Allowed + } else { + ConversationTurnAdmission::Denied { + reason: admission.evaluation.reasons.join("; "), + } + } +} + +fn observed_model_matches(response: &SetConfigOptionResponse, expected_model: &str) -> bool { + response.confirmation == ConfigOptionConfirmation::Observed + && response.config_options.as_ref().is_some_and(|options| { + options + .iter() + .any(|option| option.id == "model" && option.current_value.as_deref() == Some(expected_model)) + }) +} + +fn pre_turn_runtime_action(admission: &DevelopmentBudgetAdmission) -> BudgetRuntimeAction { + if matches!(admission.run_status.as_str(), "paused" | "cancelled" | "integrating") { + BudgetRuntimeAction::StopAgent + } else { + runtime_action(Some(&admission.evaluation)) + } +} + +pub(crate) struct DevelopmentTurnObserver { + ingestor: DevelopmentUsageIngestor, + operations: DevelopmentOperationsService, + conversation_service: ConversationService, + task_manager: Arc, +} + +impl DevelopmentTurnObserver { + pub(crate) fn new( + ingestor: DevelopmentUsageIngestor, + operations: DevelopmentOperationsService, + conversation_service: ConversationService, + task_manager: Arc, + ) -> Self { + Self { + ingestor, + operations, + conversation_service, + task_manager, + } + } + + async fn apply_runtime_action( + &self, + user_id: &str, + run_id: Option<&str>, + conversation_id: &str, + evaluation: Option<&BudgetEvaluation>, + ) -> bool { + match runtime_action(evaluation) { + BudgetRuntimeAction::None => true, + BudgetRuntimeAction::DowngradeModel(model) => { + match self + .conversation_service + .set_config_option( + conversation_id, + "model", + SetConfigOptionRequest { value: model.clone() }, + ) + .await + { + Ok(response) if observed_model_matches(&response, &model) => { + info!( + conversation_id, + model, "development budget downgraded the active agent model" + ); + true + } + result => { + let detail = match result { + Ok(response) => format!( + "Agent acknowledged model change without an observed fallback snapshot ({:?})", + response.confirmation + ), + Err(error) => ErrorChain(&error).to_string(), + }; + warn!( + conversation_id, + model, + error = %detail, + "development budget model downgrade failed; stopping the active agent to prevent unbounded execution" + ); + if let Some(run_id) = run_id + && let Err(pause_error) = self + .operations + .pause_after_runtime_action_failure( + user_id, + run_id, + "configured budget model downgrade failed; run paused fail-closed", + ) + .await + { + warn!( + run_id, + error = %ErrorChain(&pause_error), + "failed to persist fail-closed pause after budget model downgrade failure" + ); + } + self.task_manager + .kill_and_wait(conversation_id, Some(AgentKillReason::BudgetExceeded)) + .await; + false + } + } + } + BudgetRuntimeAction::StopAgent => { + self.task_manager + .kill_and_wait(conversation_id, Some(AgentKillReason::BudgetExceeded)) + .await; + false + } + } + } +} + +#[async_trait::async_trait] +impl ConversationTurnObserver for DevelopmentTurnObserver { + async fn observe(&self, observation: ConversationTurnObservation) { + let conversation_id = observation.conversation_id.clone(); + let user_id = observation.user_id.clone(); + let team_id = observation.team_id.clone(); + let event = ObservedAgentTurnUsage { + user_id: observation.user_id, + conversation_id: observation.conversation_id, + turn_id: observation.turn_id, + agent_id: observation.agent_id, + provider: observation.provider, + model: observation.model, + team_id: observation.team_id, + slot_id: observation.slot_id, + usage: observation.usage, + duration_ms: observation.duration_ms, + retry_count: observation.retry_count, + occurred_at: observation.occurred_at, + }; + match self.ingestor.record(event).await { + Ok(Some(outcome)) => { + let _ = self + .apply_runtime_action( + &outcome.row.user_id, + outcome.row.run_id.as_deref(), + &conversation_id, + outcome.budget.as_ref(), + ) + .await; + } + Ok(_) => {} + Err(error) => { + warn!( + conversation_id, + error = %ErrorChain(&error), + "failed to persist or enforce observed agent usage" + ); + match self + .ingestor + .pause_after_observation_failure( + &user_id, + &conversation_id, + team_id.as_deref(), + "observed Agent usage could not be safely persisted or enforced; run paused fail-closed", + ) + .await + { + Ok(None) => {} + Ok(Some(_)) | Err(_) => { + self.task_manager + .kill_and_wait(&conversation_id, Some(AgentKillReason::BudgetExceeded)) + .await; + } + } + } + } + } +} + +#[async_trait::async_trait] +impl ConversationTurnGuard for DevelopmentTurnObserver { + async fn authorize(&self, request: ConversationTurnAdmissionRequest) -> Result { + let admission = self + .ingestor + .admit(&request.user_id, &request.conversation_id, request.team_id.as_deref()) + .await + .map_err(|error| error.to_string())?; + let Some(admission) = admission else { + return Ok(ConversationTurnAdmission::Allowed); + }; + match pre_turn_runtime_action(&admission) { + BudgetRuntimeAction::None => {} + BudgetRuntimeAction::DowngradeModel(_) => { + if !self + .apply_runtime_action( + &request.user_id, + Some(&admission.run_id), + &request.conversation_id, + Some(&admission.evaluation), + ) + .await + { + return Ok(ConversationTurnAdmission::Denied { + reason: "Development budget model downgrade was not observed; run paused fail-closed".into(), + }); + } + } + BudgetRuntimeAction::StopAgent => { + self.task_manager + .kill_and_wait(&request.conversation_id, Some(AgentKillReason::BudgetExceeded)) + .await; + let reason = if matches!(admission.run_status.as_str(), "paused" | "cancelled") { + format!( + "Development run {} is {}; resume it or create a new run before sending more Agent work", + admission.run_id, admission.run_status + ) + } else if admission.evaluation.reasons.is_empty() { + "Development budget policy could not produce a safe runtime action".into() + } else { + admission.evaluation.reasons.join("; ") + }; + return Ok(ConversationTurnAdmission::Denied { reason }); + } + } + Ok(turn_admission(Some(&admission))) + } +} + +#[cfg(test)] +mod tests { + use aionui_api_types::AcpConfigOptionDto; + use aionui_db::models::DevelopmentUsageSummary; + + use super::*; + + fn evaluation(action: &str, replacement_model: Option<&str>, exceeded: bool) -> BudgetEvaluation { + BudgetEvaluation { + allowed: !exceeded || action == "notify", + action: action.into(), + reasons: exceeded.then(|| "token budget exceeded".into()).into_iter().collect(), + usage: DevelopmentUsageSummary::default(), + replacement_model: replacement_model.map(str::to_owned), + } + } + + #[test] + fn runtime_action_applies_only_when_the_budget_is_exceeded() { + assert_eq!(runtime_action(None), BudgetRuntimeAction::None); + assert_eq!( + runtime_action(Some(&evaluation("pause", None, false))), + BudgetRuntimeAction::None + ); + assert_eq!( + runtime_action(Some(&evaluation("notify", None, true))), + BudgetRuntimeAction::None + ); + assert_eq!( + runtime_action(Some(&evaluation("pause", None, true))), + BudgetRuntimeAction::StopAgent + ); + assert_eq!( + runtime_action(Some(&evaluation("terminate", None, true))), + BudgetRuntimeAction::StopAgent + ); + assert_eq!( + runtime_action(Some(&evaluation("downgrade_model", Some("fallback-model"), true))), + BudgetRuntimeAction::DowngradeModel("fallback-model".into()) + ); + } + + #[test] + fn malformed_persisted_budget_action_fails_closed() { + assert_eq!( + runtime_action(Some(&evaluation("downgrade_model", None, true))), + BudgetRuntimeAction::StopAgent + ); + assert_eq!( + runtime_action(Some(&evaluation("unexpected", None, true))), + BudgetRuntimeAction::StopAgent + ); + } + + #[test] + fn admission_blocks_non_executable_runs_but_allows_notify_and_downgrade() { + let admission = |status: &str, action: &str, exceeded: bool| DevelopmentBudgetAdmission { + run_id: "run-1".into(), + run_status: status.into(), + evaluation: evaluation(action, Some("fallback-model"), exceeded), + }; + assert_eq!( + turn_admission(Some(&admission("running", "notify", true))), + ConversationTurnAdmission::Allowed + ); + assert_eq!( + turn_admission(Some(&admission("running", "downgrade_model", true))), + ConversationTurnAdmission::Allowed + ); + assert!(matches!( + turn_admission(Some(&admission("paused", "pause", true))), + ConversationTurnAdmission::Denied { .. } + )); + assert!(matches!( + turn_admission(Some(&admission("cancelled", "terminate", true))), + ConversationTurnAdmission::Denied { .. } + )); + assert!(matches!( + turn_admission(Some(&admission("integrating", "notify", false))), + ConversationTurnAdmission::Denied { .. } + )); + } + + #[test] + fn model_downgrade_requires_an_observed_matching_snapshot() { + let response = |confirmation, current_value: Option<&str>| SetConfigOptionResponse { + confirmation, + config_options: Some(vec![AcpConfigOptionDto { + id: "model".into(), + name: Some("Model".into()), + label: None, + description: None, + category: Some("model".into()), + option_type: "select".into(), + current_value: current_value.map(str::to_owned), + options: vec![], + }]), + }; + assert!(observed_model_matches( + &response(ConfigOptionConfirmation::Observed, Some("fallback")), + "fallback" + )); + assert!(!observed_model_matches( + &response(ConfigOptionConfirmation::CommandAck, Some("fallback")), + "fallback" + )); + assert!(!observed_model_matches( + &response(ConfigOptionConfirmation::Observed, Some("expensive")), + "fallback" + )); + } + + #[test] + fn pre_turn_actions_stop_terminal_budget_runs_and_downgrade_every_open_status() { + let admission = |status: &str, action: &str, exceeded: bool| DevelopmentBudgetAdmission { + run_id: "run-1".into(), + run_status: status.into(), + evaluation: evaluation(action, Some("fallback-model"), exceeded), + }; + assert_eq!( + pre_turn_runtime_action(&admission("paused", "notify", false)), + BudgetRuntimeAction::StopAgent + ); + assert_eq!( + pre_turn_runtime_action(&admission("cancelled", "notify", false)), + BudgetRuntimeAction::StopAgent + ); + assert_eq!( + pre_turn_runtime_action(&admission("integrating", "notify", false)), + BudgetRuntimeAction::StopAgent + ); + for status in [ + "preflight", + "running", + "waiting_approval", + "verifying", + "reviewing", + "rework", + ] { + assert_eq!( + pre_turn_runtime_action(&admission(status, "downgrade_model", true)), + BudgetRuntimeAction::DowngradeModel("fallback-model".into()) + ); + } + } +} diff --git a/crates/aionui-app/src/router/mod.rs b/crates/aionui-app/src/router/mod.rs index d16c5972d..e14d99f40 100644 --- a/crates/aionui-app/src/router/mod.rs +++ b/crates/aionui-app/src/router/mod.rs @@ -1,5 +1,6 @@ //! HTTP router assembly for the application. +mod development_usage; mod health; mod routes; mod runtime_team_tools; diff --git a/crates/aionui-app/src/router/routes.rs b/crates/aionui-app/src/router/routes.rs index bb50d63f6..051f0d961 100644 --- a/crates/aionui-app/src/router/routes.rs +++ b/crates/aionui-app/src/router/routes.rs @@ -26,10 +26,12 @@ use aionui_channel::weixin_login_route; use aionui_common::ApiErrorLogContext; use aionui_conversation::{conversation_ops_routes, conversation_routes}; use aionui_cron::cron_routes; +use aionui_development::{approval_routes, development_routes}; use aionui_extension::{extension_routes, hub_routes, skill_routes}; use aionui_file::file_routes; use aionui_mcp::mcp_routes; use aionui_office::{office_proxy_routes, office_routes}; +use aionui_project::project_routes; use aionui_realtime::{WsHandlerState, ws_upgrade_handler}; use aionui_shell::shell_routes; use aionui_system::{connection_test_routes, system_routes}; @@ -39,7 +41,7 @@ use crate::services::AppServices; use super::health::health_check; use super::runtime_team_tools::{RuntimeTeamToolsState, runtime_team_tools_routes}; -use super::state::{ModuleStates, RouterBuildError, build_module_states, build_ws_state}; +use super::state::{ModuleStates, RouterBuildError, build_approval_state, build_module_states, build_ws_state}; use super::trace::with_access_log; pub struct RouterRuntime { @@ -207,6 +209,15 @@ pub fn create_router_with_all_state(services: &AppServices, states: ModuleStates let cron_authenticated = cron_routes(states.cron).route_layer(from_fn_with_state(auth_mw_state.clone(), auth_middleware)); + let project_authenticated = + project_routes(states.project).route_layer(from_fn_with_state(auth_mw_state.clone(), auth_middleware)); + + let development_authenticated = + development_routes(states.development).route_layer(from_fn_with_state(auth_mw_state.clone(), auth_middleware)); + + let approval_authenticated = approval_routes(build_approval_state(services)) + .route_layer(from_fn_with_state(auth_mw_state.clone(), auth_middleware)); + // Office routes protected by auth middleware let office_authenticated = office_routes(states.office.clone()).route_layer(from_fn_with_state(auth_mw_state.clone(), auth_middleware)); @@ -250,6 +261,9 @@ pub fn create_router_with_all_state(services: &AppServices, states: ModuleStates .merge(channel_authenticated) .merge(team_authenticated) .merge(cron_authenticated) + .merge(project_authenticated) + .merge(development_authenticated) + .merge(approval_authenticated) .merge(office_authenticated) .merge(shell_authenticated) .merge(assistant_authenticated); diff --git a/crates/aionui-app/src/router/state.rs b/crates/aionui-app/src/router/state.rs index a2461348b..e25017835 100644 --- a/crates/aionui-app/src/router/state.rs +++ b/crates/aionui-app/src/router/state.rs @@ -7,21 +7,47 @@ use std::sync::Arc; use std::time::Instant; use aionui_ai_agent::{AgentRouterState, AgentService, RemoteAgentRouterState, RemoteAgentService}; +use aionui_api_types::{CreateTeamRequest, TeamAgentInput}; use aionui_assistant::{ AssistantAgentCatalogPort, AssistantError, AssistantRouterState, AssistantService, BuiltinAssistantRegistry, }; use aionui_auth::extract_token_from_ws_headers; -use aionui_channel::ChannelRouterState; +use aionui_channel::error::ChannelError; +use aionui_channel::message_service::ChannelTeamSender; +use aionui_channel::{ + ChannelRouterState, + action::{ + ChannelPersonalConversationSummary, ChannelPersonalDirectory, ChannelTeamCreateRequest, ChannelTeamDirectory, + ChannelTeamSummary, + }, + approval::{ChannelApprovalContext, ChannelApprovalPort, ChannelApprovalResolutionContext}, + development::{ + ChannelDevelopmentCommand, ChannelDevelopmentContext, ChannelDevelopmentPort, DevelopmentHandoffSigner, + }, +}; +use aionui_common::now_ms; use aionui_conversation::{ConversationRouterState, ConversationService}; use aionui_cron::{CronEventEmitter, CronRouterState, service::CronServiceDeps}; +use aionui_db::models::MessageRow; use aionui_db::{ - IAcpSessionRepository, IAgentMetadataRepository, IAssistantDefinitionRepository, IAssistantOverlayRepository, + ConversationFilters, ConversationRowUpdate, IAcpSessionRepository, IAgentMetadataRepository, + IAgentWorkspaceLeaseRepository, IApprovalRepository, IAssistantDefinitionRepository, IAssistantOverlayRepository, IAssistantOverrideRepository, IAssistantPreferenceRepository, IAssistantRepository, IConversationRepository, - IProviderRepository, SqliteAcpSessionRepository, SqliteAgentMetadataRepository, - SqliteAssistantDefinitionRepository, SqliteAssistantOverlayRepository, SqliteAssistantOverrideRepository, - SqliteAssistantPreferenceRepository, SqliteAssistantRepository, SqliteClientPreferenceRepository, - SqliteConversationRepository, SqliteFeedbackDiagnosticsRepository, SqliteProviderRepository, - SqliteRemoteAgentRepository, SqliteSettingsRepository, + IDevelopmentRepository, IProjectRepository, IProviderRepository, ITeamRepository, MessagePageDirection, + MessagePageParams, SqliteAcpSessionRepository, SqliteAgentMetadataRepository, SqliteAgentWorkspaceLeaseRepository, + SqliteApprovalRepository, SqliteAssistantDefinitionRepository, SqliteAssistantOverlayRepository, + SqliteAssistantOverrideRepository, SqliteAssistantPreferenceRepository, SqliteAssistantRepository, + SqliteClientPreferenceRepository, SqliteConversationRepository, SqliteDevelopmentOperationsRepository, + SqliteDevelopmentRepository, SqliteFeedbackDiagnosticsRepository, SqliteProjectRepository, + SqliteProviderRepository, SqliteRemoteAgentRepository, SqliteSettingsRepository, SqliteTeamRepository, +}; +use aionui_development::{ + ApprovalError, ApprovalOption, ApprovalRequestInput, ApprovalResolver, ApprovalRouterState, ApprovalService, + ApprovalSource, DeliveryService, DeploymentService, DevelopmentOperationsService, DevelopmentRouterState, + DevelopmentRunner, DevelopmentService, DevelopmentUsageIngestor, DevelopmentWorkspacePort, GhCliDeliveryProvider, + PortabilityService, PrepareDevelopmentWorkspace, PreparedDevelopmentWorkspace, PricingService, + ResolveApprovalContext, ResourceLeaseCoordinator, RetentionService, SecretService, + SystemDevelopmentResourceController, UnconfiguredDeploymentProvider, }; use aionui_extension::{ AssistantRuleDispatcher, ExtensionRegistry, ExtensionRouterState, ExtensionStateStore, ExternalPathsManager, @@ -36,6 +62,10 @@ use aionui_mcp::{ use aionui_office::{ ConversionService, OfficeRouterState, OfficecliWatchManager, ProxyService, SnapshotService as OfficeSnapshotService, }; +use aionui_project::{ + AgentCapabilitySnapshot, CodebaseMemoryCliProvider, ProjectAgentCapabilityPort, ProjectError, ProjectRouterState, + ProjectService, +}; use aionui_realtime::{NoopMessageRouter, WsHandlerState}; use aionui_shell::ShellRouterState; use aionui_system::{ @@ -49,9 +79,769 @@ use aionui_team::{ }; use crate::config::derive_encryption_key; +use crate::router::development_usage::DevelopmentTurnObserver; use crate::router::team_conversation_adapters::TeamConversationAdapters; use crate::services::AppServices; +struct ChannelTeamDirectoryAdapter { + service: Arc, + owner_user_id: String, +} + +struct ChannelPersonalDirectoryAdapter { + conversation_repo: Arc, + owner_user_id: String, +} + +struct ProjectAgentCapabilityAdapter { + service: Arc, +} + +struct ApprovalAgentResolver { + task_manager: Arc, +} + +struct ChannelApprovalAdapter { + service: Arc, + owner_user_id: String, + project_repo: Arc, + development_service: Arc, +} + +struct ChannelDevelopmentAdapter { + owner_user_id: String, + project_repo: Arc, + approval_repo: Arc, + service: Arc, + handoff_signer: DevelopmentHandoffSigner, +} + +struct DevelopmentWorkspaceAdapter { + manager: Arc, +} + +#[async_trait::async_trait] +impl DevelopmentWorkspacePort for DevelopmentWorkspaceAdapter { + async fn prepare(&self, input: PrepareDevelopmentWorkspace) -> Result { + self.manager + .prepare_single_run( + &input.user_id, + &input.run_id, + &input.repository_path, + &input.baseline_commit, + ) + .await + .map(|lease| PreparedDevelopmentWorkspace { + lease_id: lease.id, + workspace_path: lease.worktree_path, + branch: lease.branch_name, + safe_point: lease.base_commit, + }) + .map_err(|error| error.to_string()) + } + + async fn restore(&self, lease_id: &str, safe_point: &str) -> Result { + self.manager + .restore_single_run(lease_id, safe_point) + .await + .map_err(|error| error.to_string()) + } +} + +#[async_trait::async_trait] +impl ApprovalResolver for ApprovalAgentResolver { + async fn resolve( + &self, + conversation_id: &str, + call_id: &str, + value: serde_json::Value, + always_allow: bool, + ) -> Result<(), String> { + let agent = self + .task_manager + .get_task(conversation_id) + .ok_or_else(|| "Conversation agent is no longer running".to_owned())?; + agent + .confirm(call_id, call_id, value, always_allow) + .map_err(|error| error.to_string()) + } +} + +#[async_trait::async_trait] +impl ChannelApprovalPort for ChannelApprovalAdapter { + async fn create( + &self, + context: ChannelApprovalContext, + confirmation: aionui_common::Confirmation, + ) -> Result { + let project = self + .project_repo + .get_for_resource(&self.owner_user_id, "conversation", &context.conversation_id) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))?; + let project_id = project.as_ref().map(|project| project.id.clone()); + let run_id = if let Some(project) = project.as_ref() { + self.development_service + .list_runs(&self.owner_user_id, Some(&project.id)) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))? + .into_iter() + .find(|run| !matches!(run.status.as_str(), "succeeded" | "failed" | "cancelled")) + .map(|run| run.id) + } else { + None + }; + let risk_level = match confirmation.command_type.as_deref() { + Some("read") => "low", + Some("edit") | Some("execute") => "high", + _ => "medium", + }; + let action_type = confirmation.command_type.clone().unwrap_or_else(|| "tool_call".into()); + let row = self + .service + .create(ApprovalRequestInput { + requester_user_id: self.owner_user_id.clone(), + project_id, + run_id, + task_id: None, + conversation_id: context.conversation_id, + agent_id: context.agent_id, + call_id: confirmation.call_id, + action_type, + command: Some(confirmation.description), + working_directory: None, + risk_level: risk_level.into(), + options: confirmation + .options + .into_iter() + .map(|option| ApprovalOption { + label: option.label, + value: option.value, + params: option.params.map(|params| serde_json::json!(params)), + }) + .collect(), + source: Some(ApprovalSource { + channel: context.platform.to_string(), + user_id: context.source_user_id, + chat_id: context.chat_id, + thread_id: context.message_thread_id, + }), + }) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))?; + Ok(row.id) + } + + async fn resolve( + &self, + context: ChannelApprovalResolutionContext, + approval_id: &str, + option_index: usize, + ) -> Result { + let resolution = self + .service + .resolve( + approval_id, + option_index, + ResolveApprovalContext::Channel { + user_id: self.owner_user_id.clone(), + channel: context.platform.to_string(), + source_user_id: context.source_user_id, + chat_id: context.chat_id, + thread_id: context.message_thread_id, + is_admin: context.is_admin, + }, + ) + .await; + match resolution { + Ok(row) => Ok(row.status), + Err(error @ ApprovalError::Conflict(_)) => { + let row = self + .service + .get(&self.owner_user_id, approval_id) + .await + .map_err(|get_error| ChannelError::MessageSendFailed(get_error.to_string()))?; + if matches!(row.status.as_str(), "approved" | "rejected") { + Ok(row.status) + } else { + Err(ChannelError::MessageSendFailed(error.to_string())) + } + } + Err(error) => Err(ChannelError::MessageSendFailed(error.to_string())), + } + } +} + +impl ChannelDevelopmentAdapter { + async fn project_for_context( + &self, + context: &ChannelDevelopmentContext, + ) -> Result { + if let Some(conversation_id) = context.conversation_id.as_deref() + && let Some(project) = self + .project_repo + .get_for_resource(&self.owner_user_id, "conversation", conversation_id) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))? + { + return Ok(project); + } + let projects = self + .project_repo + .list_for_user(&self.owner_user_id) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))?; + match projects.as_slice() { + [project] => Ok(project.clone()), + [] => Err(ChannelError::InvalidConfig( + "当前没有项目，请先在 Web 中创建项目并绑定当前会话。".into(), + )), + _ => Err(ChannelError::InvalidConfig( + "当前会话尚未绑定项目，请先在 Web 项目页完成绑定。".into(), + )), + } + } + + async fn active_run(&self, project_id: &str) -> Result, ChannelError> { + Ok(self + .service + .list_runs(&self.owner_user_id, Some(project_id)) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))? + .into_iter() + .find(|run| !matches!(run.status.as_str(), "succeeded" | "failed" | "cancelled"))) + } + + fn require_run( + run: Option, + ) -> Result { + run.ok_or_else(|| ChannelError::InvalidConfig("当前项目没有进行中的开发运行。".into())) + } +} + +#[async_trait::async_trait] +impl ChannelDevelopmentPort for ChannelDevelopmentAdapter { + async fn execute( + &self, + context: ChannelDevelopmentContext, + command: ChannelDevelopmentCommand, + ) -> Result { + let project = self.project_for_context(&context).await?; + let active_run = self.active_run(&project.id).await?; + if command == ChannelDevelopmentCommand::Project { + return Ok(format!( + "项目：{}\n类型：{}\n目录：{}\n当前运行：{}", + project.name, + project.project_type, + project.local_path, + active_run.as_ref().map(|run| run.status.as_str()).unwrap_or("无") + )); + } + let run = Self::require_run(active_run)?; + let tasks = self + .service + .list_tasks(&self.owner_user_id, &run.id) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))?; + match command { + ChannelDevelopmentCommand::Project => unreachable!(), + ChannelDevelopmentCommand::RunInfo => { + let pending = self + .approval_repo + .list_for_user(&self.owner_user_id, Some(&run.id)) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))? + .into_iter() + .filter(|approval| approval.status == "pending") + .count(); + let completed = tasks.iter().filter(|task| task.status == "completed").count(); + Ok(format!( + "运行：{}\n状态：{}\n模式：{}\n任务：{}/{} 已完成\n待审批：{}\n目标：{}", + run.id, + run.status, + run.execution_mode, + completed, + tasks.len(), + pending, + run.request_summary + )) + } + ChannelDevelopmentCommand::DiffSummary => { + let artifacts = self + .service + .list_artifacts(&self.owner_user_id, &run.id, None) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))?; + let gates = self + .service + .list_gates(&self.owner_user_id, &run.id, None) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))?; + let passed = gates.iter().filter(|gate| gate.status == "passed").count(); + let failed = gates + .iter() + .filter(|gate| matches!(gate.status.as_str(), "failed" | "timed_out")) + .count(); + let expires_at = now_ms().saturating_add(15 * 60 * 1000); + let link = self.handoff_signer.sign(&project.id, &run.id, expires_at); + Ok(format!( + "变更证据：{} 项\n质量门禁：{} 通过 / {} 失败\n详细文件、日志与冲突内容请使用 15 分钟有效的 Web 接力入口：{}", + artifacts.len(), + passed, + failed, + link, + )) + } + ChannelDevelopmentCommand::Test => { + let task = tasks + .iter() + .find(|task| !matches!(task.status.as_str(), "completed" | "cancelled" | "deleted")); + let gate = self + .service + .execute_gate( + &self.owner_user_id, + &run.id, + task.map(|task| task.id.as_str()), + "unit_test", + task.and_then(|task| task.assigned_workspace_lease_id.as_deref()), + true, + ) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))?; + Ok(format!( + "单元测试门禁：{}\n退出码：{}\n耗时：{} ms", + gate.status, + gate.exit_code + .map(|code| code.to_string()) + .unwrap_or_else(|| "无".into()), + gate.duration_ms.unwrap_or_default() + )) + } + ChannelDevelopmentCommand::Stop => { + let single_workspace = if run.execution_mode == "single" { + self.service + .get_single_workspace(&self.owner_user_id, &run.id) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))? + } else { + None + }; + if single_workspace + .as_ref() + .and_then(|workspace| workspace.workspace_lease_id.as_ref()) + .is_some() + { + self.service + .cancel_single_workspace(&self.owner_user_id, &run.id) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))?; + } else { + self.service + .cancel_run(&self.owner_user_id, &run.id) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))?; + } + Ok(format!("运行 {} 已停止。", run.id)) + } + ChannelDevelopmentCommand::Retry => { + let gates = self + .service + .list_gates(&self.owner_user_id, &run.id, None) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))?; + let previous = gates + .iter() + .rev() + .find(|gate| matches!(gate.status.as_str(), "failed" | "timed_out")) + .ok_or_else(|| ChannelError::InvalidConfig("没有可重试的失败门禁。".into()))?; + let task = previous + .task_id + .as_deref() + .and_then(|task_id| tasks.iter().find(|task| task.id == task_id)); + let gate = self + .service + .execute_gate( + &self.owner_user_id, + &run.id, + previous.task_id.as_deref(), + &previous.gate_type, + task.and_then(|task| task.assigned_workspace_lease_id.as_deref()), + previous.required, + ) + .await + .map_err(|error| ChannelError::MessageSendFailed(error.to_string()))?; + Ok(format!("已重试 {} 门禁，结果：{}。", gate.gate_type, gate.status)) + } + ChannelDevelopmentCommand::Handoff => { + let expires_at = now_ms().saturating_add(15 * 60 * 1000); + let link = self.handoff_signer.sign(&project.id, &run.id, expires_at); + Ok(format!( + "Web 接力入口（15 分钟内有效）：{link}\n打开后仍需登录，可查看任务、证据、审批和质量门禁。" + )) + } + } + } +} + +#[async_trait::async_trait] +impl ProjectAgentCapabilityPort for ProjectAgentCapabilityAdapter { + async fn snapshot(&self, id: &str, refresh: bool) -> Result, ProjectError> { + let row = if refresh { + match self.service.health_check_agent_by_id(id).await { + Ok(row) => Some(row), + Err(aionui_ai_agent::AgentError::NotFound(_)) => None, + Err(error) => return Err(ProjectError::Internal(error.to_string())), + } + } else { + self.service + .list_management_agents() + .await + .map_err(|error| ProjectError::Internal(error.to_string()))? + .into_iter() + .find(|row| row.id == id) + }; + Ok(row.map(agent_management_row_to_project_snapshot)) + } +} + +fn serialized_enum(value: &T) -> String { + serde_json::to_value(value) + .ok() + .and_then(|value| value.as_str().map(str::to_owned)) + .unwrap_or_else(|| "unknown".into()) +} + +fn agent_management_row_to_project_snapshot(row: aionui_api_types::AgentManagementRow) -> AgentCapabilitySnapshot { + AgentCapabilitySnapshot { + id: row.id, + agent_type: serialized_enum(&row.agent_type), + enabled: row.enabled, + installed: row.installed, + status: serialized_enum(&row.status), + last_check_status: row.last_check_status.as_ref().map(serialized_enum), + last_check_at: row.last_check_at, + last_success_at: row.last_success_at, + agent_capabilities: row.agent_capabilities, + available_models: row.available_models, + available_modes: row.available_modes, + available_commands: row.available_commands, + dynamic_probe: row.dynamic_probe, + } +} + +#[async_trait::async_trait] +impl ChannelTeamDirectory for ChannelTeamDirectoryAdapter { + async fn list_teams(&self, user_id: &str) -> Result, ChannelError> { + let teams = self + .service + .list_teams(user_id) + .await + .map_err(|e| ChannelError::MessageSendFailed(e.to_string()))?; + if teams.is_empty() && user_id != self.owner_user_id { + let owner_teams = self + .service + .list_teams(&self.owner_user_id) + .await + .map_err(|e| ChannelError::MessageSendFailed(e.to_string()))?; + return Ok(owner_teams.into_iter().map(team_response_to_channel_summary).collect()); + } + Ok(teams.into_iter().map(team_response_to_channel_summary).collect()) + } + + async fn get_team(&self, user_id: &str, team_id: &str) -> Result, ChannelError> { + Ok(self + .list_teams(user_id) + .await? + .into_iter() + .find(|team| team.id == team_id)) + } + + async fn ensure_team_session(&self, user_id: &str, team_id: &str) -> Result<(), ChannelError> { + match self.service.ensure_session(user_id, team_id).await { + Ok(()) => Ok(()), + Err(primary_error) if user_id != self.owner_user_id => self + .service + .ensure_session(&self.owner_user_id, team_id) + .await + .map_err(|fallback_error| { + ChannelError::MessageSendFailed(format!( + "primary user failed: {primary_error}; owner fallback failed: {fallback_error}" + )) + }), + Err(error) => Err(ChannelError::MessageSendFailed(error.to_string())), + } + } + + async fn create_team( + &self, + user_id: &str, + request: ChannelTeamCreateRequest, + ) -> Result { + let owner_user_id = if user_id == self.owner_user_id { + user_id + } else { + &self.owner_user_id + }; + let team = self + .service + .create_team( + owner_user_id, + CreateTeamRequest { + name: request.name, + agents: vec![TeamAgentInput { + name: request.lead_name, + role: request.lead_role, + backend: None, + model: request.model, + assistant_id: Some(request.assistant_id), + conversation_id: None, + }], + workspace: None, + source_channel: request.source_channel, + source_channel_id: request.source_channel_id, + source_chat_id: request.source_chat_id, + source_user_id: request.source_user_id, + source_label: request.source_label, + created_from: request.created_from, + }, + ) + .await + .map_err(|e| ChannelError::MessageSendFailed(e.to_string()))?; + Ok(team_response_to_channel_summary(team)) + } +} + +#[async_trait::async_trait] +impl ChannelPersonalDirectory for ChannelPersonalDirectoryAdapter { + async fn list_personal_conversations( + &self, + user_id: &str, + platform: aionui_channel::types::PluginType, + chat_id: &str, + ) -> Result, ChannelError> { + let conversations = self.list_for_user(user_id, platform, chat_id).await?; + if conversations.is_empty() && user_id != self.owner_user_id { + return self.list_for_user(&self.owner_user_id, platform, chat_id).await; + } + Ok(conversations) + } + + async fn get_personal_conversation( + &self, + user_id: &str, + platform: aionui_channel::types::PluginType, + chat_id: &str, + conversation_id: &str, + ) -> Result, ChannelError> { + Ok(self + .list_personal_conversations(user_id, platform, chat_id) + .await? + .into_iter() + .find(|conversation| conversation.id == conversation_id)) + } + + async fn rename_personal_conversation( + &self, + user_id: &str, + platform: aionui_channel::types::PluginType, + chat_id: &str, + conversation_id: &str, + title: &str, + ) -> Result, ChannelError> { + if self + .get_personal_conversation(user_id, platform, chat_id, conversation_id) + .await? + .is_none() + { + return Ok(None); + } + + let Some(row) = self + .conversation_repo + .get(conversation_id) + .await + .map_err(|e| ChannelError::MessageSendFailed(e.to_string()))? + else { + return Ok(None); + }; + let mut extra: serde_json::Value = serde_json::from_str(&row.extra).unwrap_or_else(|_| serde_json::json!({})); + if !extra.is_object() { + extra = serde_json::json!({}); + } + extra["title_source"] = serde_json::Value::String("manual".to_owned()); + extra["auto_title"] = serde_json::Value::Bool(false); + + self.conversation_repo + .update( + conversation_id, + &ConversationRowUpdate { + name: Some(title.to_owned()), + extra: Some(extra.to_string()), + updated_at: Some(now_ms()), + ..Default::default() + }, + ) + .await + .map_err(|e| ChannelError::MessageSendFailed(e.to_string()))?; + + self.get_personal_conversation(user_id, platform, chat_id, conversation_id) + .await + } +} + +impl ChannelPersonalDirectoryAdapter { + async fn list_for_user( + &self, + user_id: &str, + platform: aionui_channel::types::PluginType, + chat_id: &str, + ) -> Result, ChannelError> { + let platform_key = platform.to_string(); + let page = self + .conversation_repo + .list_paginated( + user_id, + &ConversationFilters { + limit: 50, + source: Some(platform_key.clone()), + ..Default::default() + }, + ) + .await + .map_err(|e| ChannelError::MessageSendFailed(e.to_string()))?; + + let mut conversations = Vec::new(); + for row in page.items { + let extra: serde_json::Value = serde_json::from_str(&row.extra).unwrap_or(serde_json::Value::Null); + if extra + .get("teamId") + .and_then(serde_json::Value::as_str) + .is_some_and(|value| !value.trim().is_empty()) + { + continue; + } + + let source_channel = row + .source_channel + .as_deref() + .or_else(|| extra.get("source_channel").and_then(serde_json::Value::as_str)) + .or(row.source.as_deref()) + .unwrap_or_default(); + if source_channel != platform_key { + continue; + } + + let source_chat_id = row + .source_chat_id + .as_deref() + .or_else(|| extra.get("source_chat_id").and_then(serde_json::Value::as_str)) + .or(row.channel_chat_id.as_deref()); + if let Some(source_chat_id) = source_chat_id + && !source_chat_id.trim().is_empty() + && source_chat_id != chat_id + { + continue; + } + + let backend = extra.get("backend").and_then(serde_json::Value::as_str); + let agent_label = agent_label_for_channel_conversation(&row.r#type, backend); + let recent_message = self.recent_user_message_for_conversation(&row.id).await?; + conversations.push(ChannelPersonalConversationSummary { + id: row.id, + name: row.name, + agent_type: row.r#type, + agent_label: Some(agent_label), + recent_message, + }); + } + + Ok(conversations) + } + + async fn recent_user_message_for_conversation( + &self, + conversation_id: &str, + ) -> Result, ChannelError> { + let page = self + .conversation_repo + .list_messages_page( + conversation_id, + &MessagePageParams { + limit: 12, + direction: MessagePageDirection::InitialLatest, + }, + ) + .await + .map_err(|e| ChannelError::MessageSendFailed(e.to_string()))?; + Ok(page.items.iter().rev().find_map(channel_user_message_preview)) + } +} + +fn channel_user_message_preview(row: &MessageRow) -> Option { + if row.hidden || row.r#type != "text" || row.position.as_deref() != Some("right") { + return None; + } + let value: serde_json::Value = serde_json::from_str(&row.content).ok()?; + value + .get("content") + .or_else(|| value.get("text")) + .and_then(serde_json::Value::as_str) + .and_then(short_preview_text) +} + +fn short_preview_text(raw: &str) -> Option { + let collapsed = raw.split_whitespace().collect::>().join(" "); + let trimmed = collapsed.trim(); + if trimmed.is_empty() { + return None; + } + Some(truncate_chars(trimmed, 48)) +} + +fn agent_label_for_channel_conversation(agent_type: &str, backend: Option<&str>) -> String { + match (agent_type, backend.map(str::trim).filter(|value| !value.is_empty())) { + ("aionrs", _) => "Aion CLI".to_owned(), + ("acp", Some("claude")) => "Claude Code".to_owned(), + ("acp", Some("codex")) => "Codex CLI".to_owned(), + ("acp", Some("cursor")) => "Cursor".to_owned(), + ("acp", Some("hermes")) => "Hermes".to_owned(), + ("acp", Some("openclaw")) => "OpenClaw".to_owned(), + ("acp", Some(other)) => other.to_owned(), + ("acp", None) => "ACP Agent".to_owned(), + (other, _) => other.to_owned(), + } +} + +fn truncate_chars(value: &str, max_chars: usize) -> String { + let chars: Vec = value.chars().collect(); + if chars.len() <= max_chars { + return value.to_owned(); + } + let head: String = chars.into_iter().take(max_chars).collect(); + format!("{head}...") +} + +fn team_response_to_channel_summary(team: aionui_api_types::TeamResponse) -> ChannelTeamSummary { + let lead_conversation_id = team + .assistants + .iter() + .find(|agent| { + agent.role == "lead" + || team + .leader_assistant_id + .as_deref() + .is_some_and(|leader| leader == agent.slot_id) + }) + .or_else(|| team.assistants.first()) + .map(|agent| agent.conversation_id.clone()); + ChannelTeamSummary { + id: team.id, + name: team.name, + lead_conversation_id, + agent_count: team.assistants.len(), + } +} + #[derive(Debug)] pub struct RouterBuildError { stage: &'static str, @@ -135,6 +925,8 @@ pub struct ModuleStates { pub channel: ChannelRouterState, pub team: TeamRouterState, pub cron: CronRouterState, + pub project: ProjectRouterState, + pub development: DevelopmentRouterState, pub office: OfficeRouterState, pub shell: ShellRouterState, pub assistant: AssistantRouterState, @@ -226,11 +1018,7 @@ pub async fn build_module_states( // resolve empty rules. Mirrors the interactive path in build_conversation_state. cron.conversation_service .with_assistant_dispatcher(assistant.service.clone() as Arc); - cron.cron_service.init().await; - tracing::info!( - elapsed_ms = boot.elapsed().as_millis(), - "startup: cron state initialized" - ); + tracing::info!(elapsed_ms = boot.elapsed().as_millis(), "startup: cron state built"); // The agent catalog already hydrated at startup (see `lib.rs`). // Extension-contributed rows will land in `agent_metadata` in a @@ -239,9 +1027,6 @@ pub async fn build_module_states( let dispatcher: Arc = assistant.service.clone(); skill_state.assistant_dispatcher = Some(dispatcher); - let (channel_state, channel_components) = build_channel_state(services, ext_state.registry.clone()).await; - tracing::info!(elapsed_ms = boot.elapsed().as_millis(), "startup: channel state built"); - let backend_binary_path = Arc::new( std::env::current_exe() .ok() @@ -253,6 +1038,19 @@ pub async fn build_module_states( "startup: backend binary path resolved" ); + let team_state = build_module_state_phase(&boot, "team", || { + build_team_state( + services, + Some(cron.cron_service.clone()), + backend_binary_path.clone(), + assistant.service.clone(), + ) + }); + + let (channel_state, channel_components) = + build_channel_state(services, ext_state.registry.clone(), Some(team_state.service.clone())).await; + tracing::info!(elapsed_ms = boot.elapsed().as_millis(), "startup: channel state built"); + let pool = services.database.pool().clone(); let provider_repo: Arc = Arc::new(SqliteProviderRepository::new(pool.clone())); let encryption_key = derive_encryption_key(&services.jwt_secret_raw); @@ -268,6 +1066,11 @@ pub async fn build_module_states( .with_agent_availability_feedback(agent_service.availability_feedback_port()); tracing::info!(elapsed_ms = boot.elapsed().as_millis(), "startup: agent service built"); + let project = build_module_state_phase(&boot, "project", || { + build_project_state(services, agent_service.clone()) + }); + let development = build_module_state_phase(&boot, "development", || build_development_state(services)); + tracing::info!( elapsed_ms = boot.elapsed().as_millis(), "startup: module states bundle started" @@ -284,7 +1087,7 @@ pub async fn build_module_states( remote_agent: build_module_state_phase(&boot, "remote_agent", || build_remote_agent_state(services)), agent: build_module_state_phase(&boot, "agent", || AgentRouterState { agent_registry: services.agent_registry.clone(), - service: agent_service, + service: agent_service.clone(), }), connection_test: build_module_state_phase(&boot, "connection_test", build_connection_test_state), file: build_module_state_phase(&boot, "file", || build_file_state(services))?, @@ -293,15 +1096,10 @@ pub async fn build_module_states( hub: hub_state, skill: skill_state, channel: channel_state, - team: build_module_state_phase(&boot, "team", || { - build_team_state( - services, - Some(cron.cron_service.clone()), - backend_binary_path.clone(), - assistant.service.clone(), - ) - }), + team: team_state, cron, + project, + development, office: build_module_state_phase(&boot, "office", || build_office_state(services)), shell: build_module_state_phase(&boot, "shell", || build_shell_state(services)), assistant, @@ -310,15 +1108,184 @@ pub async fn build_module_states( elapsed_ms = boot.elapsed().as_millis(), "startup: module state build completed" ); + let usage_ingestor = DevelopmentUsageIngestor::new( + Arc::new(SqliteProjectRepository::new(services.database.pool().clone())), + states.development.development_repo.clone(), + states.development.operations_repo.clone(), + states.development.operations_service.as_ref().clone(), + states.development.pricing_service.as_ref().clone(), + ); + let usage_observer = Arc::new(DevelopmentTurnObserver::new( + usage_ingestor, + states.development.operations_service.as_ref().clone(), + states.conversation.service.clone(), + states.conversation.task_manager.clone(), + )); + states.conversation.service.with_turn_observer(usage_observer.clone()); + states.conversation.service.with_turn_guard(usage_observer.clone()); + states + .cron + .conversation_service + .with_turn_observer(usage_observer.clone()); + states.cron.conversation_service.with_turn_guard(usage_observer); + // Start the scheduler only after its private ConversationService has the + // same usage observer and budget admission guard as interactive turns. + // Otherwise an overdue job can fire in the startup window unmetered. + if !states.cron.conversation_service.has_turn_policy() { + return Err(RouterBuildError::new( + "router.cron.turn_policy", + "cron scheduler cannot start before usage observation and budget admission are installed", + )); + } + states.cron.cron_service.init().await; + tracing::info!( + elapsed_ms = boot.elapsed().as_millis(), + "startup: cron state initialized" + ); states .conversation .service .recover_stale_runtime_state_on_startup() .await; + if let Err(error) = states + .development + .operations_service + .reconcile_stale_runs(30 * 60 * 1000) + .await + { + tracing::warn!(error = %error, "development recovery reconciliation failed"); + } Ok((states, channel_components)) } +fn build_project_state(services: &AppServices, agent_service: Arc) -> ProjectRouterState { + let pool = services.database.pool().clone(); + let project_repo: Arc = Arc::new(SqliteProjectRepository::new(pool.clone())); + let conversation_repo: Arc = Arc::new(SqliteConversationRepository::new(pool.clone())); + let team_repo: Arc = Arc::new(SqliteTeamRepository::new(pool)); + let agent_port: Arc = + Arc::new(ProjectAgentCapabilityAdapter { service: agent_service }); + let knowledge_command = + std::env::var("AIONUI_CODEBASE_MEMORY_COMMAND").unwrap_or_else(|_| "codebase-memory-mcp".into()); + ProjectRouterState { + service: Arc::new( + ProjectService::new(project_repo, conversation_repo, team_repo, agent_port) + .with_managed_project_root(services.data_dir.join("projects")) + .with_knowledge_provider(Arc::new(CodebaseMemoryCliProvider::new(knowledge_command))), + ), + } +} + +fn build_development_state(services: &AppServices) -> DevelopmentRouterState { + let pool = services.database.pool().clone(); + let development_repo: Arc = Arc::new(SqliteDevelopmentRepository::new(pool.clone())); + let project_repo: Arc = Arc::new(SqliteProjectRepository::new(pool.clone())); + let lease_repo: Arc = + Arc::new(SqliteAgentWorkspaceLeaseRepository::new(pool.clone())); + let workspace = Arc::new(DevelopmentWorkspaceAdapter { + manager: Arc::new(aionui_team::GitTeamWorkspaceManager::new( + lease_repo.clone(), + services.data_dir.join("development-worktrees"), + )), + }); + let operations_repo = Arc::new(SqliteDevelopmentOperationsRepository::new(pool.clone())); + let secret_service = Arc::new(SecretService::new( + operations_repo.clone(), + project_repo.clone(), + Arc::new(derive_encryption_key(&services.jwt_secret_raw)), + )); + let resources = ResourceLeaseCoordinator::new(operations_repo.clone(), format!("app:{}", std::process::id())); + let resource_controller = Arc::new(SystemDevelopmentResourceController); + let runner = Arc::new( + DevelopmentRunner::new(operations_repo.clone(), resources.clone(), resource_controller.clone()) + .with_secrets(secret_service.as_ref().clone()), + ); + let operations_service = Arc::new( + DevelopmentOperationsService::new( + operations_repo.clone(), + development_repo.clone(), + project_repo.clone(), + lease_repo.clone(), + ) + .with_resources(resources, resource_controller), + ); + let pricing_service = + Arc::new(PricingService::new(operations_repo.clone()).with_budget(operations_service.as_ref().clone())); + let mut portability_service = PortabilityService::new( + pool.clone(), + services.jwt_secret_raw.as_bytes(), + format!("app:{}", std::process::id()), + ); + if let Ok(configured_signers) = std::env::var("AIONUI_PORTABILITY_TRUSTED_SIGNERS") { + for signer in configured_signers + .split(',') + .map(str::trim) + .filter(|value| !value.is_empty()) + { + if let Err(error) = portability_service.trust_signer(signer) { + tracing::warn!(error = %error, "ignored invalid configured portability signer"); + } + } + } + let portability_service = Arc::new(portability_service); + let retention_service = Arc::new(RetentionService::new(pool)); + let startup_portability = portability_service.clone(); + tokio::spawn(async move { + if let Err(error) = startup_portability.record_startup().await { + tracing::warn!(error = %error, "failed to update platform instance startup metadata"); + } + }); + DevelopmentRouterState { + service: Arc::new( + DevelopmentService::new( + development_repo.clone(), + project_repo.clone(), + lease_repo, + services.data_dir.join("development-artifacts"), + ) + .with_operations(operations_service.clone()) + .with_workspace(workspace) + .with_runner(runner), + ), + delivery_service: Arc::new( + DeliveryService::new( + development_repo.clone(), + project_repo.clone(), + Arc::new(GhCliDeliveryProvider), + ) + .with_operations(operations_service.clone()), + ), + deployment_service: Arc::new( + DeploymentService::new( + development_repo.clone(), + project_repo, + Arc::new(UnconfiguredDeploymentProvider), + ) + .with_operations(operations_service.clone()), + ), + operations_service, + secret_service, + pricing_service, + development_repo, + operations_repo, + approval_repo: Arc::new(SqliteApprovalRepository::new(services.database.pool().clone())), + portability_service, + retention_service, + } +} + +pub fn build_approval_state(services: &AppServices) -> ApprovalRouterState { + let repository: Arc = + Arc::new(SqliteApprovalRepository::new(services.database.pool().clone())); + let resolver: Arc = Arc::new(ApprovalAgentResolver { + task_manager: services.worker_task_manager.clone(), + }); + ApprovalRouterState { + service: Arc::new(ApprovalService::new(repository, resolver)), + } +} + /// Build the default `AssistantRouterState` from application services. pub fn build_assistant_state(services: &AppServices) -> AssistantRouterState { #[derive(Clone)] @@ -494,6 +1461,9 @@ fn build_channel_settings_service( .with_agent_metadata_repo(Arc::new(SqliteAgentMetadataRepository::new( services.database.pool().clone(), ))) + .with_provider_repo(Arc::new(SqliteProviderRepository::new( + services.database.pool().clone(), + ))) .with_assistant_repos( Arc::new(SqliteAssistantDefinitionRepository::new( services.database.pool().clone(), @@ -506,28 +1476,44 @@ fn build_channel_settings_service( async fn build_channel_message_service( services: &AppServices, channel_settings: Arc, + team_service: Option>, ) -> Arc { - let owner_user_id = services + let owner_user_id = get_channel_owner_user_id(services).await; + + let pool = services.database.pool().clone(); + let mut service = aionui_channel::message_service::ChannelMessageService::new( + Arc::new(services.conversation_service.clone()), + services.worker_task_manager.clone(), + channel_settings, + owner_user_id, + ) + .with_conversation_repo(Arc::new(SqliteConversationRepository::new(pool))); + + if let Some(team_service) = &team_service { + service = service.with_team_sender(Arc::new(ChannelTeamSenderAdapter { + service: Arc::clone(team_service), + })); + } + + Arc::new(service) +} + +async fn get_channel_owner_user_id(services: &AppServices) -> String { + services .user_repo .get_primary_webui_user() .await .ok() .flatten() .map(|u| u.id) - .unwrap_or_else(|| "system_default_user".to_string()); - - Arc::new(aionui_channel::message_service::ChannelMessageService::new( - Arc::new(services.conversation_service.clone()), - services.worker_task_manager.clone(), - channel_settings, - owner_user_id, - )) + .unwrap_or_else(|| "system_default_user".to_string()) } /// Build the default `ChannelRouterState` and orchestrator components. pub async fn build_channel_state( services: &AppServices, extension_registry: ExtensionRegistry, + team_service: Option>, ) -> (ChannelRouterState, ChannelOrchestratorComponents) { let pool = services.database.pool().clone(); let repo: Arc = Arc::new(aionui_db::SqliteChannelRepository::new(pool)); @@ -556,22 +1542,75 @@ pub async fn build_channel_state( // Build channel settings service for per-plugin agent/model configuration. let channel_settings = build_channel_settings_service(services); + let owner_user_id = get_channel_owner_user_id(services).await; + let project_repo: Arc = + Arc::new(SqliteProjectRepository::new(services.database.pool().clone())); + let development_state = build_development_state(services); + let approval_port: Arc = Arc::new(ChannelApprovalAdapter { + service: build_approval_state(services).service, + owner_user_id: owner_user_id.clone(), + project_repo: project_repo.clone(), + development_service: development_state.service.clone(), + }); + let development_port: Arc = Arc::new(ChannelDevelopmentAdapter { + owner_user_id: owner_user_id.clone(), + project_repo: project_repo.clone(), + approval_repo: Arc::new(SqliteApprovalRepository::new(services.database.pool().clone())), + service: development_state.service, + handoff_signer: DevelopmentHandoffSigner::new(encryption_key, "/#/projects"), + }); // Build orchestrator dependencies - let action_executor = Arc::new(aionui_channel::action::ActionExecutor::new( + let mut action_executor = aionui_channel::action::ActionExecutor::new( Arc::clone(&pairing_service), Arc::clone(&session_manager), Arc::clone(&channel_settings), - )); + ) + .with_approval_port(approval_port.clone()) + .with_development_port(development_port); + if let Some(team_service) = &team_service { + let team_directory = Arc::new(ChannelTeamDirectoryAdapter { + service: Arc::clone(team_service), + owner_user_id: owner_user_id.clone(), + }) as Arc; + action_executor = action_executor.with_team_directory(team_directory); + } + let personal_directory = Arc::new(ChannelPersonalDirectoryAdapter { + conversation_repo: services.conversation_repo.clone(), + owner_user_id: owner_user_id.clone(), + }) as Arc; + action_executor = action_executor.with_personal_directory(personal_directory); + let action_executor = Arc::new(action_executor); + + let message_service = build_channel_message_service(services, Arc::clone(&channel_settings), team_service).await; - let message_service = build_channel_message_service(services, Arc::clone(&channel_settings)).await; + let team_event_relay = aionui_channel::team_event_relay::ChannelTeamEventRelay::new( + services.event_bus.subscribe(), + repo.clone(), + services.conversation_repo.clone(), + manager.clone() as Arc, + ); + tokio::spawn(team_event_relay.run()); + let development_notifier = aionui_channel::team_event_relay::ChannelDevelopmentNotifier::new( + owner_user_id.clone(), + repo.clone(), + project_repo, + Arc::new(SqliteDevelopmentRepository::new(services.database.pool().clone())), + Arc::new(SqliteDevelopmentOperationsRepository::new( + services.database.pool().clone(), + )), + Arc::new(SqliteApprovalRepository::new(services.database.pool().clone())), + manager.clone() as Arc, + ); + tokio::spawn(development_notifier.run()); let orchestrator = aionui_channel::orchestrator::ChannelOrchestrator::new( action_executor, message_service, Arc::clone(&session_manager), manager.clone() as Arc, - ); + ) + .with_approval_port(approval_port); let state = ChannelRouterState { manager: Arc::clone(&manager), @@ -594,6 +1633,35 @@ pub async fn build_channel_state( (state, components) } +struct ChannelTeamSenderAdapter { + service: Arc, +} + +#[async_trait::async_trait] +impl ChannelTeamSender for ChannelTeamSenderAdapter { + async fn send_team_lead_message(&self, user_id: &str, team_id: &str, content: &str) -> Result<(), ChannelError> { + self.service + .send_message(user_id, team_id, content, None) + .await + .map(|_| ()) + .map_err(|e| ChannelError::MessageSendFailed(e.to_string())) + } + + async fn send_team_agent_message( + &self, + user_id: &str, + team_id: &str, + slot_id: &str, + content: &str, + ) -> Result<(), ChannelError> { + self.service + .send_message_to_agent(user_id, team_id, slot_id, content, None) + .await + .map(|_| ()) + .map_err(|e| ChannelError::MessageSendFailed(e.to_string())) + } +} + /// Build the default `TeamRouterState` from application services. /// /// `backend_binary_path` is resolved once in `build_module_states` via @@ -656,7 +1724,14 @@ pub fn build_team_state( let projection_store: Arc = adapters.clone(); let turn_port: Arc = adapters.clone(); let cancellation_port: Arc = adapters; - let service = TeamSessionService::new_with_prompt_dump( + let workspace_manager: Arc = + Arc::new(aionui_team::GitTeamWorkspaceManager::new( + Arc::new(aionui_db::SqliteAgentWorkspaceLeaseRepository::new( + services.database.pool().clone(), + )), + services.data_dir.join("team-worktrees"), + )); + let service = TeamSessionService::new_with_workspace_manager_and_prompt_dump( team_repo, Arc::new(SqliteAgentMetadataRepository::new(services.database.pool().clone())), Arc::new(AssistantServiceTeamCatalog { assistant_service }), @@ -672,6 +1747,7 @@ pub fn build_team_state( turn_port, cancellation_port, backend_binary_path, + workspace_manager, aionui_team::TeamPromptDumpConfig::from_data_dir(&services.data_dir, services.dump_prompts), ); TeamRouterState { @@ -948,6 +2024,8 @@ mod tests { impl IMockAgent for ChannelStateNoopAgent {} + type CapturedRuntimeEnv = Arc>>>; + fn mock_worker_task_manager() -> Arc { let factory = Arc::new(|opts: BuildTaskOptions| { Box::pin(async move { @@ -961,9 +2039,7 @@ mod tests { Arc::new(WorkerTaskManagerImpl::new(factory)) } - fn capturing_worker_task_manager( - captured_env: Arc>>>, - ) -> Arc { + fn capturing_worker_task_manager(captured_env: CapturedRuntimeEnv) -> Arc { let factory = Arc::new(move |opts: BuildTaskOptions| { let captured_env = captured_env.clone(); Box::pin(async move { @@ -980,7 +2056,7 @@ mod tests { Arc::new(WorkerTaskManagerImpl::new(factory)) } - async fn wait_for_captured_env(captured_env: &Arc>>>) -> Vec<(String, String)> { + async fn wait_for_captured_env(captured_env: &CapturedRuntimeEnv) -> Vec<(String, String)> { for _ in 0..50 { if let Some(env) = captured_env.lock().unwrap().first().cloned() { return env; @@ -1047,15 +2123,21 @@ mod tests { let pref_repo = SqliteClientPreferenceRepository::new(pool.clone()); pref_repo - .upsert_batch(&[( - "assistant.weixin.agent", - r#"{"assistant_id":"bare-channel-aionrs","name":"Weixin Aionrs"}"#, - )]) + .upsert_batch(&[ + ( + "assistant.weixin.agent", + r#"{"assistant_id":"bare-channel-aionrs","name":"Weixin Aionrs"}"#, + ), + ( + "assistant.weixin.defaultModel", + r#"{"id":"test-provider","use_model":"test-model"}"#, + ), + ]) .await .unwrap(); let settings = build_channel_settings_service(&services); - let message_service = build_channel_message_service(&services, settings).await; + let message_service = build_channel_message_service(&services, settings, None).await; let session = AssistantSessionRow { id: "session-channel-state".to_owned(), user_id: "channel-user-state".to_owned(), @@ -1063,6 +2145,11 @@ mod tests { conversation_id: None, workspace: None, chat_id: Some("wx-chat-state".to_owned()), + message_thread_id: None, + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, created_at: 1, last_activity: 1, }; @@ -1207,6 +2294,238 @@ mod tests { services.database.close().await; } + #[tokio::test] + async fn channel_development_adapter_reports_bound_project_and_run() { + let db = aionui_db::init_database_memory().await.unwrap(); + let project_dir = tempfile::tempdir().unwrap(); + let project_repo = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + project_repo + .create(&aionui_db::models::ProjectRow { + id: "project-channel".into(), + user_id: "system_default_user".into(), + name: "Aion".into(), + local_path: project_dir.path().to_string_lossy().into_owned(), + repository_url: None, + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + project_repo + .bind_resource( + "project-channel", + "system_default_user", + "conversation", + "conversation-channel", + ) + .await + .unwrap(); + let development_repo = Arc::new(SqliteDevelopmentRepository::new(db.pool().clone())); + development_repo + .create_run(&aionui_db::models::DevelopmentRunRow { + id: "run-channel".into(), + user_id: "system_default_user".into(), + project_id: "project-channel".into(), + team_id: None, + source_channel: Some("telegram".into()), + source_user_id: Some("assistant-user".into()), + execution_mode: "single".into(), + status: "running".into(), + request_summary: "Implement approvals".into(), + acceptance_criteria: "[]".into(), + baseline_commit: None, + integration_branch: None, + started_at: Some(1), + finished_at: None, + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + let service = Arc::new(DevelopmentService::new( + development_repo.clone(), + project_repo.clone(), + Arc::new(SqliteAgentWorkspaceLeaseRepository::new(db.pool().clone())), + project_dir.path().join("artifacts"), + )); + let adapter = ChannelDevelopmentAdapter { + owner_user_id: "system_default_user".into(), + project_repo, + approval_repo: Arc::new(SqliteApprovalRepository::new(db.pool().clone())), + service, + handoff_signer: DevelopmentHandoffSigner::new([9; 32], "/#/projects"), + }; + let context = ChannelDevelopmentContext { + source_user_id: "assistant-user".into(), + conversation_id: Some("conversation-channel".into()), + platform: PluginType::Telegram, + chat_id: "chat".into(), + message_thread_id: Some(5), + }; + + let project = adapter + .execute(context.clone(), ChannelDevelopmentCommand::Project) + .await + .unwrap(); + assert!(project.contains("项目：Aion")); + assert!(project.contains("当前运行：running")); + let run = adapter + .execute(context.clone(), ChannelDevelopmentCommand::RunInfo) + .await + .unwrap(); + assert!(run.contains("运行：run-channel")); + let handoff = adapter + .execute(context, ChannelDevelopmentCommand::Handoff) + .await + .unwrap(); + assert!(handoff.contains("/#/projects?projectId=project-channel&runId=run-channel")); + assert!(handoff.contains("&expires=")); + assert!(handoff.contains("&signature=")); + } + + #[tokio::test] + async fn channel_approval_adapter_links_run_and_reuses_final_status_for_duplicate_resolution() { + struct NoopApprovalResolver; + + #[async_trait::async_trait] + impl ApprovalResolver for NoopApprovalResolver { + async fn resolve( + &self, + _conversation_id: &str, + _call_id: &str, + _value: serde_json::Value, + _always_allow: bool, + ) -> Result<(), String> { + Ok(()) + } + } + + let db = aionui_db::init_database_memory().await.unwrap(); + let project_dir = tempfile::tempdir().unwrap(); + sqlx::query( + "INSERT INTO conversations \ + (id, user_id, name, type, extra, pinned, created_at, updated_at) \ + VALUES ('conversation-approval', 'system_default_user', 'Approval', 'acp', '{}', 0, 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + let project_repo = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + project_repo + .create(&aionui_db::models::ProjectRow { + id: "project-approval".into(), + user_id: "system_default_user".into(), + name: "Aion".into(), + local_path: project_dir.path().to_string_lossy().into_owned(), + repository_url: None, + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + project_repo + .bind_resource( + "project-approval", + "system_default_user", + "conversation", + "conversation-approval", + ) + .await + .unwrap(); + let development_repo = Arc::new(SqliteDevelopmentRepository::new(db.pool().clone())); + development_repo + .create_run(&aionui_db::models::DevelopmentRunRow { + id: "run-approval".into(), + user_id: "system_default_user".into(), + project_id: "project-approval".into(), + team_id: None, + source_channel: Some("telegram".into()), + source_user_id: Some("telegram-user".into()), + execution_mode: "single".into(), + status: "running".into(), + request_summary: "Exercise remote approval".into(), + acceptance_criteria: "[]".into(), + baseline_commit: None, + integration_branch: None, + started_at: Some(1), + finished_at: None, + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + let approval_repo = Arc::new(SqliteApprovalRepository::new(db.pool().clone())); + let development_service = Arc::new(DevelopmentService::new( + development_repo, + project_repo.clone(), + Arc::new(SqliteAgentWorkspaceLeaseRepository::new(db.pool().clone())), + project_dir.path().join("artifacts"), + )); + let adapter = ChannelApprovalAdapter { + service: Arc::new(ApprovalService::new( + approval_repo.clone(), + Arc::new(NoopApprovalResolver), + )), + owner_user_id: "system_default_user".into(), + project_repo, + development_service, + }; + + let approval_id = adapter + .create( + ChannelApprovalContext { + source_user_id: "telegram-user".into(), + conversation_id: "conversation-approval".into(), + agent_id: Some("codex".into()), + platform: PluginType::Telegram, + chat_id: "chat".into(), + message_thread_id: Some(3), + }, + aionui_common::Confirmation { + id: "confirmation-1".into(), + call_id: "call-1".into(), + title: Some("Run tests?".into()), + action: None, + description: "cargo test".into(), + command_type: Some("execute".into()), + options: vec![aionui_common::ConfirmationOption { + label: "Allow once".into(), + value: serde_json::json!(true), + params: None, + }], + }, + ) + .await + .unwrap(); + + let row = approval_repo.get(&approval_id).await.unwrap().unwrap(); + assert_eq!(row.project_id.as_deref(), Some("project-approval")); + assert_eq!(row.run_id.as_deref(), Some("run-approval")); + + let resolution_context = ChannelApprovalResolutionContext { + source_user_id: "telegram-user".into(), + platform: PluginType::Telegram, + chat_id: "chat".into(), + message_thread_id: Some(3), + is_admin: false, + }; + assert_eq!( + adapter + .resolve(resolution_context.clone(), &approval_id, 0) + .await + .unwrap(), + "approved" + ); + assert_eq!( + adapter.resolve(resolution_context, &approval_id, 0).await.unwrap(), + "approved" + ); + } + #[test] fn file_watch_init_error_maps_to_bootstrap_server_failed() { let err = file_watch_init_error(aionui_file::FileError::Internal("watch backend unavailable".into())); diff --git a/crates/aionui-app/src/router/team_conversation_adapters.rs b/crates/aionui-app/src/router/team_conversation_adapters.rs index 4e6ea5662..5c4094187 100644 --- a/crates/aionui-app/src/router/team_conversation_adapters.rs +++ b/crates/aionui-app/src/router/team_conversation_adapters.rs @@ -12,7 +12,7 @@ use aionui_team::{ AgentTurnCancellationPort, AgentTurnExecutionError, AgentTurnExecutionPort, AgentTurnOutcome, AgentTurnRequest, AgentTurnStarted, AgentTurnStatus, TeamConversationBindingLookup, TeamConversationCreateRequest, TeamConversationCreateResult, TeamConversationLookupPort, TeamConversationProvisioningPort, TeamError, - TeamProjectionMessageStore, + TeamProjectionMessageStore, TeamSourceMetadata, }; use async_trait::async_trait; use tracing::info; @@ -37,6 +37,28 @@ impl TeamConversationAdapters { } } +fn json_string(value: &serde_json::Value, key: &str) -> Option { + value + .get(key) + .and_then(serde_json::Value::as_str) + .map(str::trim) + .filter(|value| !value.is_empty()) + .map(str::to_owned) +} + +fn source_label(source_channel: &str) -> &'static str { + match source_channel { + "telegram" => "Telegram", + "lark" => "Lark", + "dingtalk" => "DingTalk", + "weixin" | "wecom" => "WeCom", + "discord" => "Discord", + "desktop" => "Desktop", + "webui" | "aionui" => "WebUI", + _ => "本地历史", + } +} + #[async_trait] impl AgentTurnExecutionPort for TeamConversationAdapters { async fn run_agent_turn(&self, request: AgentTurnRequest) -> Result { @@ -183,8 +205,14 @@ impl TeamConversationProvisioningPort for TeamConversationAdapters { locale: None, conversation_overrides: None, }), - source: None, - channel_chat_id: None, + source: request.source, + channel_chat_id: request.channel_chat_id, + source_channel: request.source_channel, + source_channel_id: request.source_channel_id, + source_chat_id: request.source_chat_id, + source_user_id: request.source_user_id, + source_label: request.source_label, + created_from: request.created_from, extra: request.extra, }, ) @@ -216,6 +244,52 @@ impl TeamConversationProvisioningPort for TeamConversationAdapters { .map(str::to_owned)) } + async fn conversation_source_metadata( + &self, + conversation_id: &str, + ) -> Result, TeamError> { + let Some(row) = self.conversation_repo.get(conversation_id).await? else { + return Ok(None); + }; + let extra: serde_json::Value = serde_json::from_str(&row.extra).unwrap_or(serde_json::Value::Null); + let mut metadata = TeamSourceMetadata { + source_channel: row + .source_channel + .clone() + .or_else(|| json_string(&extra, "source_channel")) + .or_else(|| { + row.source + .clone() + .map(|source| if source == "aionui" { "webui".into() } else { source }) + }), + source_channel_id: row + .source_channel_id + .clone() + .or_else(|| json_string(&extra, "source_channel_id")), + source_chat_id: row + .source_chat_id + .clone() + .or_else(|| json_string(&extra, "source_chat_id")) + .or_else(|| row.channel_chat_id.clone()), + source_user_id: row + .source_user_id + .clone() + .or_else(|| json_string(&extra, "source_user_id")), + source_label: row.source_label.clone().or_else(|| json_string(&extra, "source_label")), + created_from: row.created_from.clone().or_else(|| json_string(&extra, "created_from")), + }; + if metadata.source_label.is_none() { + metadata.source_label = metadata.source_channel.as_deref().map(source_label).map(str::to_owned); + } + if metadata.created_from.is_none() { + metadata.created_from = metadata.source_channel.clone(); + } + if metadata.source_channel.is_none() { + return Ok(None); + } + Ok(Some(metadata)) + } + async fn conversation_assistant_id(&self, conversation_id: &str) -> Result, TeamError> { if let Some(snapshot) = self.conversation_repo.get_assistant_snapshot(conversation_id).await? { let assistant_id = snapshot.assistant_id.trim(); diff --git a/crates/aionui-app/tests/acp_e2e.rs b/crates/aionui-app/tests/acp_e2e.rs index dc0f1ec94..7be31af93 100644 --- a/crates/aionui-app/tests/acp_e2e.rs +++ b/crates/aionui-app/tests/acp_e2e.rs @@ -165,6 +165,7 @@ async fn management_list_marks_rows_with_unavailable_snapshot() { last_check_at: Some(1_750_000_000_000), last_success_at: None, last_failure_at: Some(1_750_000_000_000), + dynamic_probe_result: None, }, ) .await @@ -185,13 +186,17 @@ async fn management_list_marks_rows_with_unavailable_snapshot() { } #[tokio::test] -async fn legacy_agents_endpoint_is_not_found() { +async fn agents_endpoint_returns_visible_agents_for_frontend_bridge() { let (mut app, services) = build_app().await; let (token, _csrf) = setup_and_login(&mut app, &services, "user1", "pass123").await; let req = get_with_token("/api/agents", &token); let resp = app.oneshot(req).await.unwrap(); - assert_eq!(resp.status(), StatusCode::NOT_FOUND); + assert_eq!(resp.status(), StatusCode::OK); + + let body = body_json(resp).await; + let rows = body["data"].as_array().expect("data should be an array"); + assert!(rows.iter().all(|item| item["id"].is_string())); } #[tokio::test] diff --git a/crates/aionui-app/tests/active_lease_e2e.rs b/crates/aionui-app/tests/active_lease_e2e.rs index d789a7ab3..419e132b1 100644 --- a/crates/aionui-app/tests/active_lease_e2e.rs +++ b/crates/aionui-app/tests/active_lease_e2e.rs @@ -86,6 +86,12 @@ async fn insert_team(services: &aionui_app::AppServices, user_id: &str, team_id: lead_agent_id: agents.first().map(|agent| agent.slot_id.clone()), session_mode: None, agents_version: "1.0.1".to_owned(), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, created_at: now_ms(), updated_at: now_ms(), }) diff --git a/crates/aionui-app/tests/assistants_e2e.rs b/crates/aionui-app/tests/assistants_e2e.rs index ecdd20c47..75f2ed294 100644 --- a/crates/aionui-app/tests/assistants_e2e.rs +++ b/crates/aionui-app/tests/assistants_e2e.rs @@ -96,10 +96,13 @@ fn test_agent_row(id: &str, backend: Option<&str>, agent_type: AgentType, name: ..Default::default() }, yolo_id: None, + agent_capabilities: None, + auth_methods: None, config_options: None, available_modes: None, available_models: None, available_commands: None, + dynamic_probe: None, sort_order: 0, team_capable: true, status: AgentManagementStatus::Online, diff --git a/crates/aionui-app/tests/channel_e2e.rs b/crates/aionui-app/tests/channel_e2e.rs index f157ab5a0..a887c1729 100644 --- a/crates/aionui-app/tests/channel_e2e.rs +++ b/crates/aionui-app/tests/channel_e2e.rs @@ -433,6 +433,11 @@ async fn put_channel_assistant_setting_clears_active_sessions() { conversation_id: None, workspace: None, chat_id: Some("chat-channel-assistant".to_owned()), + message_thread_id: None, + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, created_at: now, last_activity: now, }; @@ -482,6 +487,11 @@ async fn put_channel_default_model_setting_clears_active_sessions() { conversation_id: None, workspace: None, chat_id: Some("chat-channel-model".to_owned()), + message_thread_id: None, + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, created_at: now, last_activity: now, }; diff --git a/crates/aionui-app/tests/development_e2e.rs b/crates/aionui-app/tests/development_e2e.rs new file mode 100644 index 000000000..4c1cc4fd3 --- /dev/null +++ b/crates/aionui-app/tests/development_e2e.rs @@ -0,0 +1,342 @@ +mod common; + +use axum::body::Body; +use axum::http::{Request, StatusCode}; +use serde_json::json; +use tower::ServiceExt; + +use common::{body_json, build_app, get_with_token, json_with_token, setup_and_login}; + +#[tokio::test] +async fn development_routes_require_authentication() { + let (app, _services) = build_app().await; + let request = Request::builder() + .uri("/api/development-runs") + .body(Body::empty()) + .unwrap(); + let response = app.oneshot(request).await.unwrap(); + assert!(matches!( + response.status(), + StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN + )); + + let (app, _services) = build_app().await; + let response = app + .oneshot( + Request::builder() + .uri("/api/development-projects/project/operations") + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert!(matches!( + response.status(), + StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN + )); +} + +#[tokio::test] +async fn delivery_state_changes_require_csrf_and_reads_require_authentication() { + let (mut app, services) = build_app().await; + let (token, _csrf) = setup_and_login(&mut app, &services, "delivery-admin", "StrongP@ss1").await; + let state_changes = [ + ("/api/development-runs/run-id/delivery/tags", json!({})), + ("/api/development-runs/run-id/deployments", json!({})), + ( + "/api/development-runs/run-id/deployments/deployment-id/approve", + json!({"confirmed": true, "confirmation_count": 2}), + ), + ( + "/api/development-runs/run-id/deployments/deployment-id/execute", + json!({}), + ), + ( + "/api/development-runs/run-id/deployments/deployment-id/cancel", + json!({"confirmed": true}), + ), + ( + "/api/development-runs/run-id/deployments/recover", + json!({"stale_after_ms": 1000}), + ), + ]; + for (path, body) in state_changes { + let response = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri(path) + .header("content-type", "application/json") + .header("authorization", format!("Bearer {token}")) + .body(Body::from(body.to_string())) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::FORBIDDEN, "{path} must require CSRF"); + } + + for path in [ + "/api/development-runs/run-id/delivery/tags", + "/api/development-runs/run-id/deployments", + ] { + let response = app + .clone() + .oneshot(Request::builder().uri(path).body(Body::empty()).unwrap()) + .await + .unwrap(); + assert!( + matches!(response.status(), StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN), + "{path} must require authentication" + ); + } +} + +#[tokio::test] +async fn authenticated_user_can_create_an_evidence_backed_development_board() { + let project = tempfile::tempdir().unwrap(); + let (mut app, services) = build_app().await; + let (token, csrf) = setup_and_login(&mut app, &services, "development-admin", "StrongP@ss1").await; + let response = app + .clone() + .oneshot(json_with_token( + "POST", + "/api/projects", + json!({ + "name": "Aion", + "local_path": project.path(), + "project_type": "single" + }), + &token, + &csrf, + )) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::CREATED); + let project_id = body_json(response).await["data"]["id"].as_str().unwrap().to_owned(); + + let response = app + .clone() + .oneshot( + Request::builder() + .method("PUT") + .uri(format!("/api/development-projects/{project_id}/operations/policy")) + .header("content-type", "application/json") + .header("authorization", format!("Bearer {token}")) + .body(Body::from( + json!({ + "isolation_mode": "host", + "container_cpu_millis": 1000, + "container_memory_mb": 2048, + "container_pids_limit": 256, + "network_mode": "none", + "allowed_secret_keys": [], + "max_duration_ms": 14400000, + "max_parallel_agents": 4, + "max_retries": 3, + "max_cost_microunits": 0, + "alert_percent": 80, + "over_limit_action": "pause" + }) + .to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::FORBIDDEN); + + let response = app + .clone() + .oneshot(json_with_token( + "PUT", + &format!("/api/development-projects/{project_id}/operations/policy"), + json!({ + "isolation_mode": "host", + "container_cpu_millis": 1000, + "container_memory_mb": 2048, + "container_pids_limit": 256, + "network_mode": "none", + "allowed_secret_keys": [], + "max_duration_ms": 14400000, + "max_parallel_agents": 4, + "max_retries": 3, + "max_cost_microunits": 0, + "alert_percent": 80, + "over_limit_action": "pause" + }), + &token, + &csrf, + )) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::OK); + + let secret_path = format!("/api/development-projects/{project_id}/secrets"); + let without_csrf = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri(&secret_path) + .header("content-type", "application/json") + .header("authorization", format!("Bearer {token}")) + .body(Body::from( + json!({"name": "CI token", "value": "ghp_e2e_never_return", "expires_at": null}).to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(without_csrf.status(), StatusCode::FORBIDDEN); + + let created = app + .clone() + .oneshot(json_with_token( + "POST", + &secret_path, + json!({"name": "CI token", "value": "ghp_e2e_never_return", "expires_at": null}), + &token, + &csrf, + )) + .await + .unwrap(); + assert_eq!(created.status(), StatusCode::CREATED); + let created = body_json(created).await; + assert!(!created.to_string().contains("ghp_e2e_never_return")); + + let (other_token, _other_csrf) = setup_and_login(&mut app, &services, "development-other", "StrongP@ss2").await; + let isolated = app + .clone() + .oneshot(get_with_token(&secret_path, &other_token)) + .await + .unwrap(); + assert_eq!(isolated.status(), StatusCode::NOT_FOUND); + + let response = app + .clone() + .oneshot(json_with_token( + "POST", + "/api/development-runs", + json!({ + "project_id": project_id, + "execution_mode": "single", + "request_summary": "Implement quality gates", + "acceptance_criteria": ["unit tests pass"] + }), + &token, + &csrf, + )) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::CREATED); + let run_id = body_json(response).await["data"]["id"].as_str().unwrap().to_owned(); + + let response = app + .clone() + .oneshot( + Request::builder() + .uri(format!("/api/development-runs/{run_id}/requirements")) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert!(matches!( + response.status(), + StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN + )); + + let response = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri(format!("/api/development-runs/{run_id}/plans")) + .header("content-type", "application/json") + .header("authorization", format!("Bearer {token}")) + .body(Body::from( + json!({"summary": "Plan", "content": "Implement"}).to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::FORBIDDEN); + + let (other_token, _other_csrf) = setup_and_login(&mut app, &services, "other-developer", "StrongP@ss2").await; + let response = app + .clone() + .oneshot( + Request::builder() + .uri(format!("/api/development-runs/{run_id}/requirements")) + .header("authorization", format!("Bearer {other_token}")) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::NOT_FOUND); + + let response = app + .clone() + .oneshot( + Request::builder() + .uri(format!("/api/development-runs/{run_id}/requirements")) + .header("authorization", format!("Bearer {token}")) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::OK); + let requirements = body_json(response).await; + assert_eq!(requirements["data"]["original_requirement"], "Implement quality gates"); + assert_eq!(requirements["data"]["active_criteria"].as_array().unwrap().len(), 1); + + let response = app + .clone() + .oneshot(json_with_token( + "POST", + &format!("/api/development-runs/{run_id}/plans"), + json!({"summary": "Plan", "content": "Implement and verify"}), + &token, + &csrf, + )) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::CREATED); + + let response = app + .clone() + .oneshot(json_with_token( + "POST", + &format!("/api/development-runs/{run_id}/tasks"), + json!({ + "subject": "Implement executor", + "acceptance_criteria": ["unit tests pass"], + "risk_level": "high", + "task_type": "implementation", + "blocked_by": [] + }), + &token, + &csrf, + )) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::CREATED); + + let response = app + .oneshot( + Request::builder() + .uri(format!("/api/development-runs/{run_id}/tasks")) + .header("authorization", format!("Bearer {token}")) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::OK); + assert_eq!(body_json(response).await["data"].as_array().unwrap().len(), 1); +} diff --git a/crates/aionui-app/tests/project_e2e.rs b/crates/aionui-app/tests/project_e2e.rs new file mode 100644 index 000000000..73b4b246c --- /dev/null +++ b/crates/aionui-app/tests/project_e2e.rs @@ -0,0 +1,104 @@ +mod common; + +use axum::body::Body; +use axum::http::{Request, StatusCode}; +use serde_json::json; +use tower::ServiceExt; + +use common::{body_json, build_app, json_with_token, setup_and_login}; + +#[tokio::test] +async fn project_routes_require_authentication() { + let (app, _services) = build_app().await; + let request = Request::builder().uri("/api/projects").body(Body::empty()).unwrap(); + + let response = app.oneshot(request).await.unwrap(); + assert!(matches!( + response.status(), + StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN + )); +} + +#[tokio::test] +async fn authenticated_user_can_register_and_list_a_project() { + let temp = tempfile::tempdir().unwrap(); + let (mut app, services) = build_app().await; + let (token, csrf) = setup_and_login(&mut app, &services, "project-admin", "StrongP@ss1").await; + + let create = json_with_token( + "POST", + "/api/projects", + json!({ + "name": "Aion", + "local_path": temp.path(), + "project_type": "single" + }), + &token, + &csrf, + ); + let response = app.clone().oneshot(create).await.unwrap(); + assert_eq!(response.status(), StatusCode::CREATED); + let created = body_json(response).await; + assert_eq!(created["data"]["name"], "Aion"); + + let list = Request::builder() + .uri("/api/projects") + .header("authorization", format!("Bearer {token}")) + .body(Body::empty()) + .unwrap(); + let response = app.oneshot(list).await.unwrap(); + assert_eq!(response.status(), StatusCode::OK); + assert_eq!(body_json(response).await["data"].as_array().unwrap().len(), 1); +} + +#[tokio::test] +async fn project_create_requires_csrf_for_authenticated_web_mode() { + let temp = tempfile::tempdir().unwrap(); + let (mut app, services) = build_app().await; + let (token, _csrf) = setup_and_login(&mut app, &services, "project-csrf", "StrongP@ss1").await; + let request = Request::builder() + .method("POST") + .uri("/api/projects") + .header("authorization", format!("Bearer {token}")) + .header("content-type", "application/json") + .body(Body::from( + json!({ + "name": "Blocked", + "local_path": temp.path(), + "project_type": "unknown" + }) + .to_string(), + )) + .unwrap(); + + assert_eq!(app.oneshot(request).await.unwrap().status(), StatusCode::FORBIDDEN); +} + +#[tokio::test] +async fn project_knowledge_refresh_requires_csrf_for_authenticated_web_mode() { + let temp = tempfile::tempdir().unwrap(); + git2::Repository::init(temp.path()).unwrap(); + let (mut app, services) = build_app().await; + let (token, csrf) = setup_and_login(&mut app, &services, "project-knowledge-csrf", "StrongP@ss1").await; + let create = json_with_token( + "POST", + "/api/projects", + json!({ + "name": "Knowledge", + "local_path": temp.path(), + "project_type": "single" + }), + &token, + &csrf, + ); + let created = body_json(app.clone().oneshot(create).await.unwrap()).await; + let project_id = created["data"]["id"].as_str().unwrap(); + let request = Request::builder() + .method("POST") + .uri(format!("/api/projects/{project_id}/knowledge/refresh")) + .header("authorization", format!("Bearer {token}")) + .body(Body::empty()) + .unwrap(); + + assert_eq!(app.oneshot(request).await.unwrap().status(), StatusCode::FORBIDDEN); +} diff --git a/crates/aionui-app/tests/team_e2e.rs b/crates/aionui-app/tests/team_e2e.rs index 423e87eda..d7dae9911 100644 --- a/crates/aionui-app/tests/team_e2e.rs +++ b/crates/aionui-app/tests/team_e2e.rs @@ -1,5 +1,10 @@ mod common; +use std::path::Path; +use std::process::Command; + +use aionui_api_types::{AgentDynamicProbeResult, AgentProbeStatus, AgentProbeStep, AgentProbeStepResult}; +use aionui_app::AppServices; use aionui_db::{IConversationRepository, MessagePageDirection, MessagePageParams}; use axum::http::StatusCode; use serde_json::{Value, json}; @@ -9,13 +14,85 @@ use tower::ServiceExt; use aionui_api_types::TeamMcpStdioConfig; use aionui_team::mcp::protocol::{read_frame, write_frame}; use common::{ - body_json, build_app, build_app_with_mock_agents, delete_with_token, get_request, get_with_token, json_with_token, - setup_and_login, + body_json, build_app as build_base_app, build_app_with_mock_agents as build_base_app_with_mock_agents, + delete_with_token, get_request, get_with_token, json_with_token, setup_and_login, }; const DEFAULT_TEAM_ASSISTANT_ID: &str = "team-e2e-assistant"; const DEFAULT_TEAM_AGENT_ID: &str = "2d23ff1c"; +async fn seed_healthy_team_agent(services: &AppServices) { + let checked_at = aionui_common::now_ms(); + let probe = serde_json::to_string(&AgentDynamicProbeResult { + agent_id: DEFAULT_TEAM_AGENT_ID.into(), + checked_at, + available_models: vec!["claude".into()], + steps: [ + AgentProbeStep::Spawn, + AgentProbeStep::Initialize, + AgentProbeStep::Models, + AgentProbeStep::MinimalPrompt, + AgentProbeStep::Cancel, + ] + .into_iter() + .map(|step| AgentProbeStepResult { + step, + status: AgentProbeStatus::Passed, + started_at: checked_at, + duration_ms: 1, + error_category: None, + error_message: None, + }) + .collect(), + }) + .unwrap(); + let result = sqlx::query( + "UPDATE agent_metadata SET last_check_status='online', last_check_kind='test', \ + last_check_at=?, last_success_at=?, last_failure_at=NULL, dynamic_probe_result=?, updated_at=? \ + WHERE id=?", + ) + .bind(checked_at) + .bind(checked_at) + .bind(probe) + .bind(checked_at) + .bind(DEFAULT_TEAM_AGENT_ID) + .execute(services.database.pool()) + .await + .unwrap(); + assert_eq!(result.rows_affected(), 1, "team test Agent metadata must exist"); +} + +async fn build_app() -> (axum::Router, AppServices) { + let (app, services) = build_base_app().await; + seed_healthy_team_agent(&services).await; + (app, services) +} + +async fn build_app_with_mock_agents() -> (axum::Router, AppServices) { + let (app, services) = build_base_app_with_mock_agents().await; + seed_healthy_team_agent(&services).await; + (app, services) +} + +fn git(repo: &Path, args: &[&str]) { + let output = Command::new("git").arg("-C").arg(repo).args(args).output().unwrap(); + assert!( + output.status.success(), + "git {:?} failed: {}", + args, + String::from_utf8_lossy(&output.stderr) + ); +} + +fn init_git_repo(root: &Path) { + git(root, &["init", "-b", "main"]); + git(root, &["config", "user.email", "aion@example.test"]); + git(root, &["config", "user.name", "Aion Test"]); + std::fs::write(root.join("README.md"), "baseline\n").unwrap(); + git(root, &["add", "README.md"]); + git(root, &["commit", "-m", "baseline"]); +} + fn team_agent(name: &str, role: &str) -> serde_json::Value { json!({ "name": name, @@ -418,6 +495,54 @@ async fn tc6c_create_team_rejects_missing_workspace_path() { ); } +#[tokio::test] +async fn tc6d_isolated_worktree_request_returns_persisted_lease_status() { + let (mut app, services) = build_app().await; + let (token, csrf) = setup_and_login(&mut app, &services, "admin", "StrongP@ss1").await; + ensure_default_team_assistant(&mut app, &services, &token, &csrf).await; + let repository = tempfile::tempdir().unwrap(); + init_git_repo(repository.path()); + + let req = json_with_token( + "POST", + "/api/teams", + json!({ + "name": "Isolated", + "workspace": repository.path().to_string_lossy(), + "workspace_mode": "isolated_worktree", + "agents": [team_agent("Lead", "lead"), team_agent("Worker", "teammate")] + }), + &token, + &csrf, + ); + let resp = app.clone().oneshot(req).await.unwrap(); + let status = resp.status(); + let json = body_json(resp).await; + assert_eq!(status, StatusCode::CREATED, "response: {json}"); + let team = &json["data"]; + assert_eq!(team["workspace_mode"], "isolated_worktree"); + assert_eq!(team["workspace_leases"].as_array().unwrap().len(), 3); + assert!( + team["workspace_leases"] + .as_array() + .unwrap() + .iter() + .all(|lease| lease["lease_status"] == "active") + ); + assert_ne!( + team["workspace_leases"][1]["worktree_path"], + team["workspace_leases"][2]["worktree_path"] + ); + + let team_id = team["id"].as_str().unwrap(); + let req = get_with_token(&format!("/api/teams/{team_id}"), &token); + let resp = app.oneshot(req).await.unwrap(); + assert_eq!(resp.status(), StatusCode::OK); + let json = body_json(resp).await; + assert_eq!(json["data"]["workspace_mode"], "isolated_worktree"); + assert_eq!(json["data"]["workspace_leases"].as_array().unwrap().len(), 3); +} + // TC-7: Unauthenticated returns 401 #[tokio::test] async fn tc7_unauthenticated_returns_401() { @@ -621,7 +746,7 @@ async fn trs2_run_state_returns_active_run_payload() { assert!(body["data"]["active_run"]["starting_batch_count"].is_number()); assert!(body["data"]["active_run"]["running_batch_count"].is_number()); assert!(body["data"]["active_run"]["active_enqueue_lease_count"].is_number()); - assert!(body["data"]["active_run"]["slot_work"].as_array().unwrap().len() >= 1); + assert!(!body["data"]["active_run"]["slot_work"].as_array().unwrap().is_empty()); } #[tokio::test] diff --git a/crates/aionui-app/tests/work_dir_e2e.rs b/crates/aionui-app/tests/work_dir_e2e.rs index 2434aa5af..35c1ea813 100644 --- a/crates/aionui-app/tests/work_dir_e2e.rs +++ b/crates/aionui-app/tests/work_dir_e2e.rs @@ -26,6 +26,12 @@ async fn conversation_workspace_uses_work_dir() { assistant: None, source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::json!({}), }; let response = state.service.create("system_default_user", request).await.unwrap(); @@ -64,6 +70,12 @@ async fn user_specified_workspace_is_not_overridden() { assistant: None, source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::json!({ "workspace": custom_workspace.path().to_str().unwrap() }), @@ -98,6 +110,12 @@ async fn workspace_defaults_to_data_dir_when_work_dir_equals_data_dir() { assistant: None, source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::json!({}), }; let response = state.service.create("system_default_user", request).await.unwrap(); diff --git a/crates/aionui-assistant/src/service.rs b/crates/aionui-assistant/src/service.rs index ff1794af8..823c542d3 100644 --- a/crates/aionui-assistant/src/service.rs +++ b/crates/aionui-assistant/src/service.rs @@ -3378,10 +3378,13 @@ mod tests { ..Default::default() }, yolo_id: None, + agent_capabilities: None, + auth_methods: None, config_options: None, available_modes: None, available_models: None, available_commands: None, + dynamic_probe: None, sort_order: 3100, team_capable: true, status, diff --git a/crates/aionui-channel/Cargo.toml b/crates/aionui-channel/Cargo.toml index a0de2d46d..c2f85207a 100644 --- a/crates/aionui-channel/Cargo.toml +++ b/crates/aionui-channel/Cargo.toml @@ -22,6 +22,7 @@ axum.workspace = true tokio.workspace = true serde.workspace = true serde_json.workspace = true +sha2.workspace = true thiserror.workspace = true async-trait.workspace = true tracing.workspace = true diff --git a/crates/aionui-channel/src/action.rs b/crates/aionui-channel/src/action.rs index 0d9d54c0c..93260c568 100644 --- a/crates/aionui-channel/src/action.rs +++ b/crates/aionui-channel/src/action.rs @@ -1,13 +1,18 @@ -use std::sync::Arc; +use std::collections::HashMap; +use std::sync::{Arc, Mutex}; +use aionui_api_types::{ChannelAssistantSettingRequest, ChannelDefaultModelSetting}; use tracing::{debug, info, warn}; -use crate::channel_settings::ChannelSettingsService; +use crate::approval::{ChannelApprovalPort, ChannelApprovalResolutionContext}; +use crate::channel_settings::{ChannelAgentOption, ChannelSettingsService}; +use crate::development::{ChannelDevelopmentCommand, ChannelDevelopmentContext, ChannelDevelopmentPort}; use crate::error::ChannelError; use crate::pairing::PairingService; use crate::session::SessionManager; use crate::types::{ - ActionBehavior, ActionButton, ActionCategory, ActionResponse, UnifiedAction, UnifiedIncomingMessage, + ActionBehavior, ActionButton, ActionCategory, ActionResponse, ChannelConversationTitleHint, MessageContentType, + ParseMode, UnifiedAction, UnifiedIncomingMessage, }; /// Result of processing an incoming message. @@ -23,12 +28,82 @@ pub enum MessageResult { Dispatched { session_id: String, conversation_id: Option, + title_hint: Option, }, /// Message was a text but user already has an active agent stream /// (no duplicate dispatch needed). AlreadyProcessing, } +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChannelTeamSummary { + pub id: String, + pub name: String, + pub lead_conversation_id: Option, + pub agent_count: usize, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChannelTeamCreateRequest { + pub name: String, + pub lead_name: String, + pub lead_role: String, + pub assistant_id: String, + pub model: String, + pub source_channel: Option, + pub source_channel_id: Option, + pub source_chat_id: Option, + pub source_user_id: Option, + pub source_label: Option, + pub created_from: Option, +} + +#[async_trait::async_trait] +pub trait ChannelTeamDirectory: Send + Sync { + async fn list_teams(&self, user_id: &str) -> Result, ChannelError>; + async fn get_team(&self, user_id: &str, team_id: &str) -> Result, ChannelError>; + async fn ensure_team_session(&self, user_id: &str, team_id: &str) -> Result<(), ChannelError>; + async fn create_team( + &self, + user_id: &str, + request: ChannelTeamCreateRequest, + ) -> Result; +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChannelPersonalConversationSummary { + pub id: String, + pub name: String, + pub agent_type: String, + pub agent_label: Option, + pub recent_message: Option, +} + +#[async_trait::async_trait] +pub trait ChannelPersonalDirectory: Send + Sync { + async fn list_personal_conversations( + &self, + user_id: &str, + platform: crate::types::PluginType, + chat_id: &str, + ) -> Result, ChannelError>; + async fn get_personal_conversation( + &self, + user_id: &str, + platform: crate::types::PluginType, + chat_id: &str, + conversation_id: &str, + ) -> Result, ChannelError>; + async fn rename_personal_conversation( + &self, + user_id: &str, + platform: crate::types::PluginType, + chat_id: &str, + conversation_id: &str, + title: &str, + ) -> Result, ChannelError>; +} + /// Processes incoming IM messages: authorization → action routing → AI dispatch. /// /// This is the core message entry point for the channel system. Each @@ -40,6 +115,18 @@ pub struct ActionExecutor { pairing: Arc, session_mgr: Arc, settings: Arc, + team_directory: Option>, + personal_directory: Option>, + approval_port: Option>, + development_port: Option>, + pending_flows: Arc>>, + personal_title_hints: Arc>>, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +enum PendingFlow { + TeamNewAwaitingName, + TeamNewConfirm { topic: String }, } impl ActionExecutor { @@ -52,9 +139,35 @@ impl ActionExecutor { pairing, session_mgr, settings, + team_directory: None, + personal_directory: None, + approval_port: None, + development_port: None, + pending_flows: Arc::new(Mutex::new(HashMap::new())), + personal_title_hints: Arc::new(Mutex::new(HashMap::new())), } } + pub fn with_team_directory(mut self, team_directory: Arc) -> Self { + self.team_directory = Some(team_directory); + self + } + + pub fn with_personal_directory(mut self, personal_directory: Arc) -> Self { + self.personal_directory = Some(personal_directory); + self + } + + pub fn with_approval_port(mut self, approval_port: Arc) -> Self { + self.approval_port = Some(approval_port); + self + } + + pub fn with_development_port(mut self, development_port: Arc) -> Self { + self.development_port = Some(development_port); + self + } + /// Main entry point: handle an incoming message from any platform. /// /// Flow: @@ -81,16 +194,67 @@ impl ActionExecutor { // 2. Button callback → action routing if let Some(action) = &msg.action { - let response = self.route_action(action, &internal_user_id).await?; + let response = self.route_action(action, &internal_user_id, msg).await?; + return Ok(MessageResult::Action(response)); + } + + if msg.content.content_type == MessageContentType::Command || msg.content.text.trim_start().starts_with('/') { + let response = self.handle_command(&msg.content.text, &internal_user_id, msg).await?; + return Ok(MessageResult::Action(response)); + } + + if msg.content.content_type == MessageContentType::Text + && let Some(response) = self.handle_pending_text(&internal_user_id, msg).await? + { return Ok(MessageResult::Action(response)); } // 3. Text message → session resolution → AI dispatch - let agent_config = self.settings.get_agent_config(msg.platform).await?; - let session = self - .session_mgr - .get_or_create_session(&internal_user_id, chat_id, &agent_config.agent_type, None) - .await?; + let session = if msg.platform == crate::types::PluginType::Telegram + && let Some(topic) = &msg.topic + && topic.message_thread_id != 1 + { + let Some(binding) = self + .session_mgr + .get_topic_binding(chat_id, topic.message_thread_id) + .await? + else { + return Ok(MessageResult::Action(html_response( + "此话题尚未绑定 Agent。请群管理员在本话题执行 /topic_bind <agent-id>。", + None, + ))); + }; + let option = self + .settings + .list_agent_options() + .await? + .into_iter() + .find(|option| option.agent_id == binding.agent_id) + .ok_or_else(|| { + ChannelError::InvalidConfig(format!("Bound agent '{}' is unavailable", binding.agent_id)) + })?; + self.session_mgr + .get_or_create_topic_session( + &internal_user_id, + chat_id, + topic.message_thread_id, + &option.agent_type, + &option.agent_id, + option.backend.as_deref(), + None, + ) + .await? + } else { + let agent_config = self.settings.get_agent_config(msg.platform).await?; + self.session_mgr + .get_or_create_session(&internal_user_id, chat_id, &agent_config.agent_type, None) + .await? + }; + let title_hint = if session.conversation_id.is_none() { + self.take_or_build_personal_title_hint(&internal_user_id, msg) + } else { + None + }; info!( session_id = %session.id, @@ -103,6 +267,25 @@ impl ActionExecutor { Ok(MessageResult::Dispatched { session_id: session.id, conversation_id: session.conversation_id, + title_hint, + }) + } + + fn take_or_build_personal_title_hint( + &self, + internal_user_id: &str, + msg: &UnifiedIncomingMessage, + ) -> Option { + let key = pending_key(internal_user_id, msg.platform, &msg.chat_id); + if let Some(title) = self.personal_title_hints.lock().unwrap().remove(&key) { + return Some(ChannelConversationTitleHint { + title, + source: format!("{}_explicit", msg.platform), + }); + } + auto_title_from_message(&msg.content.text).map(|title| ChannelConversationTitleHint { + title, + source: format!("{}_first_message", msg.platform), }) } @@ -133,10 +316,23 @@ impl ActionExecutor { &self, action: &UnifiedAction, internal_user_id: &str, + msg: &UnifiedIncomingMessage, ) -> Result { + if msg.platform == crate::types::PluginType::Telegram + && msg.topic.as_ref().is_some_and(|topic| topic.message_thread_id != 1) + && (action.action.starts_with("agent.") + || action.action.starts_with("team.") + || action.action.starts_with("personal.") + || action.action == "model.clear") + { + return Ok(html_response( + "此话题固定绑定单 Agent，不能使用 Agent、Team 或入口切换按钮。", + None, + )); + } match action.category { ActionCategory::Platform => self.handle_platform_action(action).await, - ActionCategory::System => self.handle_system_action(action, internal_user_id).await, + ActionCategory::System => self.handle_system_action(action, internal_user_id, msg).await, ActionCategory::Chat => self.handle_chat_action(action).await, } } @@ -219,8 +415,68 @@ impl ActionExecutor { &self, action: &UnifiedAction, internal_user_id: &str, + msg: &UnifiedIncomingMessage, ) -> Result { match action.action.as_str() { + "approval.resolve" => { + let params = action + .params + .as_ref() + .ok_or_else(|| ChannelError::InvalidConfig("Missing approval callback parameters".into()))?; + let approval_id = params + .get("id") + .filter(|value| !value.trim().is_empty()) + .ok_or_else(|| ChannelError::InvalidConfig("Missing approval ID".into()))?; + let option_index = params + .get("o") + .and_then(|value| value.parse::().ok()) + .ok_or_else(|| ChannelError::InvalidConfig("Invalid approval option".into()))?; + let approval_port = self + .approval_port + .as_ref() + .ok_or_else(|| ChannelError::InvalidConfig("Approval service is unavailable".into()))?; + let status = approval_port + .resolve( + ChannelApprovalResolutionContext { + source_user_id: internal_user_id.to_owned(), + platform: msg.platform, + chat_id: msg.chat_id.clone(), + message_thread_id: msg.topic.as_ref().map(|topic| topic.message_thread_id), + is_admin: msg + .raw + .as_ref() + .and_then(|raw| raw.get("telegram_chat_member_status")) + .and_then(serde_json::Value::as_str) + .is_some_and(|status| matches!(status, "creator" | "administrator")), + }, + approval_id, + option_index, + ) + .await?; + let rejected = status == "rejected"; + let toast = if rejected { "审批已拒绝" } else { "审批已同意" }; + let edit_message_id = action.context.message_id.clone(); + Ok(ActionResponse { + text: Some(format!( + "{}\n审批 ID：{approval_id}", + if rejected { + "❌ 审批已拒绝" + } else { + "✅ 审批已同意" + } + )), + parse_mode: None, + buttons: None, + keyboard: None, + behavior: if edit_message_id.is_some() { + ActionBehavior::Edit + } else { + ActionBehavior::Send + }, + toast: Some(toast.into()), + edit_message_id, + }) + } "session.new" => { let user_id = internal_user_id; let chat_id = &action.context.chat_id; @@ -278,11 +534,65 @@ impl ActionExecutor { }) } "help.show" => Ok(build_help_response()), + "team.select" => { + let team_id = action + .params + .as_ref() + .and_then(|params| params.get("id")) + .map(String::as_str) + .unwrap_or_default(); + self.select_team_by_selector( + internal_user_id, + action.context.platform, + &action.context.chat_id, + team_id, + ) + .await + } + "team.list" => self.build_team_list_command(internal_user_id).await, + "team.new.start" => self.create_team_command(internal_user_id, msg, "").await, + "team.help" => Ok(build_team_help_response()), + "team.new.create" => { + let key = pending_key(internal_user_id, action.context.platform, &action.context.chat_id); + let topic = { + let mut pending = self.pending_flows.lock().unwrap(); + match pending.remove(&key) { + Some(PendingFlow::TeamNewConfirm { topic }) => Some(topic), + _ => None, + } + }; + let Some(topic) = topic else { + return Ok(html_response( + "没有待确认的 Team 创建草稿。\n\n发送 /team_new 重新开始。", + None, + )); + }; + self.create_team_from_topic( + internal_user_id, + action.context.platform, + &action.context.chat_id, + &action.context.user_id, + &topic, + ) + .await + } + "team.new.confirm" => Ok(html_response("旧的草稿确认按钮已下线。发送 /team_new 重新开始。", None)), + "team.new.cancel" => { + let key = pending_key(internal_user_id, action.context.platform, &action.context.chat_id); + self.pending_flows.lock().unwrap().remove(&key); + Ok(html_response("已取消 Telegram Team 创建流程。", None)) + } + "agent.list" => self.build_agent_picker_command(action.context.platform).await, + "agent.select" => self.select_agent_action(internal_user_id, action).await, + "model.select" => self.select_model_action(internal_user_id, action, msg).await, + "model.clear" => self.clear_model_action(internal_user_id, action).await, + "personal.select" => self.select_personal_action(internal_user_id, action).await, + "personal.list" => self.build_personal_list_command(internal_user_id, msg).await, "help.features" => Ok(ActionResponse { text: Some( "Features:\n\ • AI chat through your configured assistant\n\ - • Tool execution with auto-approval\n\ + • Tool execution with explicit approval\n\ • Session isolation per chat" .into(), ), @@ -399,685 +709,3809 @@ impl ActionExecutor { } } } -} -// ── Helper builders ───────────────────────────────────────────────── + async fn handle_pending_text( + &self, + internal_user_id: &str, + msg: &UnifiedIncomingMessage, + ) -> Result, ChannelError> { + let key = pending_key(internal_user_id, msg.platform, &msg.chat_id); + let flow = self.pending_flows.lock().unwrap().get(&key).cloned(); + let Some(flow) = flow else { + return Ok(None); + }; -fn build_pairing_response(code: &str) -> ActionResponse { - ActionResponse { - text: Some(format!( - "Welcome! To use this bot, you need authorization.\n\n\ - Your pairing code: *{code}*\n\n\ - Share this code with the admin, who can approve it in \ - Settings → Channel → Pairing Requests.\n\ - The code expires in 10 minutes." - )), - parse_mode: None, - buttons: Some(vec![vec![ - ActionButton { - label: "Refresh Code".into(), - action: "pairing.refresh".into(), - params: None, - }, - ActionButton { - label: "Check Status".into(), - action: "pairing.check".into(), - params: None, - }, - ActionButton { - label: "Help".into(), - action: "pairing.help".into(), - params: None, - }, - ]]), - keyboard: None, - behavior: ActionBehavior::Send, - toast: None, - edit_message_id: None, - } -} + match flow { + PendingFlow::TeamNewAwaitingName | PendingFlow::TeamNewConfirm { .. } => { + let topic = msg.content.text.trim(); + if topic.is_empty() { + return Ok(Some(html_response( + "团队名称不能为空。请直接回复团队名称，或点击取消。", + Some(vec![vec![ActionButton { + label: "取消".into(), + action: "team.new.cancel".into(), + params: None, + }]]), + ))); + } -fn build_help_response() -> ActionResponse { - ActionResponse { - text: Some( - "How can I help?\n\ - Choose an option below or just send me a message." - .into(), - ), - parse_mode: None, - buttons: Some(vec![ - vec![ - ActionButton { - label: "New Session".into(), - action: "session.new".into(), - params: None, - }, - ActionButton { - label: "Session Status".into(), - action: "session.status".into(), - params: None, - }, - ], - vec![ - ActionButton { - label: "Features".into(), - action: "help.features".into(), - params: None, - }, - ActionButton { - label: "Tips".into(), - action: "help.tips".into(), - params: None, - }, - ], - ]), - keyboard: None, - behavior: ActionBehavior::Send, - toast: None, - edit_message_id: None, - } -} + self.pending_flows.lock().unwrap().insert( + key, + PendingFlow::TeamNewConfirm { + topic: topic.to_owned(), + }, + ); -fn build_unknown_action_response(action: &str) -> ActionResponse { - ActionResponse { - text: Some(format!("Unknown action: {action}")), - parse_mode: None, - buttons: None, - keyboard: None, - behavior: ActionBehavior::Send, - toast: None, - edit_message_id: None, + Ok(Some(html_response( + &format!( + "准备创建 Team\nTeam: {}\n\n确认后会创建真实 Team，并把当前 Telegram 聊天切换到 Team Lead。", + html_escape(topic) + ), + Some(vec![vec![ + ActionButton { + label: "创建 Team".into(), + action: "team.new.create".into(), + params: None, + }, + ActionButton { + label: "取消".into(), + action: "team.new.cancel".into(), + params: None, + }, + ]]), + ))) + } + } } -} -#[cfg(test)] -mod tests { - use super::*; - use crate::types::{ActionContext, MessageContentType, PluginType, UnifiedMessageContent, UnifiedUser}; - use aionui_api_types::WebSocketMessage; - use aionui_common::{TimestampMs, now_ms}; - use aionui_db::models::{ - AssistantSessionRow, AssistantUserRow, ChannelPluginRow, ClientPreference, PairingCodeRow, - }; - use aionui_db::{DbError, IChannelRepository, IClientPreferenceRepository, UpdatePluginStatusParams}; - use aionui_realtime::EventBroadcaster; - use std::collections::HashMap; - use std::sync::Mutex; + async fn handle_command( + &self, + raw: &str, + internal_user_id: &str, + msg: &UnifiedIncomingMessage, + ) -> Result { + let trimmed = raw.trim(); + let without_slash = trimmed.trim_start_matches('/'); + let mut parts = without_slash.splitn(2, char::is_whitespace); + let command = parts + .next() + .unwrap_or_default() + .split('@') + .next() + .unwrap_or_default() + .to_ascii_lowercase(); + let args = parts.next().unwrap_or_default().trim(); - // ── Mock EventBroadcaster ────────────────────────────────────────── + if msg.platform == crate::types::PluginType::Telegram + && let Some(topic) = &msg.topic + && topic.message_thread_id != 1 + { + let is_admin = msg + .raw + .as_ref() + .and_then(|raw| raw.get("telegram_chat_member_status")) + .and_then(|status| status.as_str()) + .is_some_and(|status| matches!(status, "creator" | "administrator")); + match command.as_str() { + "topic_bind" => { + if !is_admin { + return Ok(html_response("仅群管理员可以绑定话题。", None)); + } + let options = self.settings.list_agent_options().await?; + let Some(option) = options + .into_iter() + .find(|option| option.agent_id == args || option.name.eq_ignore_ascii_case(args)) + else { + return Ok(html_response( + "Agent 不存在或当前不可用。请使用系统中的准确 Agent ID。", + None, + )); + }; + self.session_mgr + .bind_topic( + &msg.chat_id, + topic.message_thread_id, + &option.agent_id, + internal_user_id, + ) + .await?; + return Ok(html_response( + &format!("已将当前话题绑定到 {}。", html_escape(&option.name)), + None, + )); + } + "topic_unbind" => { + if !is_admin { + return Ok(html_response("仅群管理员可以解绑话题。", None)); + } + self.session_mgr + .unbind_topic(&msg.chat_id, topic.message_thread_id) + .await?; + return Ok(html_response("当前话题已解绑。", None)); + } + "topic_info" => { + let binding = self + .session_mgr + .get_topic_binding(&msg.chat_id, topic.message_thread_id) + .await?; + return Ok(match binding { + Some(binding) => html_response( + &format!( + "话题绑定\nThread: {}\nAgent ID: {}", + topic.message_thread_id, + html_escape(&binding.agent_id) + ), + None, + ), + None => html_response("当前话题尚未绑定 Agent。", None), + }); + } + _ => {} + } + let binding = self + .session_mgr + .get_topic_binding(&msg.chat_id, topic.message_thread_id) + .await?; + if let Some(binding) = binding { + let option = self + .settings + .list_agent_options() + .await? + .into_iter() + .find(|option| option.agent_id == binding.agent_id) + .ok_or_else(|| { + ChannelError::InvalidConfig(format!("Bound agent '{}' is unavailable", binding.agent_id)) + })?; + if matches!(command.as_str(), "help" | "start" | "") { + return Ok(html_response( + &format!( + "单 Agent 话题\n当前 Agent：{}\n\n可用命令：\n/model — 查看并切换此 Agent 可用模型\n/status — 查看当前话题会话状态\n/new 或 /new_session — 新建当前话题会话\n/topic_info — 查看绑定信息\n/project — 当前项目\n/run_info — 当前开发运行\n/diff_summary — 变更与证据摘要\n/test — 执行配置的单元测试门禁\n/stop — 停止当前运行\n/retry — 重试最近失败门禁\n/handoff — Web 接力入口\n\n管理员命令：\n/topic_bind <agent-id>\n/topic_unbind\n\n此话题不支持 Agent 切换或 Team/集群功能。", + html_escape(&option.name), + ), + None, + )); + } + if command == "model" { + return self + .build_topic_model_command(internal_user_id, msg, &binding.agent_id, args) + .await; + } + if command == "status" { + let session = self + .session_mgr + .get_or_create_topic_session( + internal_user_id, + &msg.chat_id, + topic.message_thread_id, + &option.agent_type, + &option.agent_id, + option.backend.as_deref(), + None, + ) + .await?; + let model = match (&session.bound_provider_id, &session.bound_model) { + (Some(provider), Some(model)) => format!("{provider} / {model}"), + _ => "Agent 默认模型".to_owned(), + }; + return Ok(html_response( + &format!( + "当前话题会话\nThread: {}\nAgent: {}\nSession: {}\nModel: {}\nConversation: {}", + topic.message_thread_id, + html_escape(&option.name), + html_escape(&short_channel_id(&session.id)), + html_escape(&model), + html_escape(session.conversation_id.as_deref().unwrap_or("尚未创建")), + ), + None, + )); + } + if matches!(command.as_str(), "new" | "new_session") { + self.session_mgr + .reset_topic_session( + internal_user_id, + &msg.chat_id, + topic.message_thread_id, + &option.agent_type, + &option.agent_id, + option.backend.as_deref(), + None, + ) + .await?; + return Ok(html_response("已为你新建当前话题的单 Agent 会话。", None)); + } + if command == "agent" { + return Ok(html_response( + &format!( + "当前话题固定绑定 Agent：{}，不可在话题内切换。", + html_escape(&option.name) + ), + None, + )); + } + if command.starts_with("team") + || matches!( + command.as_str(), + "personal" | "personal_list" | "conversation_select" | "rename" + ) + { + return Ok(html_response( + "此话题已绑定单 Agent，不能使用集群或入口切换命令。", + None, + )); + } + } else if !matches!(command.as_str(), "help" | "start") { + return Ok(html_response( + "此话题尚未绑定 Agent。请群管理员执行 /topic_bind <agent-id>。", + None, + )); + } + } - struct MockBroadcaster; + match command.as_str() { + "start" | "help" => Ok(build_command_help_response()), + "status" => self.build_status_command(internal_user_id, msg).await, + "agent" => self.build_agent_command(msg).await, + "model" => self.build_model_command(internal_user_id, msg, args).await, + "personal" => { + self.reset_personal_session_command(internal_user_id, msg, false, None) + .await + } + "personal_list" | "conversation_select" => self.build_personal_list_command(internal_user_id, msg).await, + "new_session" => { + self.reset_personal_session_command(internal_user_id, msg, true, Some(args)) + .await + } + "rename" => self.rename_personal_command(internal_user_id, msg, args).await, + "team" | "team_status" => self.build_team_status_command(internal_user_id, msg).await, + "team_list" => self.build_team_list_command(internal_user_id).await, + "team_select" => self.select_team_command(internal_user_id, msg, args).await, + "team_help" => Ok(build_team_help_response()), + "team_new" => self.create_team_command(internal_user_id, msg, args).await, + "project" => { + self.execute_development_command(internal_user_id, msg, ChannelDevelopmentCommand::Project) + .await + } + "run_info" => { + self.execute_development_command(internal_user_id, msg, ChannelDevelopmentCommand::RunInfo) + .await + } + "diff_summary" => { + self.execute_development_command(internal_user_id, msg, ChannelDevelopmentCommand::DiffSummary) + .await + } + "test" => { + self.execute_development_command(internal_user_id, msg, ChannelDevelopmentCommand::Test) + .await + } + "stop" => { + self.execute_development_command(internal_user_id, msg, ChannelDevelopmentCommand::Stop) + .await + } + "retry" => { + self.execute_development_command(internal_user_id, msg, ChannelDevelopmentCommand::Retry) + .await + } + "handoff" => { + self.execute_development_command(internal_user_id, msg, ChannelDevelopmentCommand::Handoff) + .await + } + "" => Ok(build_command_help_response()), + _ => Ok(html_response("未知命令。发送 /help 查看可用命令。", None)), + } + } - impl EventBroadcaster for MockBroadcaster { - fn broadcast(&self, _event: WebSocketMessage) {} + async fn execute_development_command( + &self, + internal_user_id: &str, + msg: &UnifiedIncomingMessage, + command: ChannelDevelopmentCommand, + ) -> Result { + let port = self + .development_port + .as_ref() + .ok_or_else(|| ChannelError::InvalidConfig("Development command service is unavailable".into()))?; + let thread_id = msg.topic.as_ref().map(|topic| topic.message_thread_id); + let conversation_id = self + .session_mgr + .get_active_sessions() + .await? + .into_iter() + .find(|session| { + session.user_id == internal_user_id + && session.chat_id.as_deref() == Some(msg.chat_id.as_str()) + && session.message_thread_id == thread_id + }) + .and_then(|session| session.conversation_id); + let text = port + .execute( + ChannelDevelopmentContext { + source_user_id: internal_user_id.to_owned(), + conversation_id, + platform: msg.platform, + chat_id: msg.chat_id.clone(), + message_thread_id: thread_id, + }, + command, + ) + .await?; + Ok(html_response(&html_escape(&text), None)) } - // ── Mock IChannelRepository ──────────────────────────────────────── + async fn build_status_command( + &self, + internal_user_id: &str, + msg: &UnifiedIncomingMessage, + ) -> Result { + let agent_config = self.settings.get_agent_config(msg.platform).await?; + let session = self + .session_mgr + .get_or_create_session(internal_user_id, &msg.chat_id, &agent_config.agent_type, None) + .await?; + let conversation = session.conversation_id.as_deref().unwrap_or("尚未绑定"); + Ok(html_response( + &format!( + "当前 Telegram 绑定\nSession: {}\nAgent: {}\nConversation: {}\nChat: {}", + html_escape(&short_channel_id(&session.id)), + html_escape(&session.agent_type), + html_escape(conversation), + html_escape(&msg.chat_id), + ), + None, + )) + } - struct MockRepo { - users: Mutex>, - sessions: Mutex>, - pairings: Mutex>, + async fn build_agent_command(&self, msg: &UnifiedIncomingMessage) -> Result { + let agent_config = self.settings.get_agent_config(msg.platform).await?; + let model_config = self.settings.get_model_config(msg.platform).await?; + let model = model_config + .as_ref() + .map(|config| format!("{} / {}", config.provider_id, config.model)) + .unwrap_or_else(|| "默认模型".into()); + let agent_options = self.settings.list_agent_options().await?; + let assistant = self.settings.get_assistant_setting(msg.platform).await?; + let agent_label = resolve_current_agent_option(&agent_options, assistant.as_ref(), &agent_config) + .map(|option| option.name.as_str()) + .or_else(|| assistant.as_ref().and_then(|setting| setting.name.as_deref())) + .or_else(|| assistant.as_ref().and_then(|setting| setting.assistant_id.as_deref())) + .unwrap_or("默认 Agent"); + let buttons = Some(vec![vec![ActionButton { + label: "切换 Agent".into(), + action: "agent.list".into(), + params: None, + }]]); + Ok(html_response( + &format!( + "当前 Telegram Agent 绑定\nAgent: {}\nType: {}\nBackend: {}\nModel: {}\n\n这个绑定作用于 Telegram 渠道的新个人会话和 Team 创建。", + html_escape(agent_label), + html_escape(&agent_config.agent_type), + html_escape(agent_config.backend.as_deref().unwrap_or("默认")), + html_escape(&model), + ), + buttons, + )) } - impl MockRepo { - fn new() -> Self { - Self { - users: Mutex::new(Vec::new()), - sessions: Mutex::new(Vec::new()), - pairings: Mutex::new(Vec::new()), - } + async fn build_agent_picker_command( + &self, + platform: crate::types::PluginType, + ) -> Result { + let options = self.settings.list_agent_options().await?; + if options.is_empty() { + return Ok(html_response( + "当前没有可在 Telegram 中切换的本地 Agent。\n\n可以先在 WebUI 的 Agents 页面刷新检测本地 Agent。", + None, + )); } + let agent_config = self.settings.get_agent_config(platform).await?; + let assistant = self.settings.get_assistant_setting(platform).await?; + let current_agent_id = resolve_current_agent_option(&options, assistant.as_ref(), &agent_config) + .map(|option| option.agent_id.as_str()); - fn add_authorized_user(&self, platform_user_id: &str, platform_type: &str) { - let user = AssistantUserRow { - id: format!("user_{platform_user_id}"), - platform_user_id: platform_user_id.to_owned(), - platform_type: platform_type.to_owned(), - display_name: Some("Test User".into()), - authorized_at: now_ms(), - last_active: None, - session_id: None, - }; - self.users.lock().unwrap().push(user); + let mut text = String::from("请选择 Telegram 渠道要绑定的 Agent\n"); + let mut buttons = Vec::new(); + for option in options + .iter() + .filter(|option| Some(option.agent_id.as_str()) != current_agent_id) + .take(12) + { + text.push_str(&format!( + "\n- {} ({})", + html_escape(&option.name), + html_escape(&option.agent_type) + )); + buttons.push(vec![ActionButton { + label: short_button_label(&option.name), + action: "agent.select".into(), + params: Some(HashMap::from([("agentId".into(), option.agent_id.clone())])), + }]); } + if buttons.is_empty() { + text.push_str("\n\n当前已绑定唯一可用 Agent，没有其他可切换项。"); + } + if options.len() > 12 { + text.push_str("\n\n当前只显示前 12 个本地 Agent。更完整的管理请到 WebUI Agents 页面。"); + } + + Ok(html_response(&text, Some(buttons))) } - #[async_trait::async_trait] - impl IChannelRepository for MockRepo { - async fn get_all_plugins(&self) -> Result, DbError> { - Ok(vec![]) + async fn select_agent_action( + &self, + internal_user_id: &str, + action: &UnifiedAction, + ) -> Result { + let agent_id = action + .params + .as_ref() + .and_then(|params| params.get("agentId").or_else(|| params.get("assistantId"))) + .map(String::as_str) + .unwrap_or_default() + .trim(); + if agent_id.is_empty() { + return Ok(html_response( + "缺少 agentId，无法切换 Agent。请发送 /agent 后点击列表按钮。", + None, + )); } - async fn get_plugin(&self, _id: &str) -> Result, DbError> { - Ok(None) - } - async fn upsert_plugin(&self, _row: &ChannelPluginRow) -> Result<(), DbError> { - Ok(()) + + let options = self.settings.list_agent_options().await?; + let selected = options.iter().find(|option| option.agent_id == agent_id); + if !options.is_empty() && selected.is_none() { + return Ok(html_response( + "没有找到这个本地 Agent，可能已经被禁用或当前不可用。请发送 /agent 重新选择。", + None, + )); } - async fn update_plugin_status(&self, _id: &str, _params: &UpdatePluginStatusParams) -> Result<(), DbError> { - Ok(()) + let Some(selected) = selected else { + return Ok(html_response( + "当前没有可切换的本地 Agent。请先在 WebUI Agents 页面刷新检测。", + None, + )); + }; + + self.settings + .set_assistant_setting( + action.context.platform, + &ChannelAssistantSettingRequest { + assistant_id: selected.agent_id.clone(), + name: Some(selected.name.clone()), + }, + ) + .await?; + self.settings.clear_model_setting(action.context.platform).await?; + + let agent_config = self.settings.get_agent_config(action.context.platform).await?; + let session = self + .session_mgr + .reset_session( + internal_user_id, + &action.context.chat_id, + &agent_config.agent_type, + None, + ) + .await?; + + Ok(html_response( + &format!( + "Telegram Agent 已切换\nAgent: {}\nType: {}\nBackend: {}\nSession: {}\nModel: 已恢复 Agent 默认模型\n\n当前聊天已新建个人会话，后续消息会使用新的绑定。", + html_escape(&selected.name), + html_escape(&agent_config.agent_type), + html_escape(agent_config.backend.as_deref().unwrap_or("默认")), + html_escape(&short_channel_id(&session.id)), + ), + None, + )) + } + + async fn build_model_command( + &self, + internal_user_id: &str, + msg: &UnifiedIncomingMessage, + args: &str, + ) -> Result { + let args = args.trim(); + let model_config = self.settings.get_model_config(msg.platform).await?; + let agent_config = self.settings.get_agent_config(msg.platform).await?; + let agent_options = self.settings.list_agent_options().await?; + let assistant = self.settings.get_assistant_setting(msg.platform).await?; + let current_agent = resolve_current_agent_option(&agent_options, assistant.as_ref(), &agent_config); + let is_openclaw_agent = agent_config.backend.as_deref() == Some("openclaw") + || current_agent + .map(|agent| agent.name.eq_ignore_ascii_case("openclaw")) + .unwrap_or(false); + + if !args.is_empty() { + let mut parts = args.split_whitespace(); + let Some(provider_id) = parts.next() else { + return Ok(html_response("用法：/model <provider_id> <model>", None)); + }; + let model = parts.collect::>().join(" "); + if provider_id.trim().is_empty() || model.trim().is_empty() { + return Ok(html_response("用法：/model <provider_id> <model>", None)); + } + if is_openclaw_agent { + let current = model_config + .as_ref() + .map(|config| format!("{} / {}", config.provider_id, config.model)) + .unwrap_or_else(|| "未单独指定，使用 OpenClaw 默认运行模型".into()); + let mut text = format!("当前 Telegram 模型绑定\n{}\n", html_escape(¤t)); + if let Some(agent) = current_agent { + text.push_str(&format!("\n当前 Agent: {}\n", html_escape(&agent.name))); + } + append_openclaw_model_status(&mut text); + return Ok(html_response( + &text, + Some(vec![vec![ActionButton { + label: "恢复 Agent 默认模型".into(), + action: "model.clear".into(), + params: None, + }]]), + )); + } + self.settings + .set_model_setting( + msg.platform, + &ChannelDefaultModelSetting { + id: provider_id.to_owned(), + use_model: model.clone(), + }, + ) + .await?; + let session = self + .session_mgr + .reset_session(internal_user_id, &msg.chat_id, &agent_config.agent_type, None) + .await?; + return Ok(html_response( + &format!( + "Telegram 默认模型已切换\nProvider: {}\nModel: {}\nSession: {}\n\n当前聊天已新建个人会话，后续消息会使用新的模型绑定。", + html_escape(provider_id), + html_escape(&model), + html_escape(&short_channel_id(&session.id)) + ), + None, + )); } - async fn delete_plugin(&self, _id: &str) -> Result<(), DbError> { - Ok(()) + + let current = model_config + .as_ref() + .map(|config| format!("{} / {}", config.provider_id, config.model)) + .unwrap_or_else(|| { + if is_openclaw_agent { + "未单独指定，使用 OpenClaw 默认运行模型".into() + } else { + "未单独指定，使用 Agent 默认模型".into() + } + }); + let mut text = format!("当前 Telegram 模型绑定\n{}\n", html_escape(¤t)); + let mut buttons = Vec::new(); + if let Some(agent) = current_agent { + text.push_str(&format!("\n当前 Agent: {}\n", html_escape(&agent.name))); + if is_openclaw_agent { + append_openclaw_model_status(&mut text); + } else if agent.models.is_empty() { + text.push_str("\n这个 Agent 当前没有上报可选模型。可以使用 Agent 默认模型。"); + } else { + text.push_str("\n请选择当前 Agent 可用模型："); + for model in agent.models.iter().take(12) { + buttons.push(vec![ActionButton { + label: short_button_label(&model.label), + action: "model.select".into(), + params: Some(HashMap::from([ + ("p".into(), model.provider_id.clone()), + ("m".into(), model.model.clone()), + ])), + }]); + } + } + } else { + text.push_str("\n当前 Agent 无法从本地 Agent 列表中解析。请先发送 /agent 选择一个本地 Agent。"); } + buttons.push(vec![ActionButton { + label: "恢复 Agent 默认模型".into(), + action: "model.clear".into(), + params: None, + }]); + Ok(html_response(&text, Some(buttons))) + } - async fn get_all_users(&self) -> Result, DbError> { - Ok(self.users.lock().unwrap().clone()) + async fn build_topic_model_command( + &self, + internal_user_id: &str, + msg: &UnifiedIncomingMessage, + agent_id: &str, + args: &str, + ) -> Result { + let thread_id = msg + .topic + .as_ref() + .map(|topic| topic.message_thread_id) + .ok_or_else(|| ChannelError::InvalidConfig("Telegram topic is missing".into()))?; + let option = self + .settings + .list_agent_options() + .await? + .into_iter() + .find(|option| option.agent_id == agent_id) + .ok_or_else(|| ChannelError::InvalidConfig(format!("Agent '{agent_id}' is unavailable")))?; + if option.models.is_empty() { + return Ok(html_response("当前 Agent 没有上报可切换模型。", None)); } - async fn get_user_by_platform( - &self, - platform_user_id: &str, - platform_type: &str, - ) -> Result, DbError> { - let users = self.users.lock().unwrap(); - Ok(users + let args = args.trim(); + if !args.is_empty() { + let mut parts = args.split_whitespace(); + let provider_id = parts.next().unwrap_or_default(); + let model = parts.collect::>().join(" "); + if !option + .models .iter() - .find(|u| u.platform_user_id == platform_user_id && u.platform_type == platform_type) - .cloned()) + .any(|item| item.provider_id == provider_id && item.model == model) + { + return Ok(html_response("该模型不属于当前话题绑定 Agent 的可用模型。", None)); + } + self.session_mgr + .set_topic_model(internal_user_id, &msg.chat_id, thread_id, agent_id, provider_id, &model) + .await?; + return Ok(html_response( + &format!( + "话题模型已切换\nAgent: {}\nProvider: {}\nModel: {}", + html_escape(&option.name), + html_escape(provider_id), + html_escape(&model) + ), + None, + )); } - async fn create_user(&self, row: &AssistantUserRow) -> Result<(), DbError> { - self.users.lock().unwrap().push(row.clone()); - Ok(()) + let buttons = option + .models + .iter() + .take(12) + .map(|item| { + vec![ActionButton { + label: item.label.clone(), + action: "model.select".into(), + params: Some(HashMap::from([ + ("p".into(), item.provider_id.clone()), + ("m".into(), item.model.clone()), + ])), + }] + }) + .collect(); + Ok(html_response( + &format!( + "{} 可用模型\n模型选择只影响你在当前话题中的会话。{}", + html_escape(&option.name), + option + .last_probe_at + .map(|checked_at| format!("\n能力探测时间: {checked_at}")) + .unwrap_or_default() + ), + Some(buttons), + )) + } + + async fn select_model_action( + &self, + internal_user_id: &str, + action: &UnifiedAction, + msg: &UnifiedIncomingMessage, + ) -> Result { + let provider_id = action + .params + .as_ref() + .and_then(|params| params.get("providerId").or_else(|| params.get("p"))) + .map(String::as_str) + .unwrap_or_default() + .trim(); + let model = action + .params + .as_ref() + .and_then(|params| params.get("model").or_else(|| params.get("m"))) + .map(String::as_str) + .unwrap_or_default() + .trim(); + if provider_id.is_empty() || model.is_empty() { + return Ok(html_response("缺少模型参数。请发送 /model 后点击模型按钮。", None)); } - async fn update_user_last_active(&self, _id: &str, _last_active: TimestampMs) -> Result<(), DbError> { - Ok(()) + + if msg.platform == crate::types::PluginType::Telegram + && let Some(topic) = &msg.topic + && topic.message_thread_id != 1 + { + let thread_id = topic.message_thread_id; + let binding = self + .session_mgr + .get_topic_binding(&action.context.chat_id, thread_id) + .await?; + let Some(binding) = binding else { + return Ok(html_response("当前话题尚未绑定 Agent。", None)); + }; + let agent_id = binding.agent_id; + let option = self + .settings + .list_agent_options() + .await? + .into_iter() + .find(|option| option.agent_id == agent_id); + let allowed = option.as_ref().is_some_and(|option| { + option + .models + .iter() + .any(|item| item.provider_id == provider_id && item.model == model) + }); + if !allowed { + return Ok(html_response("该模型不属于当前话题绑定 Agent。", None)); + } + self.session_mgr + .set_topic_model( + internal_user_id, + &action.context.chat_id, + thread_id, + &agent_id, + provider_id, + model, + ) + .await?; + return Ok(html_response( + &format!( + "话题模型已切换\nAgent: {}\nProvider: {}\nModel: {}", + html_escape(option.as_ref().map(|value| value.name.as_str()).unwrap_or(&agent_id)), + html_escape(provider_id), + html_escape(model) + ), + None, + )); } - async fn delete_user(&self, _id: &str) -> Result<(), DbError> { - Ok(()) + + let agent_config = self.settings.get_agent_config(action.context.platform).await?; + let agent_options = self.settings.list_agent_options().await?; + let assistant = self.settings.get_assistant_setting(action.context.platform).await?; + let current_agent = resolve_current_agent_option(&agent_options, assistant.as_ref(), &agent_config); + let allowed = current_agent + .as_ref() + .map(|agent| { + agent + .models + .iter() + .any(|option| option.provider_id == provider_id && option.model == model) + }) + .unwrap_or(false); + if !allowed { + return Ok(html_response( + "这个模型不属于当前 Telegram Agent 的可选模型。请发送 /model 重新选择。", + None, + )); } - async fn get_all_sessions(&self) -> Result, DbError> { - Ok(self.sessions.lock().unwrap().clone()) + self.settings + .set_model_setting( + action.context.platform, + &ChannelDefaultModelSetting { + id: provider_id.to_owned(), + use_model: model.to_owned(), + }, + ) + .await?; + let session = self + .session_mgr + .reset_session( + internal_user_id, + &action.context.chat_id, + &agent_config.agent_type, + None, + ) + .await?; + Ok(html_response( + &format!( + "Telegram 模型已切换\nAgent: {}\nProvider: {}\nModel: {}\nSession: {}\n\n当前聊天已新建个人会话，后续消息会使用新的模型绑定。", + html_escape(current_agent.map(|agent| agent.name.as_str()).unwrap_or("当前 Agent")), + html_escape(provider_id), + html_escape(model), + html_escape(&short_channel_id(&session.id)) + ), + None, + )) + } + + async fn clear_model_action( + &self, + internal_user_id: &str, + action: &UnifiedAction, + ) -> Result { + self.settings.clear_model_setting(action.context.platform).await?; + let agent_config = self.settings.get_agent_config(action.context.platform).await?; + let session = self + .session_mgr + .reset_session( + internal_user_id, + &action.context.chat_id, + &agent_config.agent_type, + None, + ) + .await?; + Ok(html_response( + &format!( + "已恢复 Agent 默认模型\nSession: {}\n\n当前聊天已新建个人会话。", + html_escape(&short_channel_id(&session.id)) + ), + None, + )) + } + + async fn reset_personal_session_command( + &self, + internal_user_id: &str, + msg: &UnifiedIncomingMessage, + new_session: bool, + title_arg: Option<&str>, + ) -> Result { + let key = pending_key(internal_user_id, msg.platform, &msg.chat_id); + self.pending_flows.lock().unwrap().remove(&key); + self.personal_title_hints.lock().unwrap().remove(&key); + let agent_config = self.settings.get_agent_config(msg.platform).await?; + let session = self + .session_mgr + .reset_session(internal_user_id, &msg.chat_id, &agent_config.agent_type, None) + .await?; + let title = title_arg.and_then(normalize_personal_title); + if new_session && let Some(title) = title.as_ref() { + self.personal_title_hints.lock().unwrap().insert(key, title.clone()); } - async fn get_session(&self, id: &str) -> Result, DbError> { - let sessions = self.sessions.lock().unwrap(); - Ok(sessions.iter().find(|s| s.id == id).cloned()) + let title = if new_session { + "已新建个人会话。" + } else { + "已切换到个人会话。" + }; + let title_line = title_arg + .and_then(normalize_personal_title) + .map(|title| format!("\n标题: {}", html_escape(&title))) + .unwrap_or_default(); + Ok(html_response( + &format!( + "{}{}\nSession: {}\nAgent: {}", + title, + title_line, + html_escape(&short_channel_id(&session.id)), + html_escape(&session.agent_type) + ), + None, + )) + } + + async fn rename_personal_command( + &self, + internal_user_id: &str, + msg: &UnifiedIncomingMessage, + args: &str, + ) -> Result { + let Some(title) = normalize_personal_title(args) else { + return Ok(html_response("用法：/rename <新的会话标题>", None)); + }; + + let agent_config = self.settings.get_agent_config(msg.platform).await?; + let session = self + .session_mgr + .get_or_create_session(internal_user_id, &msg.chat_id, &agent_config.agent_type, None) + .await?; + + let Some(conversation_id) = session.conversation_id.as_deref() else { + let key = pending_key(internal_user_id, msg.platform, &msg.chat_id); + self.personal_title_hints.lock().unwrap().insert(key, title.clone()); + return Ok(html_response( + &format!( + "已设置新个人会话标题\n{}\n\n当前聊天还没有创建实际会话，下一条普通消息会使用这个标题。", + html_escape(&title) + ), + None, + )); + }; + + let Some(directory) = self.personal_directory.as_ref() else { + return Ok(html_response("当前运行时未接入个人会话重命名服务。", None)); + }; + let Some(renamed) = directory + .rename_personal_conversation(internal_user_id, msg.platform, &msg.chat_id, conversation_id, &title) + .await? + else { + return Ok(html_response("没有找到当前个人会话，无法重命名。", None)); + }; + + Ok(html_response( + &format!( + "已重命名当前个人会话\n{}\nID: {}", + html_escape(&renamed.name), + html_escape(&short_channel_id(&renamed.id)) + ), + None, + )) + } + + async fn build_personal_list_command( + &self, + internal_user_id: &str, + msg: &UnifiedIncomingMessage, + ) -> Result { + let Some(directory) = self.personal_directory.as_ref() else { + return Ok(html_response("当前运行时未接入个人会话列表服务。", None)); + }; + let conversations = directory + .list_personal_conversations(internal_user_id, msg.platform, &msg.chat_id) + .await?; + if conversations.is_empty() { + return Ok(html_response( + "当前没有可切换的 Telegram 个人会话。\n\n可以发送 /new_session 新建一个个人会话。", + None, + )); } - async fn get_or_create_session( - &self, - user_id: &str, - chat_id: &str, - new_row: &AssistantSessionRow, - ) -> Result { - let mut sessions = self.sessions.lock().unwrap(); - if let Some(existing) = sessions - .iter_mut() - .find(|s| s.user_id == user_id && s.chat_id.as_deref() == Some(chat_id)) + + let mut text = String::from("请选择要切换的个人会话\n"); + for (idx, conversation) in conversations.iter().take(12).enumerate() { + let agent_label = conversation + .agent_label + .as_deref() + .filter(|value| !value.trim().is_empty()) + .unwrap_or(&conversation.agent_type); + text.push_str(&format!( + "\n\n{}. {}\nAgent: {}\nID: {}", + idx + 1, + html_escape(&conversation.name), + html_escape(agent_label), + html_escape(&short_channel_id(&conversation.id)) + )); + if let Some(recent_message) = conversation.recent_message.as_deref() + && !recent_message.trim().is_empty() { - existing.last_activity = new_row.last_activity; - return Ok(existing.clone()); + text.push_str(&format!("\n最近: {}", html_escape(recent_message))); } - sessions.push(new_row.clone()); - Ok(new_row.clone()) } - async fn update_session_activity(&self, _id: &str, _last_activity: TimestampMs) -> Result<(), DbError> { - Ok(()) + Ok(html_response(&text, Some(personal_select_buttons(&conversations)))) + } + + async fn select_personal_action( + &self, + internal_user_id: &str, + action: &UnifiedAction, + ) -> Result { + let Some(directory) = self.personal_directory.as_ref() else { + return Ok(html_response("当前运行时未接入个人会话列表服务。", None)); + }; + let conversation_id = action + .params + .as_ref() + .and_then(|params| params.get("id")) + .map(String::as_str) + .unwrap_or_default() + .trim(); + if conversation_id.is_empty() { + return Ok(html_response( + "缺少 conversation id。请发送 /personal_list 后点击会话按钮。", + None, + )); } - async fn update_session_conversation(&self, id: &str, conversation_id: &str) -> Result<(), DbError> { - let mut sessions = self.sessions.lock().unwrap(); - if let Some(s) = sessions.iter_mut().find(|s| s.id == id) { - s.conversation_id = Some(conversation_id.to_owned()); - Ok(()) - } else { - Err(DbError::NotFound(id.into())) + let Some(conversation) = directory + .get_personal_conversation( + internal_user_id, + action.context.platform, + &action.context.chat_id, + conversation_id, + ) + .await? + else { + return Ok(html_response( + "没有找到这个个人会话。请发送 /personal_list 重新选择。", + None, + )); + }; + + let session = self + .session_mgr + .reset_session( + internal_user_id, + &action.context.chat_id, + &conversation.agent_type, + None, + ) + .await?; + self.session_mgr + .bind_conversation(&session.id, &conversation.id) + .await?; + Ok(html_response( + &format!( + "已切换到个人会话\nConversation: {}\nSession: {}\nAgent: {}", + html_escape(&conversation.name), + html_escape(&short_channel_id(&session.id)), + html_escape(&conversation.agent_type), + ), + None, + )) + } + + async fn build_team_status_command( + &self, + internal_user_id: &str, + msg: &UnifiedIncomingMessage, + ) -> Result { + let agent_config = self.settings.get_agent_config(msg.platform).await?; + let session = self + .session_mgr + .get_or_create_session(internal_user_id, &msg.chat_id, &agent_config.agent_type, None) + .await?; + let conversation = session.conversation_id.as_deref().unwrap_or("尚未绑定 Team 会话"); + let team_label = self + .find_team_by_conversation(internal_user_id, session.conversation_id.as_deref()) + .await? + .map(|team| format!("{} ({})", team.name, team.id)) + .unwrap_or_else(|| "未识别为已知 Team".into()); + Ok(html_response( + &format!( + "Team 会话状态\n当前 Channel Session: {}\n当前 Conversation: {}\n当前 Team: {}\n\n如果这个 Conversation 属于 Team-owned 会话，后续普通消息会自动通过 Team API 路由。", + html_escape(&short_channel_id(&session.id)), + html_escape(conversation), + html_escape(&team_label) + ), + None, + )) + } + + async fn build_team_list_command(&self, internal_user_id: &str) -> Result { + let Some(directory) = &self.team_directory else { + return Ok(html_response("当前运行时未接入 Team 查询服务。", None)); + }; + let teams = directory.list_teams(internal_user_id).await?; + if teams.is_empty() { + return Ok(html_response( + "当前没有可用 Team。\n\n可以先在 WebUI 创建团队，或发送 /team_new <主题> 创建真实 Team。", + None, + )); + } + let mut text = String::from("可用 Team\n"); + for (idx, team) in teams.iter().enumerate() { + text.push_str(&format!( + "\n{}. {} ({})\n成员数：{}", + idx + 1, + html_escape(&team.name), + html_escape(&short_channel_id(&team.id)), + team.agent_count, + )); + } + text.push_str("\n\n点击下面按钮即可切换，不需要复制 Team ID。"); + Ok(html_response(&text, Some(team_select_buttons(&teams)))) + } + + async fn create_team_command( + &self, + internal_user_id: &str, + msg: &UnifiedIncomingMessage, + topic: &str, + ) -> Result { + let Some(directory) = &self.team_directory else { + return Ok(html_response("当前运行时未接入 Team 创建服务。", None)); + }; + let topic = topic.trim(); + if topic.is_empty() { + let key = pending_key(internal_user_id, msg.platform, &msg.chat_id); + self.pending_flows + .lock() + .unwrap() + .insert(key, PendingFlow::TeamNewAwaitingName); + return Ok(html_response( + "创建新 Team\n\n请直接回复团队名称。\n例如：今日4小时BTC做单分析\n\n也可以发送 /team_new <团队名> 快速创建。", + Some(vec![vec![ActionButton { + label: "取消".into(), + action: "team.new.cancel".into(), + params: None, + }]]), + )); + } + if topic.eq_ignore_ascii_case("confirm") || topic.eq_ignore_ascii_case("cancel") { + return Ok(html_response( + "Team 草稿确认流程已下线。\n\n现在请直接发送：/team_new <团队主题>", + None, + )); + } + + let _ = directory; + self.create_team_from_topic(internal_user_id, msg.platform, &msg.chat_id, &msg.user.id, topic) + .await + } + + async fn create_team_from_topic( + &self, + internal_user_id: &str, + platform: crate::types::PluginType, + chat_id: &str, + platform_user_id: &str, + topic: &str, + ) -> Result { + let Some(directory) = &self.team_directory else { + return Ok(html_response("当前运行时未接入 Team 创建服务。", None)); + }; + let assistant_setting = self.settings.get_assistant_setting(platform).await?; + let Some(assistant_id) = assistant_setting + .as_ref() + .and_then(|setting| setting.assistant_id.as_deref()) + .map(str::trim) + .filter(|assistant_id| !assistant_id.is_empty()) + .map(normalize_team_assistant_id) + else { + return Ok(html_response( + "当前 Telegram 还没有可用于创建 Team 的 Assistant 绑定。\n\n请先在 WebUI 的 Channel 设置里为 Telegram 选择一个 Agent/Assistant，然后再发送 /team_new <团队主题>。", + None, + )); + }; + + let agent_config = match self.settings.get_agent_config(platform).await { + Ok(config) => config, + Err(error) => { + warn!(error = %error, "failed to resolve channel agent config for team creation; falling back to acp session binding"); + crate::channel_settings::ResolvedAgentConfig { + agent_type: "acp".into(), + backend: None, + } + } + }; + let model_config = self.settings.get_model_config(platform).await?; + let model = model_config + .and_then(|config| config.use_model.or(Some(config.model))) + .unwrap_or_else(|| "default".into()); + let lead_name = assistant_setting + .as_ref() + .and_then(|setting| setting.name.as_deref()) + .map(str::trim) + .filter(|name| !name.is_empty()) + .map(ToOwned::to_owned) + .or_else(|| agent_config.backend.clone()) + .unwrap_or_else(|| "Team Lead".into()); + + let team = match directory + .create_team( + internal_user_id, + ChannelTeamCreateRequest { + name: topic.to_owned(), + lead_name, + lead_role: "lead".into(), + assistant_id, + model, + source_channel: Some(platform.to_string()), + source_channel_id: None, + source_chat_id: Some(chat_id.to_owned()), + source_user_id: Some(platform_user_id.to_owned()), + source_label: Some(channel_source_label(platform).into()), + created_from: Some(platform.to_string()), + }, + ) + .await + { + Ok(team) => team, + Err(error) => { + return Ok(html_response( + &format!( + "Team 创建失败：{}\n\n请检查 Telegram 当前绑定的 Assistant 是否可用于 Team，或先在 WebUI 创建/选择 Team。", + html_escape(&error.to_string()) + ), + None, + )); + } + }; + if let Err(error) = directory.ensure_team_session(internal_user_id, &team.id).await { + return Ok(html_response( + &format!( + "Team 已创建，但启动 Team session 失败：{}\n\n请稍后发送 /team_select {} 重试切换。", + html_escape(&error.to_string()), + html_escape(&team.id) + ), + None, + )); + } + + let Some(conversation_id) = team.lead_conversation_id.as_deref().filter(|id| !id.trim().is_empty()) else { + return Ok(html_response( + "Team 已创建，但 Lead conversation 尚未初始化完成。请稍后发送 /team_list 查看并使用 /team_select 切换。", + None, + )); + }; + + let session = self + .session_mgr + .get_or_create_session(internal_user_id, chat_id, &agent_config.agent_type, None) + .await?; + self.session_mgr.bind_conversation(&session.id, conversation_id).await?; + + Ok(html_response( + &format!( + "Team 已创建并切换\nTeam: {}\nTeam ID: {}\nLead Conversation: {}\n\n现在直接发送普通消息，会通过 Team API 发给 Team Lead。", + html_escape(&team.name), + html_escape(&team.id), + html_escape(conversation_id), + ), + None, + )) + } + + async fn select_team_command( + &self, + internal_user_id: &str, + msg: &UnifiedIncomingMessage, + selector: &str, + ) -> Result { + let Some(directory) = &self.team_directory else { + return Ok(html_response("当前运行时未接入 Team 查询服务。", None)); + }; + if selector.trim().is_empty() { + let teams = directory.list_teams(internal_user_id).await?; + if teams.is_empty() { + return Ok(html_response( + "当前没有可用 Team。\n\n可以先在 WebUI 创建团队，或发送 /team_new 创建 Telegram 侧 Team。", + None, + )); + } + let text = "请选择要切换的 Team\n\n点击下面按钮即可切换，不需要复制 Team ID。"; + return Ok(html_response(text, Some(team_select_buttons(&teams)))); + } + + self.select_team_by_selector(internal_user_id, msg.platform, &msg.chat_id, selector) + .await + } + + async fn select_team_by_selector( + &self, + internal_user_id: &str, + platform: crate::types::PluginType, + chat_id: &str, + selector: &str, + ) -> Result { + let Some(directory) = &self.team_directory else { + return Ok(html_response("当前运行时未接入 Team 查询服务。", None)); + }; + if selector.trim().is_empty() { + return Ok(html_response("请选择一个 Team。发送 /team_select 查看按钮列表。", None)); + } + + let teams = directory.list_teams(internal_user_id).await?; + let selector_lower = selector.to_ascii_lowercase(); + let Some(team) = teams.into_iter().find(|team| { + team.id == selector || team.name == selector || team.name.to_ascii_lowercase().contains(&selector_lower) + }) else { + return Ok(html_response( + "没有找到匹配的 Team。发送 /team_list 查看可用团队。", + None, + )); + }; + + directory.ensure_team_session(internal_user_id, &team.id).await?; + let team = directory.get_team(internal_user_id, &team.id).await?.unwrap_or(team); + let Some(conversation_id) = team.lead_conversation_id.as_deref().filter(|id| !id.trim().is_empty()) else { + return Ok(html_response( + "已找到 Team，但还没有可绑定的 Lead conversation。请先在 WebUI 打开该 Team，让系统完成初始化。", + None, + )); + }; + + let agent_config = match self.settings.get_agent_config(platform).await { + Ok(config) => config, + Err(error) => { + warn!(error = %error, "failed to resolve channel agent config for team selection; falling back to acp session binding"); + crate::channel_settings::ResolvedAgentConfig { + agent_type: "acp".into(), + backend: None, + } + } + }; + let session = self + .session_mgr + .get_or_create_session(internal_user_id, chat_id, &agent_config.agent_type, None) + .await?; + self.session_mgr.bind_conversation(&session.id, conversation_id).await?; + + Ok(html_response( + &format!( + "已切换到 Team 会话。\nTeam: {}\nConversation: {}\n\n现在直接发送普通消息，会通过 Team API 发给 Team Lead。", + html_escape(&team.name), + html_escape(conversation_id), + ), + None, + )) + } + + async fn find_team_by_conversation( + &self, + internal_user_id: &str, + conversation_id: Option<&str>, + ) -> Result, ChannelError> { + let Some(conversation_id) = conversation_id else { + return Ok(None); + }; + let Some(directory) = &self.team_directory else { + return Ok(None); + }; + let teams = directory.list_teams(internal_user_id).await?; + Ok(teams + .into_iter() + .find(|team| team.lead_conversation_id.as_deref() == Some(conversation_id))) + } +} + +// ── Helper builders ───────────────────────────────────────────────── + +fn build_pairing_response(code: &str) -> ActionResponse { + ActionResponse { + text: Some(format!( + "Welcome! To use this bot, you need authorization.\n\n\ + Your pairing code: *{code}*\n\n\ + Share this code with the admin, who can approve it in \ + Settings → Channel → Pairing Requests.\n\ + The code expires in 10 minutes." + )), + parse_mode: None, + buttons: Some(vec![vec![ + ActionButton { + label: "Refresh Code".into(), + action: "pairing.refresh".into(), + params: None, + }, + ActionButton { + label: "Check Status".into(), + action: "pairing.check".into(), + params: None, + }, + ActionButton { + label: "Help".into(), + action: "pairing.help".into(), + params: None, + }, + ]]), + keyboard: None, + behavior: ActionBehavior::Send, + toast: None, + edit_message_id: None, + } +} + +fn build_help_response() -> ActionResponse { + ActionResponse { + text: Some( + "How can I help?\n\ + Choose an option below or just send me a message." + .into(), + ), + parse_mode: None, + buttons: Some(vec![ + vec![ + ActionButton { + label: "New Session".into(), + action: "session.new".into(), + params: None, + }, + ActionButton { + label: "Session Status".into(), + action: "session.status".into(), + params: None, + }, + ], + vec![ + ActionButton { + label: "Features".into(), + action: "help.features".into(), + params: None, + }, + ActionButton { + label: "Tips".into(), + action: "help.tips".into(), + params: None, + }, + ], + ]), + keyboard: None, + behavior: ActionBehavior::Send, + toast: None, + edit_message_id: None, + } +} + +fn build_command_help_response() -> ActionResponse { + html_response( + "Telegram 可用命令\n/status - 查看当前绑定\n/agent - 按钮切换 Telegram 本地 Agent\n/model - 按钮切换当前 Agent 可用模型\n/project - 当前项目\n/run_info - 当前开发运行\n/diff_summary - 变更和证据摘要\n/test - 执行单元测试门禁\n/stop - 停止当前运行\n/retry - 重试最近失败门禁\n/handoff - Web 接力入口\n/team - 查看团队会话状态\n/team_help - 查看 Team 功能说明\n/team_list - 团队列表入口\n/team_select - 按钮选择团队\n/team_new - 交互式创建 Team\n/team_new <主题> - 快速创建真实 Team\n/personal - 切换到新的个人会话\n/personal_list - 按钮选择已有个人会话\n/new_session - 新建个人会话\n/new_session <标题> - 新建带标题的个人会话\n/rename <标题> - 重命名当前个人会话\n/help - 查看帮助", + Some(vec![ + vec![ + ActionButton { + label: "选择 Agent".into(), + action: "agent.list".into(), + params: None, + }, + ActionButton { + label: "个人会话".into(), + action: "personal.list".into(), + params: None, + }, + ], + vec![ + ActionButton { + label: "选择 Team".into(), + action: "team.list".into(), + params: None, + }, + ActionButton { + label: "创建 Team".into(), + action: "team.new.start".into(), + params: None, + }, + ], + vec![ActionButton { + label: "Team 帮助".into(), + action: "team.help".into(), + params: None, + }], + ]), + ) +} + +fn build_team_help_response() -> ActionResponse { + html_response( + "Telegram Team 功能说明\n\nTeam 是什么\nTeam 是一个多 Agent 协作会话。通常由 Team Lead 负责拆解任务、分配给成员、汇总结果；成员可以使用不同 assistant、模型、权限和工作区。\n\n常用流程\n1. 创建新 Team：/team_new <主题>\n2. 查看已有 Team：/team_list\n3. 按钮切换 Team：/team_select\n4. 查看当前 Team 状态：/team\n5. 回到个人会话：/personal、/personal_list 或 /new_session\n\nTelegram 与 WebUI 的关系\nTelegram 负责移动端下达任务、接收结果和切换入口；WebUI 更适合查看完整历史、多列 Team 运行状态、成员配置、权限、模型和工作区。\n\n上下文说明\n/team_new 会创建一个新的真实 Team，并把 Telegram 绑定到该 Team Lead conversation。切换到 Team 后，普通消息会通过 Team API 发送给 Team Lead。\n\n个人会话说明\n/personal 会切回一个新的个人 agent 会话；/personal_list 可以按钮选择已有 Telegram 个人会话；/new_session 会新建个人会话，不会删除已有 Team。", + None, + ) +} + +fn channel_source_label(platform: crate::types::PluginType) -> &'static str { + match platform { + crate::types::PluginType::Telegram => "Telegram", + crate::types::PluginType::Lark => "Lark", + crate::types::PluginType::Dingtalk => "DingTalk", + crate::types::PluginType::Weixin => "WeCom", + crate::types::PluginType::Slack => "Slack", + crate::types::PluginType::Discord => "Discord", + } +} + +fn short_channel_id(id: &str) -> String { + let chars: Vec = id.chars().collect(); + if chars.len() <= 13 { + return id.to_owned(); + } + let head: String = chars.iter().take(8).collect(); + let tail: String = chars + .iter() + .rev() + .take(4) + .collect::>() + .into_iter() + .rev() + .collect(); + format!("{head}...{tail}") +} + +fn short_button_label(label: &str) -> String { + let chars: Vec = label.chars().collect(); + if chars.len() <= 28 { + return label.to_owned(); + } + let head: String = chars.iter().take(25).collect(); + format!("{head}...") +} + +fn team_select_buttons(teams: &[ChannelTeamSummary]) -> Vec> { + let mut rows = Vec::new(); + for team in teams.iter().take(12) { + rows.push(vec![ActionButton { + label: short_button_label(&team.name), + action: "team.select".into(), + params: Some(HashMap::from([("id".into(), team.id.clone())])), + }]); + } + rows +} + +fn personal_select_buttons(conversations: &[ChannelPersonalConversationSummary]) -> Vec> { + let mut rows = Vec::new(); + for conversation in conversations.iter().take(12) { + rows.push(vec![ActionButton { + label: short_button_label(&personal_button_label(conversation)), + action: "personal.select".into(), + params: Some(HashMap::from([("id".into(), conversation.id.clone())])), + }]); + } + rows +} + +fn personal_button_label(conversation: &ChannelPersonalConversationSummary) -> String { + if !agent_label_matches_title(conversation) + || conversation + .recent_message + .as_deref() + .map(str::trim) + .filter(|value| !value.is_empty()) + .is_none() + { + return conversation.name.clone(); + } + conversation + .recent_message + .as_deref() + .and_then(normalize_personal_title) + .unwrap_or_else(|| conversation.name.clone()) +} + +fn agent_label_matches_title(conversation: &ChannelPersonalConversationSummary) -> bool { + conversation + .agent_label + .as_deref() + .map(|agent| agent.trim().eq_ignore_ascii_case(conversation.name.trim())) + .unwrap_or(false) +} + +fn normalize_personal_title(raw: &str) -> Option { + let collapsed = raw.split_whitespace().collect::>().join(" "); + let trimmed = collapsed.trim(); + if trimmed.is_empty() { + return None; + } + Some(truncate_chars(trimmed, 32)) +} + +fn auto_title_from_message(raw: &str) -> Option { + let title = normalize_personal_title(raw)?; + if title.starts_with('/') { + return None; + } + Some(title) +} + +fn truncate_chars(value: &str, max_chars: usize) -> String { + let mut chars = value.chars(); + let head: String = chars.by_ref().take(max_chars).collect(); + if chars.next().is_some() { + format!("{head}...") + } else { + head + } +} + +fn resolve_current_agent_option<'a>( + options: &'a [ChannelAgentOption], + assistant: Option<&aionui_api_types::ChannelAssistantSettingResponse>, + config: &crate::channel_settings::ResolvedAgentConfig, +) -> Option<&'a ChannelAgentOption> { + if let Some(id) = assistant + .and_then(|setting| setting.assistant_id.as_deref().or(setting.custom_agent_id.as_deref())) + .map(str::trim) + .filter(|id| !id.is_empty()) + && let Some(option) = options.iter().find(|option| option.agent_id == id) + { + return Some(option); + } + + if let Some(backend) = config.backend.as_deref() + && let Some(option) = options.iter().find(|option| option.backend.as_deref() == Some(backend)) + { + return Some(option); + } + + options + .iter() + .find(|option| option.agent_type == config.agent_type && option.backend.is_none()) + .or_else(|| options.iter().find(|option| option.agent_type == config.agent_type)) +} + +fn pending_key(internal_user_id: &str, platform: crate::types::PluginType, chat_id: &str) -> String { + format!("{platform}:{internal_user_id}:{chat_id}") +} + +fn html_response(text: &str, buttons: Option>>) -> ActionResponse { + ActionResponse { + text: Some(text.to_owned()), + parse_mode: Some(ParseMode::HTML), + buttons, + keyboard: None, + behavior: ActionBehavior::Send, + toast: None, + edit_message_id: None, + } +} + +fn normalize_team_assistant_id(assistant_id: &str) -> String { + let trimmed = assistant_id.trim(); + if trimmed.len() == 8 && trimmed.chars().all(|ch| ch.is_ascii_hexdigit()) { + format!("bare:{trimmed}") + } else { + trimmed.to_owned() + } +} + +fn html_escape(text: &str) -> String { + text.replace('&', "&").replace('<', "<").replace('>', ">") +} + +#[derive(Debug, Clone, PartialEq, Eq)] +struct OpenClawRuntimeModel { + provider: Option, + name: Option, + think_level: Option, +} + +impl OpenClawRuntimeModel { + fn display_name(&self) -> String { + match (self.provider.as_deref(), self.name.as_deref()) { + (Some(provider), Some(name)) => format!("{provider} / {name}"), + (Some(provider), None) => provider.to_owned(), + (None, Some(name)) => name.to_owned(), + (None, None) => "未知模型".to_owned(), + } + } +} + +fn append_openclaw_model_status(text: &mut String) { + text.push_str("\nOpenClaw 当前没有通过 ACP 上报可切换模型列表。"); + if let Some(runtime_model) = find_openclaw_runtime_model() { + text.push_str(&format!( + "\n最近运行时检测模型: {}", + html_escape(&runtime_model.display_name()) + )); + if let Some(think_level) = runtime_model.think_level.as_deref() + && !think_level.trim().is_empty() + { + text.push_str(&format!("\n推理强度: {}", html_escape(think_level))); + } + } else { + text.push_str("\n最近运行时检测模型: 暂未检测到"); + } + text.push_str( + "\n\n暂不支持在 Telegram 中切换 OpenClaw 模型。\n后续等待 OpenClaw ACP 完善模型列表和 set model 能力后可实现。", + ); +} + +fn find_openclaw_runtime_model() -> Option { + let sessions_dir = openclaw_sessions_dir()?; + let mut entries = std::fs::read_dir(sessions_dir) + .ok()? + .filter_map(Result::ok) + .filter(|entry| { + entry + .file_name() + .to_str() + .map(|name| name.ends_with(".trajectory.jsonl")) + .unwrap_or(false) + }) + .filter_map(|entry| { + let modified = entry.metadata().ok()?.modified().ok()?; + Some((modified, entry.path())) + }) + .collect::>(); + + entries.sort_by(|(a, _), (b, _)| b.cmp(a)); + + for (_, path) in entries { + if let Some(runtime_model) = extract_openclaw_runtime_model_from_trajectory(&path) { + return Some(runtime_model); + } + } + None +} + +fn openclaw_sessions_dir() -> Option { + if let Ok(state_dir) = std::env::var("OPENCLAW_STATE_DIR") + && !state_dir.trim().is_empty() + { + return Some(std::path::PathBuf::from(state_dir).join("agents/main/sessions")); + } + let home = std::env::var("HOME").ok()?; + Some(std::path::PathBuf::from(home).join(".openclaw/agents/main/sessions")) +} + +fn extract_openclaw_runtime_model_from_trajectory(path: &std::path::Path) -> Option { + let file = std::fs::File::open(path).ok()?; + let reader = std::io::BufReader::new(file); + let mut latest = None; + for line in std::io::BufRead::lines(reader).map_while(Result::ok) { + if let Some(runtime_model) = extract_openclaw_runtime_model_from_trajectory_line(&line) { + latest = Some(runtime_model); + } + } + latest +} + +fn extract_openclaw_runtime_model_from_trajectory_line(line: &str) -> Option { + let value: serde_json::Value = serde_json::from_str(line).ok()?; + if value.get("type").and_then(serde_json::Value::as_str) != Some("trace.metadata") { + return None; + } + let model = value.get("data")?.get("model")?; + let read_string = |key: &str| { + model + .get(key) + .and_then(serde_json::Value::as_str) + .map(str::trim) + .filter(|value| !value.is_empty()) + .map(ToOwned::to_owned) + }; + let provider = read_string("provider"); + let name = read_string("name").or_else(|| read_string("model")); + let think_level = read_string("thinkLevel").or_else(|| read_string("think_level")); + + if provider.is_none() && name.is_none() && think_level.is_none() { + return None; + } + + Some(OpenClawRuntimeModel { + provider, + name, + think_level, + }) +} + +fn build_unknown_action_response(action: &str) -> ActionResponse { + ActionResponse { + text: Some(format!("Unknown action: {action}")), + parse_mode: None, + buttons: None, + keyboard: None, + behavior: ActionBehavior::Send, + toast: None, + edit_message_id: None, + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::types::{ActionContext, MessageContentType, PluginType, UnifiedMessageContent, UnifiedUser}; + use aionui_api_types::WebSocketMessage; + use aionui_common::{TimestampMs, now_ms}; + use aionui_db::models::{ + AgentMetadataRow, AssistantSessionRow, AssistantUserRow, ChannelPluginRow, ClientPreference, PairingCodeRow, + Provider, UpdateAgentAvailabilitySnapshotParams, UpdateAgentHandshakeParams, UpsertAgentMetadataParams, + }; + use aionui_db::{ + CreateProviderParams, DbError, IAgentMetadataRepository, IChannelRepository, IClientPreferenceRepository, + IProviderRepository, UpdatePluginStatusParams, UpdateProviderParams, + }; + use aionui_realtime::EventBroadcaster; + use std::collections::HashMap; + use std::sync::Mutex; + + type ApprovalResolution = (String, PluginType, String, Option, String, usize); + + #[derive(Default)] + struct RecordingApprovalPort { + resolutions: Mutex>, + } + + #[derive(Default)] + struct RecordingDevelopmentPort { + calls: Mutex< + Vec<( + crate::development::ChannelDevelopmentContext, + crate::development::ChannelDevelopmentCommand, + )>, + >, + } + + #[async_trait::async_trait] + impl crate::development::ChannelDevelopmentPort for RecordingDevelopmentPort { + async fn execute( + &self, + context: crate::development::ChannelDevelopmentContext, + command: crate::development::ChannelDevelopmentCommand, + ) -> Result { + self.calls.lock().unwrap().push((context, command)); + Ok("Project: Aion\nRun: running".into()) + } + } + + #[async_trait::async_trait] + impl crate::approval::ChannelApprovalPort for RecordingApprovalPort { + async fn create( + &self, + _context: crate::approval::ChannelApprovalContext, + _confirmation: aionui_common::Confirmation, + ) -> Result { + Ok("approval".into()) + } + + async fn resolve( + &self, + context: crate::approval::ChannelApprovalResolutionContext, + approval_id: &str, + option_index: usize, + ) -> Result { + self.resolutions.lock().unwrap().push(( + context.source_user_id, + context.platform, + context.chat_id, + context.message_thread_id, + approval_id.into(), + option_index, + )); + Ok("approved".into()) + } + } + + // ── Mock EventBroadcaster ────────────────────────────────────────── + + struct MockBroadcaster; + + impl EventBroadcaster for MockBroadcaster { + fn broadcast(&self, _event: WebSocketMessage) {} + } + + // ── Mock IChannelRepository ──────────────────────────────────────── + + struct MockRepo { + users: Mutex>, + sessions: Mutex>, + pairings: Mutex>, + } + + impl MockRepo { + fn new() -> Self { + Self { + users: Mutex::new(Vec::new()), + sessions: Mutex::new(Vec::new()), + pairings: Mutex::new(Vec::new()), + } + } + + fn add_authorized_user(&self, platform_user_id: &str, platform_type: &str) { + let user = AssistantUserRow { + id: format!("user_{platform_user_id}"), + platform_user_id: platform_user_id.to_owned(), + platform_type: platform_type.to_owned(), + display_name: Some("Test User".into()), + authorized_at: now_ms(), + last_active: None, + session_id: None, + }; + self.users.lock().unwrap().push(user); + } + } + + #[async_trait::async_trait] + impl IChannelRepository for MockRepo { + async fn get_all_plugins(&self) -> Result, DbError> { + Ok(vec![]) + } + async fn get_plugin(&self, _id: &str) -> Result, DbError> { + Ok(None) + } + async fn upsert_plugin(&self, _row: &ChannelPluginRow) -> Result<(), DbError> { + Ok(()) + } + async fn update_plugin_status(&self, _id: &str, _params: &UpdatePluginStatusParams) -> Result<(), DbError> { + Ok(()) + } + async fn delete_plugin(&self, _id: &str) -> Result<(), DbError> { + Ok(()) + } + + async fn get_all_users(&self) -> Result, DbError> { + Ok(self.users.lock().unwrap().clone()) + } + async fn get_user_by_platform( + &self, + platform_user_id: &str, + platform_type: &str, + ) -> Result, DbError> { + let users = self.users.lock().unwrap(); + Ok(users + .iter() + .find(|u| u.platform_user_id == platform_user_id && u.platform_type == platform_type) + .cloned()) + } + async fn create_user(&self, row: &AssistantUserRow) -> Result<(), DbError> { + self.users.lock().unwrap().push(row.clone()); + Ok(()) + } + async fn update_user_last_active(&self, _id: &str, _last_active: TimestampMs) -> Result<(), DbError> { + Ok(()) + } + async fn delete_user(&self, _id: &str) -> Result<(), DbError> { + Ok(()) + } + + async fn get_all_sessions(&self) -> Result, DbError> { + Ok(self.sessions.lock().unwrap().clone()) + } + async fn get_session(&self, id: &str) -> Result, DbError> { + let sessions = self.sessions.lock().unwrap(); + Ok(sessions.iter().find(|s| s.id == id).cloned()) + } + async fn get_or_create_session( + &self, + user_id: &str, + chat_id: &str, + new_row: &AssistantSessionRow, + ) -> Result { + let mut sessions = self.sessions.lock().unwrap(); + if let Some(existing) = sessions + .iter_mut() + .find(|s| s.user_id == user_id && s.chat_id.as_deref() == Some(chat_id)) + { + existing.last_activity = new_row.last_activity; + return Ok(existing.clone()); + } + sessions.push(new_row.clone()); + Ok(new_row.clone()) + } + async fn update_session_activity(&self, _id: &str, _last_activity: TimestampMs) -> Result<(), DbError> { + Ok(()) + } + async fn update_session_conversation(&self, id: &str, conversation_id: &str) -> Result<(), DbError> { + let mut sessions = self.sessions.lock().unwrap(); + if let Some(s) = sessions.iter_mut().find(|s| s.id == id) { + s.conversation_id = Some(conversation_id.to_owned()); + Ok(()) + } else { + Err(DbError::NotFound(id.into())) + } + } + async fn update_session_agent_type(&self, id: &str, agent_type: &str) -> Result<(), DbError> { + let mut sessions = self.sessions.lock().unwrap(); + if let Some(s) = sessions.iter_mut().find(|s| s.id == id) { + s.agent_type = agent_type.to_owned(); + Ok(()) + } else { + Err(DbError::NotFound(id.into())) + } + } + async fn delete_sessions_by_user(&self, user_id: &str) -> Result<(), DbError> { + self.sessions.lock().unwrap().retain(|s| s.user_id != user_id); + Ok(()) + } + async fn delete_session_by_user_chat(&self, user_id: &str, chat_id: &str) -> Result<(), DbError> { + let mut sessions = self.sessions.lock().unwrap(); + sessions.retain(|s| !(s.user_id == user_id && s.chat_id.as_deref() == Some(chat_id))); + Ok(()) + } + + async fn create_pairing(&self, row: &PairingCodeRow) -> Result<(), DbError> { + self.pairings.lock().unwrap().push(row.clone()); + Ok(()) + } + async fn get_pending_pairings(&self) -> Result, DbError> { + let pairings = self.pairings.lock().unwrap(); + Ok(pairings.iter().filter(|p| p.status == "pending").cloned().collect()) + } + async fn get_pairing_by_code(&self, code: &str) -> Result, DbError> { + let pairings = self.pairings.lock().unwrap(); + Ok(pairings.iter().find(|p| p.code == code).cloned()) + } + async fn update_pairing_status(&self, code: &str, status: &str) -> Result<(), DbError> { + let mut pairings = self.pairings.lock().unwrap(); + if let Some(p) = pairings.iter_mut().find(|p| p.code == code) { + p.status = status.to_owned(); + Ok(()) + } else { + Err(DbError::NotFound(code.into())) + } + } + async fn cleanup_expired_pairings(&self, _now: TimestampMs) -> Result { + Ok(0) + } + } + + // ── Mock IClientPreferenceRepository ────────────────────────────── + + struct MockPrefRepo; + + #[async_trait::async_trait] + impl IClientPreferenceRepository for MockPrefRepo { + async fn get_all(&self) -> Result, DbError> { + Ok(vec![]) + } + async fn get_by_keys(&self, _keys: &[&str]) -> Result, DbError> { + Ok(vec![]) + } + async fn upsert_batch(&self, _entries: &[(&str, &str)]) -> Result<(), DbError> { + Ok(()) + } + async fn delete_keys(&self, _keys: &[&str]) -> Result<(), DbError> { + Ok(()) + } + } + + struct StaticPrefRepo { + prefs: Mutex>, + } + + impl StaticPrefRepo { + fn new(prefs: HashMap) -> Self { + Self { + prefs: Mutex::new(prefs), + } + } + + fn get(&self, key: &str) -> Option { + self.prefs.lock().unwrap().get(key).cloned() + } + } + + #[async_trait::async_trait] + impl IClientPreferenceRepository for StaticPrefRepo { + async fn get_all(&self) -> Result, DbError> { + Ok(self + .prefs + .lock() + .unwrap() + .iter() + .map(|(key, value)| ClientPreference { + key: key.clone(), + value: value.clone(), + updated_at: now_ms(), + }) + .collect()) + } + async fn get_by_keys(&self, keys: &[&str]) -> Result, DbError> { + Ok(keys + .iter() + .filter_map(|key| { + self.prefs.lock().unwrap().get(*key).map(|value| ClientPreference { + key: (*key).to_owned(), + value: value.clone(), + updated_at: now_ms(), + }) + }) + .collect()) + } + async fn upsert_batch(&self, entries: &[(&str, &str)]) -> Result<(), DbError> { + let mut prefs = self.prefs.lock().unwrap(); + for (key, value) in entries { + prefs.insert((*key).to_owned(), (*value).to_owned()); + } + Ok(()) + } + async fn delete_keys(&self, keys: &[&str]) -> Result<(), DbError> { + let mut prefs = self.prefs.lock().unwrap(); + for key in keys { + prefs.remove(*key); + } + Ok(()) + } + } + + #[derive(Default)] + struct MockAgentMetadataRepo { + rows: Mutex>, + } + + impl MockAgentMetadataRepo { + fn with_rows(rows: Vec) -> Self { + Self { rows: Mutex::new(rows) } + } + } + + #[derive(Default)] + struct MockProviderRepo { + rows: Mutex>, + } + + impl MockProviderRepo { + fn with_rows(rows: Vec) -> Self { + Self { rows: Mutex::new(rows) } + } + } + + #[async_trait::async_trait] + impl IProviderRepository for MockProviderRepo { + async fn list(&self) -> Result, DbError> { + Ok(self.rows.lock().unwrap().clone()) + } + + async fn find_by_id(&self, id: &str) -> Result, DbError> { + Ok(self.rows.lock().unwrap().iter().find(|row| row.id == id).cloned()) + } + + async fn create(&self, _params: CreateProviderParams<'_>) -> Result { + unimplemented!("not needed in channel action tests") + } + + async fn update(&self, _id: &str, _params: UpdateProviderParams<'_>) -> Result { + unimplemented!("not needed in channel action tests") + } + + async fn delete(&self, _id: &str) -> Result<(), DbError> { + unimplemented!("not needed in channel action tests") + } + } + + #[async_trait::async_trait] + impl IAgentMetadataRepository for MockAgentMetadataRepo { + async fn list_all(&self) -> Result, DbError> { + Ok(self.rows.lock().unwrap().clone()) + } + + async fn get(&self, id: &str) -> Result, DbError> { + Ok(self.rows.lock().unwrap().iter().find(|row| row.id == id).cloned()) + } + + async fn find_by_source_and_name( + &self, + agent_source: &str, + name: &str, + ) -> Result, DbError> { + Ok(self + .rows + .lock() + .unwrap() + .iter() + .find(|row| row.agent_source == agent_source && row.name == name) + .cloned()) + } + + async fn find_builtin_by_backend(&self, backend: &str) -> Result, DbError> { + Ok(self + .rows + .lock() + .unwrap() + .iter() + .find(|row| row.agent_source == "builtin" && row.backend.as_deref() == Some(backend)) + .cloned()) + } + + async fn upsert(&self, _params: &UpsertAgentMetadataParams<'_>) -> Result { + Err(DbError::NotFound("unused mock upsert".into())) + } + + async fn apply_handshake( + &self, + _id: &str, + _params: &UpdateAgentHandshakeParams<'_>, + ) -> Result, DbError> { + Ok(None) + } + + async fn update_availability_snapshot( + &self, + _id: &str, + _params: &UpdateAgentAvailabilitySnapshotParams<'_>, + ) -> Result, DbError> { + Ok(None) + } + + async fn update_agent_overrides( + &self, + _id: &str, + _command_override: Option<&str>, + _env_override: Option<&str>, + ) -> Result<(), DbError> { + Ok(()) + } + + async fn set_enabled(&self, _id: &str, _enabled: bool) -> Result { + Ok(false) + } + + async fn delete(&self, _id: &str) -> Result { + Ok(false) + } + } + + #[derive(Default)] + struct MockTeamDirectory { + teams: Mutex>, + created: Mutex>, + ensured: Mutex>, + } + + impl MockTeamDirectory { + fn with_teams(teams: Vec) -> Self { + Self { + teams: Mutex::new(teams), + ..Default::default() + } + } + } + + #[async_trait::async_trait] + impl ChannelTeamDirectory for MockTeamDirectory { + async fn list_teams(&self, _user_id: &str) -> Result, ChannelError> { + Ok(self.teams.lock().unwrap().clone()) + } + + async fn get_team(&self, _user_id: &str, _team_id: &str) -> Result, ChannelError> { + Ok(self + .teams + .lock() + .unwrap() + .iter() + .find(|team| team.id == _team_id) + .cloned()) + } + + async fn ensure_team_session(&self, _user_id: &str, team_id: &str) -> Result<(), ChannelError> { + self.ensured.lock().unwrap().push(team_id.to_owned()); + Ok(()) + } + + async fn create_team( + &self, + _user_id: &str, + request: ChannelTeamCreateRequest, + ) -> Result { + self.created.lock().unwrap().push(request.clone()); + Ok(ChannelTeamSummary { + id: "team-created-1".into(), + name: request.name, + lead_conversation_id: Some("lead-conv-1".into()), + agent_count: 1, + }) + } + } + + #[derive(Default)] + struct MockPersonalDirectory { + conversations: Mutex>, + } + + impl MockPersonalDirectory { + fn with_conversations(conversations: Vec) -> Self { + Self { + conversations: Mutex::new(conversations), + } + } + } + + #[async_trait::async_trait] + impl ChannelPersonalDirectory for MockPersonalDirectory { + async fn list_personal_conversations( + &self, + _user_id: &str, + _platform: PluginType, + _chat_id: &str, + ) -> Result, ChannelError> { + Ok(self.conversations.lock().unwrap().clone()) + } + + async fn get_personal_conversation( + &self, + _user_id: &str, + _platform: PluginType, + _chat_id: &str, + conversation_id: &str, + ) -> Result, ChannelError> { + Ok(self + .conversations + .lock() + .unwrap() + .iter() + .find(|conversation| conversation.id == conversation_id) + .cloned()) + } + + async fn rename_personal_conversation( + &self, + _user_id: &str, + _platform: PluginType, + _chat_id: &str, + conversation_id: &str, + title: &str, + ) -> Result, ChannelError> { + let mut conversations = self.conversations.lock().unwrap(); + let Some(conversation) = conversations + .iter_mut() + .find(|conversation| conversation.id == conversation_id) + else { + return Ok(None); + }; + conversation.name = title.to_owned(); + Ok(Some(conversation.clone())) + } + } + + // ── Test helpers ─────────────────────────────────────────────────── + + fn setup() -> (ActionExecutor, Arc) { + let repo = Arc::new(MockRepo::new()); + let broadcaster = Arc::new(MockBroadcaster); + let pairing = Arc::new(PairingService::new(repo.clone(), broadcaster)); + let session_mgr = Arc::new(SessionManager::new(repo.clone())); + let pref_repo: Arc = Arc::new(MockPrefRepo); + let settings = Arc::new(ChannelSettingsService::new(pref_repo)); + let executor = ActionExecutor::new(pairing, session_mgr, settings); + (executor, repo) + } + + fn setup_with_team_directory( + team_directory: Arc, + ) -> (ActionExecutor, Arc, Arc) { + let repo = Arc::new(MockRepo::new()); + let broadcaster = Arc::new(MockBroadcaster); + let pairing = Arc::new(PairingService::new(repo.clone(), broadcaster)); + let session_mgr = Arc::new(SessionManager::new(repo.clone())); + let mut prefs = HashMap::new(); + prefs.insert( + "assistant.telegram.agent".to_owned(), + r#"{"assistant_id":"assistant-telegram-lead","name":"Telegram Lead"}"#.to_owned(), + ); + let pref_repo: Arc = Arc::new(StaticPrefRepo::new(prefs)); + let settings = Arc::new(ChannelSettingsService::new(pref_repo)); + let executor = ActionExecutor::new(pairing, session_mgr, settings).with_team_directory(team_directory.clone()); + (executor, repo, team_directory) + } + + fn setup_with_agent_rows( + rows: Vec, + prefs: HashMap, + ) -> (ActionExecutor, Arc, Arc) { + let repo = Arc::new(MockRepo::new()); + let broadcaster = Arc::new(MockBroadcaster); + let pairing = Arc::new(PairingService::new(repo.clone(), broadcaster)); + let session_mgr = Arc::new(SessionManager::new(repo.clone())); + let pref_repo = Arc::new(StaticPrefRepo::new(prefs)); + let agent_repo: Arc = Arc::new(MockAgentMetadataRepo::with_rows(rows)); + let settings = Arc::new(ChannelSettingsService::new(pref_repo.clone()).with_agent_metadata_repo(agent_repo)); + let executor = ActionExecutor::new(pairing, session_mgr, settings); + (executor, repo, pref_repo) + } + + fn setup_with_agent_rows_and_providers( + rows: Vec, + providers: Vec, + prefs: HashMap, + ) -> (ActionExecutor, Arc, Arc) { + let repo = Arc::new(MockRepo::new()); + let broadcaster: Arc = Arc::new(MockBroadcaster); + let pairing = Arc::new(PairingService::new(repo.clone(), broadcaster)); + let session_mgr = Arc::new(SessionManager::new(repo.clone())); + let pref_repo = Arc::new(StaticPrefRepo::new(prefs)); + let agent_repo: Arc = Arc::new(MockAgentMetadataRepo::with_rows(rows)); + let provider_repo: Arc = Arc::new(MockProviderRepo::with_rows(providers)); + let settings = Arc::new( + ChannelSettingsService::new(pref_repo.clone()) + .with_agent_metadata_repo(agent_repo) + .with_provider_repo(provider_repo), + ); + let executor = ActionExecutor::new(pairing, session_mgr, settings); + (executor, repo, pref_repo) + } + + fn setup_with_personal_directory( + personal_directory: Arc, + ) -> (ActionExecutor, Arc, Arc) { + let (executor, repo) = setup(); + let executor = executor.with_personal_directory(personal_directory.clone()); + (executor, repo, personal_directory) + } + + #[allow(clippy::too_many_arguments)] + fn make_agent_row( + id: &str, + name: &str, + agent_type: &str, + backend: Option<&str>, + enabled: bool, + last_check_status: Option<&str>, + available_models: Option<&str>, + sort_order: i64, + ) -> AgentMetadataRow { + let dynamic_probe_result = if agent_type == "acp" { + available_models.and_then(test_dynamic_probe_from_models) + } else { + None + }; + AgentMetadataRow { + id: id.into(), + icon: None, + name: name.into(), + name_i18n: None, + description: None, + description_i18n: None, + backend: backend.map(str::to_owned), + agent_type: agent_type.into(), + agent_source: if agent_type == "aionrs" { + "internal".into() + } else { + "builtin".into() + }, + agent_source_info: None, + enabled, + command: Some(name.to_ascii_lowercase()), + args: None, + env: None, + native_skills_dirs: None, + behavior_policy: None, + yolo_id: None, + agent_capabilities: None, + auth_methods: None, + config_options: None, + available_modes: None, + available_models: available_models.map(str::to_owned), + available_commands: None, + sort_order, + last_check_status: last_check_status.map(str::to_owned), + last_check_kind: None, + last_check_error_code: None, + last_check_error_message: None, + last_check_guidance: None, + last_check_latency_ms: None, + last_check_at: None, + last_success_at: last_check_status.map(|_| now_ms()), + last_failure_at: None, + dynamic_probe_result, + command_override: None, + env_override: None, + created_at: now_ms(), + updated_at: now_ms(), + } + } + + fn test_dynamic_probe_from_models(raw: &str) -> Option { + use aionui_api_types::{AgentDynamicProbeResult, AgentProbeStatus, AgentProbeStep, AgentProbeStepResult}; + + let value: serde_json::Value = serde_json::from_str(raw).ok()?; + let entries = value + .get("available_models") + .and_then(serde_json::Value::as_array) + .or_else(|| value.as_array())?; + let models = entries + .iter() + .filter_map(|entry| { + entry + .as_str() + .or_else(|| entry.get("id").and_then(serde_json::Value::as_str)) + }) + .map(str::to_owned) + .collect::>(); + let checked_at = now_ms(); + serde_json::to_string(&AgentDynamicProbeResult { + agent_id: "fixture-agent".into(), + checked_at, + available_models: models, + steps: [ + AgentProbeStep::Spawn, + AgentProbeStep::Initialize, + AgentProbeStep::Models, + AgentProbeStep::MinimalPrompt, + AgentProbeStep::Cancel, + ] + .into_iter() + .map(|step| AgentProbeStepResult { + step, + status: AgentProbeStatus::Passed, + started_at: checked_at, + duration_ms: 1, + error_category: None, + error_message: None, + }) + .collect(), + }) + .ok() + } + + fn make_provider(id: &str, name: &str, models: &str) -> Provider { + Provider { + id: id.into(), + platform: "custom".into(), + name: name.into(), + base_url: "https://example.test/v1".into(), + api_key_encrypted: "encrypted".into(), + models: models.into(), + enabled: true, + capabilities: "[]".into(), + context_limit: None, + model_protocols: None, + model_enabled: None, + model_health: None, + model_settings: "{}".into(), + bedrock_config: None, + is_full_url: false, + created_at: now_ms(), + updated_at: now_ms(), + } + } + + fn make_text_message(user_id: &str, chat_id: &str, text: &str, platform: PluginType) -> UnifiedIncomingMessage { + UnifiedIncomingMessage { + id: "msg_1".into(), + platform, + chat_id: chat_id.into(), + user: UnifiedUser { + id: user_id.into(), + username: None, + display_name: "Test".into(), + avatar_url: None, + }, + content: UnifiedMessageContent { + content_type: MessageContentType::Text, + text: text.into(), + attachments: None, + }, + timestamp: now_ms(), + topic: None, + reply_to_message_id: None, + action: None, + raw: None, + } + } + + fn make_command_message(user_id: &str, chat_id: &str, text: &str, platform: PluginType) -> UnifiedIncomingMessage { + let mut msg = make_text_message(user_id, chat_id, text, platform); + msg.content.content_type = MessageContentType::Command; + msg + } + + fn make_action_message( + user_id: &str, + chat_id: &str, + action_name: &str, + category: ActionCategory, + platform: PluginType, + params: Option>, + ) -> UnifiedIncomingMessage { + UnifiedIncomingMessage { + id: "msg_1".into(), + platform, + chat_id: chat_id.into(), + user: UnifiedUser { + id: user_id.into(), + username: None, + display_name: "Test".into(), + avatar_url: None, + }, + content: UnifiedMessageContent { + content_type: MessageContentType::Action, + text: String::new(), + attachments: None, + }, + timestamp: now_ms(), + topic: None, + reply_to_message_id: None, + action: Some(UnifiedAction { + action: action_name.into(), + category, + params, + context: ActionContext { + platform, + user_id: user_id.into(), + chat_id: chat_id.into(), + message_id: None, + session_id: None, + }, + }), + raw: None, + } + } + + // ── Authorization tests ──────────────────────────────────────────── + + #[tokio::test] + async fn unauthorized_user_gets_pairing_response() { + let (executor, _repo) = setup(); + let msg = make_text_message("tg_42", "chat_1", "Hello", PluginType::Telegram); + + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(resp) => { + assert_eq!(resp.behavior, ActionBehavior::Send); + let text = resp.text.unwrap(); + assert!(text.contains("pairing code")); + assert!(resp.buttons.is_some()); + } + _ => panic!("Expected Action result for unauthorized user"), + } + } + + #[tokio::test] + async fn authorized_user_text_dispatches_to_agent() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + + let msg = make_text_message("tg_42", "chat_1", "Hello AI", PluginType::Telegram); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + + match result { + MessageResult::Dispatched { session_id, .. } => { + assert!(!session_id.is_empty()); + } + _ => panic!("Expected Dispatched result for authorized user"), + } + } + + // ── Platform action tests ────────────────────────────────────────── + + #[tokio::test] + async fn pairing_show_generates_code() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + + let msg = make_action_message( + "tg_42", + "chat_1", + "pairing.show", + ActionCategory::Platform, + PluginType::Telegram, + None, + ); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + + match result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("pairing code")); + } + _ => panic!("Expected Action result"), + } + } + + #[tokio::test] + async fn pairing_check_authorized() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + + let msg = make_action_message( + "tg_42", + "chat_1", + "pairing.check", + ActionCategory::Platform, + PluginType::Telegram, + None, + ); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + + match result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("authorized")); + } + _ => panic!("Expected Action result"), + } + } + + #[tokio::test] + async fn pairing_check_not_authorized() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + + let msg = make_action_message( + "tg_99", // different user + "chat_1", + "pairing.check", + ActionCategory::Platform, + PluginType::Telegram, + None, + ); + // tg_99 is not authorized, but the action itself needs the user to be authorized + // first (it's routed via handle_incoming_message which checks auth first) + // So for this test, authorize tg_99 too + repo.add_authorized_user("tg_99", "telegram"); + + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + // tg_99 is authorized + assert!(text.contains("authorized")); + } + _ => panic!("Expected Action result"), + } + } + + #[tokio::test] + async fn pairing_help_returns_instructions() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + + let msg = make_action_message( + "tg_42", + "chat_1", + "pairing.help", + ActionCategory::Platform, + PluginType::Telegram, + None, + ); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("authorization")); + } + _ => panic!("Expected Action result"), + } + } + + // ── System action tests ──────────────────────────────────────────── + + #[tokio::test] + async fn session_new_creates_session() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + + let msg = make_action_message( + "tg_42", + "chat_1", + "session.new", + ActionCategory::System, + PluginType::Telegram, + None, + ); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("New session")); + // With no client_preferences configured, defaults to "aionrs" + assert!(text.contains("aionrs")); + } + _ => panic!("Expected Action result"), + } + } + + #[tokio::test] + async fn session_new_resets_existing_session() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + + // First: send a text message to create a session + let text_msg = make_text_message("tg_42", "chat_1", "Hello", PluginType::Telegram); + let r1 = executor.handle_incoming_message(&text_msg).await.unwrap(); + let sid1 = match r1 { + MessageResult::Dispatched { session_id, .. } => session_id, + _ => panic!("Expected Dispatched"), + }; + + // Then: session.new should delete old + create fresh + let new_msg = make_action_message( + "tg_42", + "chat_1", + "session.new", + ActionCategory::System, + PluginType::Telegram, + None, + ); + let r2 = executor.handle_incoming_message(&new_msg).await.unwrap(); + match r2 { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("New session")); + } + _ => panic!("Expected Action result"), + } + + // Send another text message — the session ID should differ + let text_msg2 = make_text_message("tg_42", "chat_1", "Again", PluginType::Telegram); + let r3 = executor.handle_incoming_message(&text_msg2).await.unwrap(); + let sid3 = match r3 { + MessageResult::Dispatched { session_id, .. } => session_id, + _ => panic!("Expected Dispatched"), + }; + // New session has different full ID (reset deleted the old one) + assert_ne!(sid1, sid3); + + // Only 1 session should exist for this user+chat + let sessions = repo.sessions.lock().unwrap(); + let user_chat_sessions: Vec<_> = sessions + .iter() + .filter(|s| s.user_id == "user_tg_42" && s.chat_id.as_deref() == Some("chat_1")) + .collect(); + assert_eq!(user_chat_sessions.len(), 1); + } + + #[tokio::test] + async fn session_status_shows_info() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + + let msg = make_action_message( + "tg_42", + "chat_1", + "session.status", + ActionCategory::System, + PluginType::Telegram, + None, + ); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("Session:")); + assert!(text.contains("Agent:")); + } + _ => panic!("Expected Action result"), + } + } + + #[tokio::test] + async fn help_show_returns_menu() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + + let msg = make_action_message( + "tg_42", + "chat_1", + "help.show", + ActionCategory::System, + PluginType::Telegram, + None, + ); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(resp) => { + assert!(resp.text.is_some()); + assert!(resp.buttons.is_some()); + let buttons = resp.buttons.unwrap(); + assert!(buttons.len() >= 2); // at least 2 rows + assert!( + !buttons.iter().flatten().any(|button| button.action == "agent.show"), + "help menu must not expose direct agent selection" + ); + } + _ => panic!("Expected Action result"), + } + } + + #[tokio::test] + async fn slash_help_returns_telegram_command_menu() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + + let msg = make_command_message("tg_42", "chat_1", "/help", PluginType::Telegram); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("/status"), "got: {text}"); + assert!(text.contains("/team_new"), "got: {text}"); + assert!(text.contains("/team_help"), "got: {text}"); + assert!(!text.contains("/new_team_session"), "got: {text}"); + let actions: Vec<_> = resp + .buttons + .expect("General help should expose contextual operation buttons") + .into_iter() + .flatten() + .map(|button| button.action) + .collect(); + assert!(actions.contains(&"agent.list".to_owned())); + assert!(actions.contains(&"personal.list".to_owned())); + assert!(actions.contains(&"team.list".to_owned())); + assert!(actions.contains(&"team.new.start".to_owned())); + assert!(actions.contains(&"team.help".to_owned())); + } + _ => panic!("Expected Action result"), + } + } + + #[tokio::test] + async fn general_help_team_list_button_routes_to_team_directory() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + let msg = make_action_message( + "tg_42", + "chat_1", + "team.list", + ActionCategory::System, + PluginType::Telegram, + None, + ); + + let MessageResult::Action(resp) = executor.handle_incoming_message(&msg).await.unwrap() else { + panic!("Expected Action result"); + }; + assert!(resp.text.unwrap().contains("Team 查询服务")); + } + + #[tokio::test] + async fn general_help_team_new_button_starts_creation_flow() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + let msg = make_action_message( + "tg_42", + "chat_1", + "team.new.start", + ActionCategory::System, + PluginType::Telegram, + None, + ); + + let MessageResult::Action(resp) = executor.handle_incoming_message(&msg).await.unwrap() else { + panic!("Expected Action result"); + }; + assert!(resp.text.unwrap().contains("Team 创建服务")); + } + + #[tokio::test] + async fn general_help_personal_list_button_routes_to_personal_directory() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + let msg = make_action_message( + "tg_42", + "chat_1", + "personal.list", + ActionCategory::System, + PluginType::Telegram, + None, + ); + + let MessageResult::Action(resp) = executor.handle_incoming_message(&msg).await.unwrap() else { + panic!("Expected Action result"); + }; + assert!(resp.text.unwrap().contains("个人会话列表服务")); + } + + #[tokio::test] + async fn general_help_team_help_button_returns_team_help() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + let msg = make_action_message( + "tg_42", + "chat_1", + "team.help", + ActionCategory::System, + PluginType::Telegram, + None, + ); + + let MessageResult::Action(resp) = executor.handle_incoming_message(&msg).await.unwrap() else { + panic!("Expected Action result"); + }; + assert!(resp.text.unwrap().contains("Telegram Team 功能说明")); + } + + #[tokio::test] + async fn slash_new_team_session_is_not_a_supported_command() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + + let msg = make_command_message("tg_42", "chat_1", "/new_team_session", PluginType::Telegram); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("未知命令"), "got: {text}"); } + _ => panic!("Expected Action result"), } - async fn update_session_agent_type(&self, id: &str, agent_type: &str) -> Result<(), DbError> { - let mut sessions = self.sessions.lock().unwrap(); - if let Some(s) = sessions.iter_mut().find(|s| s.id == id) { - s.agent_type = agent_type.to_owned(); - Ok(()) - } else { - Err(DbError::NotFound(id.into())) + } + + #[tokio::test] + async fn slash_status_shows_current_binding() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + + let msg = make_command_message("tg_42", "chat_1", "/status", PluginType::Telegram); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("当前 Telegram 绑定"), "got: {text}"); + assert!(text.contains("Session"), "got: {text}"); } + _ => panic!("Expected Action result"), } - async fn delete_sessions_by_user(&self, user_id: &str) -> Result<(), DbError> { - self.sessions.lock().unwrap().retain(|s| s.user_id != user_id); - Ok(()) - } - async fn delete_session_by_user_chat(&self, user_id: &str, chat_id: &str) -> Result<(), DbError> { - let mut sessions = self.sessions.lock().unwrap(); - sessions.retain(|s| !(s.user_id == user_id && s.chat_id.as_deref() == Some(chat_id))); - Ok(()) - } + } - async fn create_pairing(&self, row: &PairingCodeRow) -> Result<(), DbError> { - self.pairings.lock().unwrap().push(row.clone()); - Ok(()) - } - async fn get_pending_pairings(&self) -> Result, DbError> { - let pairings = self.pairings.lock().unwrap(); - Ok(pairings.iter().filter(|p| p.status == "pending").cloned().collect()) - } - async fn get_pairing_by_code(&self, code: &str) -> Result, DbError> { - let pairings = self.pairings.lock().unwrap(); - Ok(pairings.iter().find(|p| p.code == code).cloned()) - } - async fn update_pairing_status(&self, code: &str, status: &str) -> Result<(), DbError> { - let mut pairings = self.pairings.lock().unwrap(); - if let Some(p) = pairings.iter_mut().find(|p| p.code == code) { - p.status = status.to_owned(); - Ok(()) - } else { - Err(DbError::NotFound(code.into())) + #[tokio::test] + async fn slash_team_new_creates_real_team_and_binds_session() { + let team_directory = Arc::new(MockTeamDirectory::default()); + let (executor, repo, team_directory) = setup_with_team_directory(team_directory); + repo.add_authorized_user("tg_42", "telegram"); + + let msg = make_command_message("tg_42", "chat_1", "/team_new BTC 4H Strategy", PluginType::Telegram); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("Team 已创建并切换"), "got: {text}"); + assert!(text.contains("BTC 4H Strategy"), "got: {text}"); + assert!(text.contains("lead-conv-1"), "got: {text}"); + assert!(resp.buttons.is_none()); } + _ => panic!("Expected Action result"), } - async fn cleanup_expired_pairings(&self, _now: TimestampMs) -> Result { - Ok(0) + + { + let created = team_directory.created.lock().unwrap(); + assert_eq!(created.len(), 1); + assert_eq!(created[0].name, "BTC 4H Strategy"); + assert_eq!(created[0].assistant_id, "assistant-telegram-lead"); + assert_eq!(created[0].lead_name, "Telegram Lead"); } + + assert_eq!(team_directory.ensured.lock().unwrap().as_slice(), ["team-created-1"]); + let sessions = repo.get_all_sessions().await.unwrap(); + assert_eq!(sessions.len(), 1); + assert_eq!(sessions[0].conversation_id.as_deref(), Some("lead-conv-1")); } - // ── Mock IClientPreferenceRepository ────────────────────────────── + #[tokio::test] + async fn slash_team_select_without_selector_returns_inline_team_buttons() { + let team_directory = Arc::new(MockTeamDirectory::with_teams(vec![ + ChannelTeamSummary { + id: "team-1".into(), + name: "BTC Strategy".into(), + lead_conversation_id: Some("lead-1".into()), + agent_count: 3, + }, + ChannelTeamSummary { + id: "team-2".into(), + name: "ETH Research".into(), + lead_conversation_id: Some("lead-2".into()), + agent_count: 2, + }, + ])); + let (executor, repo, _team_directory) = setup_with_team_directory(team_directory); + repo.add_authorized_user("tg_42", "telegram"); - struct MockPrefRepo; + let msg = make_command_message("tg_42", "chat_1", "/team_select", PluginType::Telegram); + let result = executor.handle_incoming_message(&msg).await.unwrap(); - #[async_trait::async_trait] - impl IClientPreferenceRepository for MockPrefRepo { - async fn get_all(&self) -> Result, DbError> { - Ok(vec![]) - } - async fn get_by_keys(&self, _keys: &[&str]) -> Result, DbError> { - Ok(vec![]) - } - async fn upsert_batch(&self, _entries: &[(&str, &str)]) -> Result<(), DbError> { - Ok(()) - } - async fn delete_keys(&self, _keys: &[&str]) -> Result<(), DbError> { - Ok(()) + match result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("请选择要切换的 Team"), "got: {text}"); + let buttons = resp.buttons.expect("team_select should return inline buttons"); + assert_eq!(buttons[0][0].label, "BTC Strategy"); + assert_eq!(buttons[0][0].action, "team.select"); + assert_eq!( + buttons[0][0].params.as_ref().unwrap().get("id").map(String::as_str), + Some("team-1") + ); + } + _ => panic!("Expected Action result"), } } - // ── Test helpers ─────────────────────────────────────────────────── + #[tokio::test] + async fn team_select_button_binds_the_selected_team() { + let team_directory = Arc::new(MockTeamDirectory::with_teams(vec![ChannelTeamSummary { + id: "team-1".into(), + name: "BTC Strategy".into(), + lead_conversation_id: Some("lead-1".into()), + agent_count: 3, + }])); + let (executor, repo, team_directory) = setup_with_team_directory(team_directory); + repo.add_authorized_user("tg_42", "telegram"); - fn setup() -> (ActionExecutor, Arc) { - let repo = Arc::new(MockRepo::new()); - let broadcaster = Arc::new(MockBroadcaster); - let pairing = Arc::new(PairingService::new(repo.clone(), broadcaster)); - let session_mgr = Arc::new(SessionManager::new(repo.clone())); - let pref_repo: Arc = Arc::new(MockPrefRepo); - let settings = Arc::new(ChannelSettingsService::new(pref_repo)); - let executor = ActionExecutor::new(pairing, session_mgr, settings); - (executor, repo) - } + let params = HashMap::from([("id".into(), "team-1".into())]); + let msg = make_action_message( + "tg_42", + "chat_1", + "team.select", + ActionCategory::System, + PluginType::Telegram, + Some(params), + ); + let result = executor.handle_incoming_message(&msg).await.unwrap(); - fn make_text_message(user_id: &str, chat_id: &str, text: &str, platform: PluginType) -> UnifiedIncomingMessage { - UnifiedIncomingMessage { - id: "msg_1".into(), - platform, - chat_id: chat_id.into(), - user: UnifiedUser { - id: user_id.into(), - username: None, - display_name: "Test".into(), - avatar_url: None, - }, - content: UnifiedMessageContent { - content_type: MessageContentType::Text, - text: text.into(), - attachments: None, - }, - timestamp: now_ms(), - reply_to_message_id: None, - action: None, - raw: None, + match result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("已切换到 Team 会话"), "got: {text}"); + assert!(text.contains("BTC Strategy"), "got: {text}"); + } + _ => panic!("Expected Action result"), } + + assert_eq!(team_directory.ensured.lock().unwrap().as_slice(), ["team-1"]); + let sessions = repo.get_all_sessions().await.unwrap(); + assert_eq!(sessions[0].conversation_id.as_deref(), Some("lead-1")); } - fn make_action_message( - user_id: &str, - chat_id: &str, - action_name: &str, - category: ActionCategory, - platform: PluginType, - params: Option>, - ) -> UnifiedIncomingMessage { - UnifiedIncomingMessage { - id: "msg_1".into(), - platform, - chat_id: chat_id.into(), - user: UnifiedUser { - id: user_id.into(), - username: None, - display_name: "Test".into(), - avatar_url: None, - }, - content: UnifiedMessageContent { - content_type: MessageContentType::Action, - text: String::new(), - attachments: None, - }, - timestamp: now_ms(), - reply_to_message_id: None, - action: Some(UnifiedAction { - action: action_name.into(), - category, - params, - context: ActionContext { - platform, - user_id: user_id.into(), - chat_id: chat_id.into(), - message_id: None, - session_id: None, - }, - }), - raw: None, + #[tokio::test] + async fn slash_team_new_without_topic_starts_reply_driven_creation_flow() { + let team_directory = Arc::new(MockTeamDirectory::default()); + let (executor, repo, team_directory) = setup_with_team_directory(team_directory); + repo.add_authorized_user("tg_42", "telegram"); + + let start = make_command_message("tg_42", "chat_1", "/team_new", PluginType::Telegram); + let start_result = executor.handle_incoming_message(&start).await.unwrap(); + match start_result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("请直接回复团队名称"), "got: {text}"); + assert_eq!(resp.buttons.unwrap()[0][0].action, "team.new.cancel"); + } + _ => panic!("Expected Action result"), + } + + let name = make_text_message("tg_42", "chat_1", "BTC 4H Button Flow", PluginType::Telegram); + let name_result = executor.handle_incoming_message(&name).await.unwrap(); + match name_result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("准备创建 Team"), "got: {text}"); + assert!(text.contains("BTC 4H Button Flow"), "got: {text}"); + let buttons = resp.buttons.unwrap(); + assert_eq!(buttons[0][0].action, "team.new.create"); + assert_eq!(buttons[0][1].action, "team.new.cancel"); + } + _ => panic!("Expected Action result"), + } + + let create = make_action_message( + "tg_42", + "chat_1", + "team.new.create", + ActionCategory::System, + PluginType::Telegram, + None, + ); + let create_result = executor.handle_incoming_message(&create).await.unwrap(); + match create_result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("Team 已创建并切换"), "got: {text}"); + assert!(text.contains("BTC 4H Button Flow"), "got: {text}"); + } + _ => panic!("Expected Action result"), } + + assert_eq!(team_directory.created.lock().unwrap()[0].name, "BTC 4H Button Flow"); } - // ── Authorization tests ──────────────────────────────────────────── + #[test] + fn team_new_normalizes_generated_agent_id_for_team_assistant() { + assert_eq!(normalize_team_assistant_id("8e1acf31"), "bare:8e1acf31"); + assert_eq!(normalize_team_assistant_id(" 8E1ACF31 "), "bare:8E1ACF31"); + assert_eq!(normalize_team_assistant_id("cowork"), "cowork"); + assert_eq!( + normalize_team_assistant_id("custom-1782376459103-3673"), + "custom-1782376459103-3673" + ); + assert_eq!(normalize_team_assistant_id("bare:8e1acf31"), "bare:8e1acf31"); + } #[tokio::test] - async fn unauthorized_user_gets_pairing_response() { - let (executor, _repo) = setup(); - let msg = make_text_message("tg_42", "chat_1", "Hello", PluginType::Telegram); + async fn agent_show_is_treated_as_unknown_action() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + let msg = make_action_message( + "tg_42", + "chat_1", + "agent.show", + ActionCategory::System, + PluginType::Telegram, + None, + ); let result = executor.handle_incoming_message(&msg).await.unwrap(); match result { MessageResult::Action(resp) => { - assert_eq!(resp.behavior, ActionBehavior::Send); let text = resp.text.unwrap(); - assert!(text.contains("pairing code")); - assert!(resp.buttons.is_some()); + assert!(text.contains("Unknown action")); + assert!(text.contains("agent.show")); } - _ => panic!("Expected Action result for unauthorized user"), + _ => panic!("Expected Action result"), } } #[tokio::test] - async fn authorized_user_text_dispatches_to_agent() { + async fn agent_select_without_assistant_id_returns_clear_error() { let (executor, repo) = setup(); repo.add_authorized_user("tg_42", "telegram"); - let msg = make_text_message("tg_42", "chat_1", "Hello AI", PluginType::Telegram); - let result = executor.handle_incoming_message(&msg).await.unwrap(); - + let params = HashMap::from([("agentType".into(), "acp".into())]); + let select_msg = make_action_message( + "tg_42", + "chat_1", + "agent.select", + ActionCategory::System, + PluginType::Telegram, + Some(params), + ); + let result = executor.handle_incoming_message(&select_msg).await.unwrap(); match result { - MessageResult::Dispatched { session_id, .. } => { - assert!(!session_id.is_empty()); + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("缺少 agentId"), "got: {text}"); } - _ => panic!("Expected Dispatched result for authorized user"), + _ => panic!("Expected Action result"), } } - // ── Platform action tests ────────────────────────────────────────── - #[tokio::test] - async fn pairing_show_generates_code() { - let (executor, repo) = setup(); + async fn agent_list_returns_only_available_local_agents() { + let (executor, repo, _prefs) = setup_with_agent_rows( + vec![ + make_agent_row( + "codex-1", + "Codex CLI", + "acp", + Some("codex"), + true, + Some("online"), + None, + 10, + ), + make_agent_row( + "claude-1", + "Claude Code", + "acp", + Some("claude"), + true, + Some("offline"), + None, + 20, + ), + make_agent_row( + "disabled-1", + "Disabled Agent", + "acp", + Some("disabled"), + false, + Some("online"), + None, + 30, + ), + ], + HashMap::new(), + ); repo.add_authorized_user("tg_42", "telegram"); let msg = make_action_message( "tg_42", "chat_1", - "pairing.show", - ActionCategory::Platform, + "agent.list", + ActionCategory::System, PluginType::Telegram, None, ); let result = executor.handle_incoming_message(&msg).await.unwrap(); - match result { MessageResult::Action(resp) => { let text = resp.text.unwrap(); - assert!(text.contains("pairing code")); + assert!(text.contains("Codex CLI"), "got: {text}"); + assert!(!text.contains("Claude Code"), "got: {text}"); + assert!(!text.contains("Disabled Agent"), "got: {text}"); + let buttons = resp.buttons.unwrap(); + assert_eq!(buttons[0][0].action, "agent.select"); + assert_eq!( + buttons[0][0] + .params + .as_ref() + .unwrap() + .get("agentId") + .map(String::as_str), + Some("codex-1") + ); } _ => panic!("Expected Action result"), } } #[tokio::test] - async fn pairing_check_authorized() { - let (executor, repo) = setup(); + async fn agent_list_hides_current_agent_and_includes_path_available_agents() { + let mut prefs = HashMap::new(); + prefs.insert( + "assistant.telegram.agent".into(), + r#"{"assistant_id":"codex-1","name":"Codex CLI"}"#.into(), + ); + let mut openclaw = make_agent_row("openclaw-1", "OpenClaw", "acp", Some("openclaw"), true, None, None, 20); + openclaw.command = Some("sh".into()); + let (executor, repo, _prefs) = setup_with_agent_rows( + vec![ + make_agent_row( + "codex-1", + "Codex CLI", + "acp", + Some("codex"), + true, + Some("online"), + None, + 10, + ), + openclaw, + make_agent_row( + "disabled-1", + "Disabled Agent", + "acp", + Some("disabled"), + false, + Some("online"), + None, + 30, + ), + ], + prefs, + ); repo.add_authorized_user("tg_42", "telegram"); let msg = make_action_message( "tg_42", "chat_1", - "pairing.check", - ActionCategory::Platform, + "agent.list", + ActionCategory::System, PluginType::Telegram, None, ); let result = executor.handle_incoming_message(&msg).await.unwrap(); - match result { MessageResult::Action(resp) => { let text = resp.text.unwrap(); - assert!(text.contains("authorized")); + assert!(text.contains("OpenClaw"), "got: {text}"); + assert!(!text.contains("- Codex CLI"), "got: {text}"); + let buttons = resp.buttons.unwrap(); + assert_eq!( + buttons[0][0] + .params + .as_ref() + .unwrap() + .get("agentId") + .map(String::as_str), + Some("openclaw-1") + ); } _ => panic!("Expected Action result"), } } #[tokio::test] - async fn pairing_check_not_authorized() { - let (executor, repo) = setup(); + async fn agent_select_binds_local_agent_and_clears_model_override() { + let mut prefs = HashMap::new(); + prefs.insert( + "assistant.telegram.defaultModel".into(), + r#"{"id":"old-provider","use_model":"old-model"}"#.into(), + ); + let (executor, repo, prefs) = setup_with_agent_rows( + vec![make_agent_row( + "codex-1", + "Codex CLI", + "acp", + Some("codex"), + true, + Some("online"), + None, + 10, + )], + prefs, + ); repo.add_authorized_user("tg_42", "telegram"); let msg = make_action_message( - "tg_99", // different user + "tg_42", "chat_1", - "pairing.check", - ActionCategory::Platform, + "agent.select", + ActionCategory::System, PluginType::Telegram, - None, + Some(HashMap::from([("agentId".into(), "codex-1".into())])), ); - // tg_99 is not authorized, but the action itself needs the user to be authorized - // first (it's routed via handle_incoming_message which checks auth first) - // So for this test, authorize tg_99 too - repo.add_authorized_user("tg_99", "telegram"); - let result = executor.handle_incoming_message(&msg).await.unwrap(); match result { MessageResult::Action(resp) => { let text = resp.text.unwrap(); - // tg_99 is authorized - assert!(text.contains("authorized")); + assert!(text.contains("Telegram Agent 已切换"), "got: {text}"); + assert!(text.contains("Codex CLI"), "got: {text}"); + assert!(text.contains("已恢复 Agent 默认模型"), "got: {text}"); } _ => panic!("Expected Action result"), } + + let saved_agent = prefs.get("assistant.telegram.agent").unwrap(); + assert!(saved_agent.contains("codex-1"), "saved: {saved_agent}"); + assert!(prefs.get("assistant.telegram.defaultModel").is_none()); + let sessions = repo.get_all_sessions().await.unwrap(); + assert_eq!(sessions[0].agent_type, "acp"); } #[tokio::test] - async fn pairing_help_returns_instructions() { - let (executor, repo) = setup(); + async fn slash_model_returns_buttons_for_current_agent_models() { + let mut prefs = HashMap::new(); + prefs.insert( + "assistant.telegram.agent".into(), + r#"{"assistant_id":"codex-1","name":"Codex CLI"}"#.into(), + ); + let model_payload = r#"{"current_model_id":"gpt-5","available_models":[{"id":"gpt-5","label":"GPT-5"},{"id":"gpt-5-mini","label":"GPT-5 Mini"}]}"#; + let (executor, repo, _prefs) = setup_with_agent_rows( + vec![make_agent_row( + "codex-1", + "Codex CLI", + "acp", + Some("codex"), + true, + Some("online"), + Some(model_payload), + 10, + )], + prefs, + ); repo.add_authorized_user("tg_42", "telegram"); - let msg = make_action_message( - "tg_42", - "chat_1", - "pairing.help", - ActionCategory::Platform, - PluginType::Telegram, - None, - ); + let msg = make_command_message("tg_42", "chat_1", "/model", PluginType::Telegram); let result = executor.handle_incoming_message(&msg).await.unwrap(); match result { MessageResult::Action(resp) => { let text = resp.text.unwrap(); - assert!(text.contains("authorization")); + assert!(text.contains("当前 Agent: Codex CLI"), "got: {text}"); + let buttons = resp.buttons.unwrap(); + assert_eq!(buttons[0][0].label, "gpt-5"); + assert_eq!(buttons[0][0].action, "model.select"); + assert_eq!( + buttons[0][0].params.as_ref().unwrap().get("m").map(String::as_str), + Some("gpt-5") + ); } _ => panic!("Expected Action result"), } } - // ── System action tests ──────────────────────────────────────────── - #[tokio::test] - async fn session_new_creates_session() { - let (executor, repo) = setup(); + async fn slash_model_uses_acp_config_options_when_probe_models_are_empty() { + let mut prefs = HashMap::new(); + prefs.insert( + "assistant.telegram.agent".into(), + r#"{"assistant_id":"claude-1","name":"Claude Code"}"#.into(), + ); + let mut row = make_agent_row( + "claude-1", + "Claude Code", + "acp", + Some("claude"), + true, + Some("online"), + Some(r#"{"available_models":[]}"#), + 10, + ); + row.config_options = Some( + r#"{"config_options":[{"category":"model","currentValue":"sonnet","id":"model","name":"Model","options":[{"name":"Default","value":"default"},{"name":"Sonnet","value":"sonnet"}],"type":"select"}]}"# + .into(), + ); + let (executor, repo, _prefs) = setup_with_agent_rows(vec![row], prefs); repo.add_authorized_user("tg_42", "telegram"); - let msg = make_action_message( - "tg_42", - "chat_1", - "session.new", - ActionCategory::System, - PluginType::Telegram, - None, - ); + let msg = make_command_message("tg_42", "chat_1", "/model", PluginType::Telegram); let result = executor.handle_incoming_message(&msg).await.unwrap(); match result { MessageResult::Action(resp) => { let text = resp.text.unwrap(); - assert!(text.contains("New session")); - // With no client_preferences configured, defaults to "aionrs" - assert!(text.contains("aionrs")); + assert!(text.contains("当前 Agent: Claude Code"), "got: {text}"); + let buttons = resp.buttons.unwrap(); + assert_eq!(buttons[0][0].label, "Default"); + assert_eq!(buttons[1][0].label, "Sonnet"); + assert_eq!(buttons[1][0].action, "model.select"); + assert_eq!( + buttons[1][0].params.as_ref().unwrap().get("m").map(String::as_str), + Some("sonnet") + ); } _ => panic!("Expected Action result"), } } #[tokio::test] - async fn session_new_resets_existing_session() { - let (executor, repo) = setup(); + async fn slash_model_uses_compact_callback_params_for_telegram_limit() { + let mut prefs = HashMap::new(); + prefs.insert( + "assistant.telegram.agent".into(), + r#"{"assistant_id":"hermes-1","name":"Hermes"}"#.into(), + ); + let model_payload = r#"{"available_models":[{"id":"openai-codex:gpt-5.3-codex-spark","label":"openai-codex:gpt-5.3-codex-spark"}]}"#; + let (executor, repo, _prefs) = setup_with_agent_rows( + vec![make_agent_row( + "hermes-1", + "Hermes", + "acp", + Some("hermes"), + true, + Some("online"), + Some(model_payload), + 10, + )], + prefs, + ); repo.add_authorized_user("tg_42", "telegram"); - // First: send a text message to create a session - let text_msg = make_text_message("tg_42", "chat_1", "Hello", PluginType::Telegram); - let r1 = executor.handle_incoming_message(&text_msg).await.unwrap(); - let sid1 = match r1 { - MessageResult::Dispatched { session_id, .. } => session_id, - _ => panic!("Expected Dispatched"), - }; + let msg = make_command_message("tg_42", "chat_1", "/model", PluginType::Telegram); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(resp) => { + let buttons = resp.buttons.unwrap(); + let params = buttons[0][0].params.as_ref().unwrap(); + assert_eq!(params.get("p").map(String::as_str), Some("hermes-1")); + assert_eq!( + params.get("m").map(String::as_str), + Some("openai-codex:gpt-5.3-codex-spark") + ); + assert!(!params.contains_key("providerId")); + assert!(!params.contains_key("model")); + } + _ => panic!("Expected Action result"), + } + } - // Then: session.new should delete old + create fresh - let new_msg = make_action_message( - "tg_42", - "chat_1", - "session.new", - ActionCategory::System, - PluginType::Telegram, - None, + #[tokio::test] + async fn slash_model_returns_provider_buttons_for_aionrs_agent() { + let mut prefs = HashMap::new(); + prefs.insert( + "assistant.telegram.agent".into(), + r#"{"assistant_id":"aion-1","name":"Aion CLI"}"#.into(), ); - let r2 = executor.handle_incoming_message(&new_msg).await.unwrap(); - match r2 { + prefs.insert( + "aionrs.defaultModel".into(), + r#"{"id":"deepseek-provider","use_model":"deepseek-v4-pro"}"#.into(), + ); + let (executor, repo, _prefs) = setup_with_agent_rows_and_providers( + vec![make_agent_row( + "aion-1", "Aion CLI", "aionrs", None, true, None, None, 10, + )], + vec![make_provider( + "deepseek-provider", + "DeepSeek", + r#"["deepseek-v4-pro","deepseek-v4-flash"]"#, + )], + prefs, + ); + repo.add_authorized_user("tg_42", "telegram"); + + let msg = make_command_message("tg_42", "chat_1", "/model", PluginType::Telegram); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { MessageResult::Action(resp) => { let text = resp.text.unwrap(); - assert!(text.contains("New session")); + assert!(text.contains("deepseek-provider / deepseek-v4-pro"), "got: {text}"); + assert!(text.contains("当前 Agent: Aion CLI"), "got: {text}"); + let buttons = resp.buttons.unwrap(); + assert_eq!(buttons[0][0].label, "DeepSeek / deepseek-v4-pro"); + assert_eq!(buttons[0][0].action, "model.select"); + assert_eq!( + buttons[0][0].params.as_ref().unwrap().get("p").map(String::as_str), + Some("deepseek-provider") + ); } _ => panic!("Expected Action result"), } + } - // Send another text message — the session ID should differ - let text_msg2 = make_text_message("tg_42", "chat_1", "Again", PluginType::Telegram); - let r3 = executor.handle_incoming_message(&text_msg2).await.unwrap(); - let sid3 = match r3 { - MessageResult::Dispatched { session_id, .. } => session_id, - _ => panic!("Expected Dispatched"), - }; - // New session has different full ID (reset deleted the old one) - assert_ne!(sid1, sid3); + #[tokio::test] + async fn slash_model_explains_openclaw_runtime_model_is_display_only() { + let mut prefs = HashMap::new(); + prefs.insert( + "assistant.telegram.agent".into(), + r#"{"assistant_id":"openclaw-1","name":"OpenClaw"}"#.into(), + ); + let (executor, repo, _prefs) = setup_with_agent_rows( + vec![make_agent_row( + "openclaw-1", + "OpenClaw", + "acp", + Some("openclaw"), + true, + Some("online"), + None, + 10, + )], + prefs, + ); + repo.add_authorized_user("tg_42", "telegram"); - // Only 1 session should exist for this user+chat - let sessions = repo.sessions.lock().unwrap(); - let user_chat_sessions: Vec<_> = sessions - .iter() - .filter(|s| s.user_id == "user_tg_42" && s.chat_id.as_deref() == Some("chat_1")) - .collect(); - assert_eq!(user_chat_sessions.len(), 1); + let msg = make_command_message("tg_42", "chat_1", "/model", PluginType::Telegram); + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("当前 Agent: OpenClaw"), "got: {text}"); + assert!( + text.contains("暂不支持在 Telegram 中切换 OpenClaw 模型。"), + "got: {text}" + ); + assert!( + text.contains("后续等待 OpenClaw ACP 完善模型列表和 set model 能力后可实现。"), + "got: {text}" + ); + let buttons = resp.buttons.unwrap_or_default(); + assert!( + buttons.iter().flatten().all(|button| button.action != "model.select"), + "OpenClaw must not show model switch buttons until ACP reports model support" + ); + } + _ => panic!("Expected Action result"), + } + } + + #[test] + fn openclaw_runtime_model_line_extracts_metadata_model_only() { + let line = serde_json::json!({ + "type": "trace.metadata", + "sessionKey": "agent:main:acp:sess-123", + "data": { + "model": { + "provider": "openai-codex", + "name": "gpt-5.5", + "thinkLevel": "medium" + }, + "config": { + "redacted": { + "auth": "must not leak" + } + } + } + }) + .to_string(); + + let model = super::extract_openclaw_runtime_model_from_trajectory_line(&line).unwrap(); + assert_eq!(model.provider.as_deref(), Some("openai-codex")); + assert_eq!(model.name.as_deref(), Some("gpt-5.5")); + assert_eq!(model.think_level.as_deref(), Some("medium")); } #[tokio::test] - async fn session_status_shows_info() { - let (executor, repo) = setup(); + async fn model_select_writes_allowed_model_and_resets_session() { + let mut prefs = HashMap::new(); + prefs.insert( + "assistant.telegram.agent".into(), + r#"{"assistant_id":"codex-1","name":"Codex CLI"}"#.into(), + ); + let model_payload = r#"{"available_models":[{"id":"gpt-5","label":"GPT-5"}]}"#; + let (executor, repo, prefs) = setup_with_agent_rows( + vec![make_agent_row( + "codex-1", + "Codex CLI", + "acp", + Some("codex"), + true, + Some("online"), + Some(model_payload), + 10, + )], + prefs, + ); repo.add_authorized_user("tg_42", "telegram"); let msg = make_action_message( "tg_42", "chat_1", - "session.status", + "model.select", ActionCategory::System, PluginType::Telegram, - None, + Some(HashMap::from([ + ("providerId".into(), "codex-1".into()), + ("model".into(), "gpt-5".into()), + ])), ); let result = executor.handle_incoming_message(&msg).await.unwrap(); match result { MessageResult::Action(resp) => { let text = resp.text.unwrap(); - assert!(text.contains("Session:")); - assert!(text.contains("Agent:")); + assert!(text.contains("Telegram 模型已切换"), "got: {text}"); + assert!(text.contains("gpt-5"), "got: {text}"); } _ => panic!("Expected Action result"), } + + let saved_model = prefs.get("assistant.telegram.defaultModel").unwrap(); + assert!(saved_model.contains("codex-1"), "saved: {saved_model}"); + assert!(saved_model.contains("gpt-5"), "saved: {saved_model}"); } #[tokio::test] - async fn help_show_returns_menu() { - let (executor, repo) = setup(); + async fn personal_list_and_select_bind_existing_personal_conversation() { + let personal_directory = Arc::new(MockPersonalDirectory::with_conversations(vec![ + ChannelPersonalConversationSummary { + id: "conv-1".into(), + name: "检查本机资源情况".into(), + agent_type: "acp".into(), + agent_label: Some("OpenClaw".into()), + recent_message: Some("帮我检查本机资源情况".into()), + }, + ])); + let (executor, repo, _personal_directory) = setup_with_personal_directory(personal_directory); repo.add_authorized_user("tg_42", "telegram"); - let msg = make_action_message( + let list_msg = make_command_message("tg_42", "chat_1", "/personal_list", PluginType::Telegram); + let list_result = executor.handle_incoming_message(&list_msg).await.unwrap(); + match list_result { + MessageResult::Action(resp) => { + let text = resp.text.unwrap(); + assert!(text.contains("请选择要切换的个人会话"), "got: {text}"); + assert!(text.contains("检查本机资源情况"), "got: {text}"); + assert!(text.contains("Agent: OpenClaw"), "got: {text}"); + assert!(text.contains("最近: 帮我检查本机资源情况"), "got: {text}"); + assert!(text.contains("ID: conv-1"), "got: {text}"); + let buttons = resp.buttons.unwrap(); + assert_eq!(buttons[0][0].action, "personal.select"); + assert_eq!(buttons[0][0].label, "检查本机资源情况"); + assert_eq!( + buttons[0][0].params.as_ref().unwrap().get("id").map(String::as_str), + Some("conv-1") + ); + } + _ => panic!("Expected Action result"), + } + + let select_msg = make_action_message( "tg_42", "chat_1", - "help.show", + "personal.select", ActionCategory::System, PluginType::Telegram, - None, + Some(HashMap::from([("id".into(), "conv-1".into())])), ); - let result = executor.handle_incoming_message(&msg).await.unwrap(); - match result { + let select_result = executor.handle_incoming_message(&select_msg).await.unwrap(); + match select_result { MessageResult::Action(resp) => { - assert!(resp.text.is_some()); - assert!(resp.buttons.is_some()); - let buttons = resp.buttons.unwrap(); - assert!(buttons.len() >= 2); // at least 2 rows - assert!( - !buttons.iter().flatten().any(|button| button.action == "agent.show"), - "help menu must not expose direct agent selection" - ); + let text = resp.text.unwrap(); + assert!(text.contains("已切换到个人会话"), "got: {text}"); + assert!(text.contains("检查本机资源情况"), "got: {text}"); } _ => panic!("Expected Action result"), } + let sessions = repo.get_all_sessions().await.unwrap(); + assert_eq!(sessions[0].conversation_id.as_deref(), Some("conv-1")); + assert_eq!(sessions[0].agent_type, "acp"); } #[tokio::test] - async fn agent_show_is_treated_as_unknown_action() { + async fn new_session_with_title_passes_explicit_title_hint_to_next_dispatch() { let (executor, repo) = setup(); repo.add_authorized_user("tg_42", "telegram"); - let msg = make_action_message( - "tg_42", - "chat_1", - "agent.show", - ActionCategory::System, - PluginType::Telegram, - None, - ); - let result = executor.handle_incoming_message(&msg).await.unwrap(); - match result { + let new_msg = make_command_message("tg_42", "chat_1", "/new_session 检查本机资源情况", PluginType::Telegram); + let new_result = executor.handle_incoming_message(&new_msg).await.unwrap(); + match new_result { MessageResult::Action(resp) => { let text = resp.text.unwrap(); - assert!(text.contains("Unknown action")); - assert!(text.contains("agent.show")); + assert!(text.contains("已新建个人会话"), "got: {text}"); + assert!(text.contains("检查本机资源情况"), "got: {text}"); } _ => panic!("Expected Action result"), } + + let text_msg = make_text_message("tg_42", "chat_1", "hello", PluginType::Telegram); + let dispatch_result = executor.handle_incoming_message(&text_msg).await.unwrap(); + match dispatch_result { + MessageResult::Dispatched { title_hint, .. } => { + let title_hint = title_hint.expect("expected explicit title hint"); + assert_eq!(title_hint.title, "检查本机资源情况"); + assert_eq!(title_hint.source, "telegram_explicit"); + } + _ => panic!("Expected Dispatched result"), + } } #[tokio::test] - async fn agent_select_is_treated_as_unknown_action() { + async fn first_personal_message_generates_auto_title_hint() { let (executor, repo) = setup(); repo.add_authorized_user("tg_42", "telegram"); - let params = HashMap::from([("agentType".into(), "acp".into())]); + let text_msg = make_text_message( + "tg_42", + "chat_1", + "帮我检查本机资源情况，重点看 CPU 和内存", + PluginType::Telegram, + ); + let dispatch_result = executor.handle_incoming_message(&text_msg).await.unwrap(); + match dispatch_result { + MessageResult::Dispatched { title_hint, .. } => { + let title_hint = title_hint.expect("expected first-message title hint"); + assert_eq!(title_hint.title, "帮我检查本机资源情况，重点看 CPU 和内存"); + assert_eq!(title_hint.source, "telegram_first_message"); + } + _ => panic!("Expected Dispatched result"), + } + } + + #[tokio::test] + async fn rename_updates_current_personal_conversation_title() { + let personal_directory = Arc::new(MockPersonalDirectory::with_conversations(vec![ + ChannelPersonalConversationSummary { + id: "conv-1".into(), + name: "OpenClaw".into(), + agent_type: "acp".into(), + agent_label: Some("OpenClaw".into()), + recent_message: None, + }, + ])); + let (executor, repo, personal_directory) = setup_with_personal_directory(personal_directory); + repo.add_authorized_user("tg_42", "telegram"); + let select_msg = make_action_message( "tg_42", "chat_1", - "agent.select", + "personal.select", ActionCategory::System, PluginType::Telegram, - Some(params), + Some(HashMap::from([("id".into(), "conv-1".into())])), ); - let result = executor.handle_incoming_message(&select_msg).await.unwrap(); - match result { + executor.handle_incoming_message(&select_msg).await.unwrap(); + + let rename_msg = make_command_message("tg_42", "chat_1", "/rename 检查本机资源情况", PluginType::Telegram); + let rename_result = executor.handle_incoming_message(&rename_msg).await.unwrap(); + match rename_result { MessageResult::Action(resp) => { let text = resp.text.unwrap(); - assert!(text.contains("Unknown action")); - assert!(text.contains("agent.select")); + assert!(text.contains("已重命名当前个人会话"), "got: {text}"); + assert!(text.contains("检查本机资源情况"), "got: {text}"); } _ => panic!("Expected Action result"), } + + let renamed = personal_directory.conversations.lock().unwrap()[0].clone(); + assert_eq!(renamed.name, "检查本机资源情况"); } // ── Chat action tests ────────────────────────────────────────────── @@ -1106,6 +4540,69 @@ mod tests { } } + #[tokio::test] + async fn approval_callback_is_resolved_with_authorized_topic_identity() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + let approvals = Arc::new(RecordingApprovalPort::default()); + let executor = executor.with_approval_port(approvals.clone()); + let mut msg = make_action_message( + "tg_42", + "chat_1", + "approval.resolve", + ActionCategory::System, + PluginType::Telegram, + Some(HashMap::from([ + ("id".into(), "approval1234567".into()), + ("o".into(), "1".into()), + ])), + ); + msg.topic = Some(crate::types::ChannelTopicContext { message_thread_id: 5 }); + msg.action.as_mut().unwrap().context.message_id = Some("telegram-message-77".into()); + + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(response) => { + assert_eq!(response.behavior, ActionBehavior::Edit); + assert_eq!(response.edit_message_id.as_deref(), Some("telegram-message-77")); + assert_eq!(response.buttons, None); + assert_eq!(response.toast.as_deref(), Some("审批已同意")); + let text = response + .text + .expect("approval callback must visibly update the Telegram card"); + assert!(text.contains("审批已同意"), "got: {text}"); + assert!(text.contains("approval1234567"), "got: {text}"); + } + _ => panic!("Expected Action result"), + } + let calls = approvals.resolutions.lock().unwrap(); + assert_eq!(calls.len(), 1); + assert_eq!(calls[0].0, "user_tg_42"); + assert_eq!(calls[0].3, Some(5)); + assert_eq!(calls[0].4, "approval1234567"); + assert_eq!(calls[0].5, 1); + } + + #[tokio::test] + async fn project_command_uses_authorized_channel_context() { + let (executor, repo) = setup(); + repo.add_authorized_user("tg_42", "telegram"); + let development = Arc::new(RecordingDevelopmentPort::default()); + let executor = executor.with_development_port(development.clone()); + let msg = make_command_message("tg_42", "chat_1", "/project", PluginType::Telegram); + + let result = executor.handle_incoming_message(&msg).await.unwrap(); + match result { + MessageResult::Action(response) => assert!(response.text.unwrap().contains("Project: Aion")), + _ => panic!("Expected Action result"), + } + let calls = development.calls.lock().unwrap(); + assert_eq!(calls.len(), 1); + assert_eq!(calls[0].0.source_user_id, "user_tg_42"); + assert_eq!(calls[0].0.chat_id, "chat_1"); + assert_eq!(calls[0].1, crate::development::ChannelDevelopmentCommand::Project); + } + #[tokio::test] async fn action_copy_returns_answer() { let (executor, repo) = setup(); diff --git a/crates/aionui-channel/src/approval.rs b/crates/aionui-channel/src/approval.rs new file mode 100644 index 000000000..ba5520160 --- /dev/null +++ b/crates/aionui-channel/src/approval.rs @@ -0,0 +1,37 @@ +use aionui_common::Confirmation; +use async_trait::async_trait; + +use crate::error::ChannelError; +use crate::types::PluginType; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChannelApprovalContext { + pub source_user_id: String, + pub conversation_id: String, + pub agent_id: Option, + pub platform: PluginType, + pub chat_id: String, + pub message_thread_id: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChannelApprovalResolutionContext { + pub source_user_id: String, + pub platform: PluginType, + pub chat_id: String, + pub message_thread_id: Option, + pub is_admin: bool, +} + +#[async_trait] +pub trait ChannelApprovalPort: Send + Sync { + async fn create(&self, context: ChannelApprovalContext, confirmation: Confirmation) + -> Result; + + async fn resolve( + &self, + context: ChannelApprovalResolutionContext, + approval_id: &str, + option_index: usize, + ) -> Result; +} diff --git a/crates/aionui-channel/src/channel_settings.rs b/crates/aionui-channel/src/channel_settings.rs index be223a69b..0c8470f17 100644 --- a/crates/aionui-channel/src/channel_settings.rs +++ b/crates/aionui-channel/src/channel_settings.rs @@ -1,4 +1,4 @@ -use std::sync::Arc; +use std::{env, path::Path, sync::Arc}; use aionui_api_types::{ ChannelAssistantSettingRequest, ChannelAssistantSettingResponse, ChannelDefaultModelSetting, @@ -6,8 +6,9 @@ use aionui_api_types::{ }; use aionui_common::ProviderWithModel; use aionui_db::{ - IAgentMetadataRepository, IAssistantDefinitionRepository, IAssistantOverlayRepository, IClientPreferenceRepository, - resolve_agent_binding_from_rows, + AgentMetadataRow, IAgentMetadataRepository, IAssistantDefinitionRepository, IAssistantOverlayRepository, + IClientPreferenceRepository, IProviderRepository, models::Provider, resolve_agent_binding_from_rows, + runtime_backend_for_agent, }; use tracing::debug; @@ -15,6 +16,7 @@ use crate::error::ChannelError; use crate::types::PluginType; const DEFAULT_AGENT_TYPE: &str = "aionrs"; +const AIONRS_DEFAULT_MODEL_KEY: &str = "aionrs.defaultModel"; /// Per-plugin agent/model configuration read from `client_preferences`. /// @@ -24,6 +26,7 @@ const DEFAULT_AGENT_TYPE: &str = "aionrs"; pub struct ChannelSettingsService { pref_repo: Arc, agent_metadata_repo: Option>, + provider_repo: Option>, assistant_definition_repo: Option>, assistant_overlay_repo: Option>, } @@ -46,11 +49,40 @@ pub struct ResolvedModelConfig { pub use_model: Option, } +/// Assistant option exposed to channel command UIs. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChannelAssistantOption { + pub assistant_id: String, + pub name: String, + pub agent_type: String, + pub backend: Option, +} + +/// Local agent option exposed to channel command UIs. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChannelAgentOption { + pub agent_id: String, + pub name: String, + pub agent_type: String, + pub backend: Option, + pub models: Vec, + pub last_probe_at: Option, +} + +/// Model option exposed to channel command UIs. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChannelModelOption { + pub provider_id: String, + pub model: String, + pub label: String, +} + impl ChannelSettingsService { pub fn new(pref_repo: Arc) -> Self { Self { pref_repo, agent_metadata_repo: None, + provider_repo: None, assistant_definition_repo: None, assistant_overlay_repo: None, } @@ -61,6 +93,11 @@ impl ChannelSettingsService { self } + pub fn with_provider_repo(mut self, provider_repo: Arc) -> Self { + self.provider_repo = Some(provider_repo); + self + } + pub fn with_assistant_repos( mut self, assistant_definition_repo: Arc, @@ -139,28 +176,47 @@ impl ChannelSettingsService { /// Returns `None` when no model is configured (common for ACP agents). pub async fn get_model_config(&self, platform: PluginType) -> Result, ChannelError> { let key = model_key(platform); - let prefs = self.pref_repo.get_by_keys(&[&key]).await?; + if let Some(config) = self.get_model_config_by_key(&key).await? { + return Ok(Some(config)); + } + + let agent_config = match self.get_agent_config(platform).await { + Ok(config) => config, + Err(error) => { + debug!(platform = %platform, error = %error, "skipping channel model fallback because agent config could not be resolved"); + return Ok(None); + } + }; + if agent_config.agent_type == DEFAULT_AGENT_TYPE { + return self.get_model_config_by_key(AIONRS_DEFAULT_MODEL_KEY).await; + } + + Ok(None) + } + + async fn get_model_config_by_key(&self, key: &str) -> Result, ChannelError> { + let prefs = self.pref_repo.get_by_keys(&[key]).await?; let Some(pref) = prefs.into_iter().next() else { return Ok(None); }; - let parsed: serde_json::Value = serde_json::from_str(&pref.value).unwrap_or_default(); + let Some(model) = parse_model_config_value(&pref.value) else { + return Ok(None); + }; - let provider_id = parsed["id"].as_str().unwrap_or_default().to_owned(); - let use_model = parsed["use_model"].as_str().map(|s| s.to_owned()); + debug!(key, provider_id = %model.provider_id, use_model = ?model.use_model, "resolved channel model config"); - if provider_id.is_empty() && use_model.is_none() { - return Ok(None); - } + Ok(Some(model)) + } - debug!(platform = %platform, provider_id = %provider_id, use_model = ?use_model, "resolved channel model config"); + async fn provider_model_options(&self) -> Result, ChannelError> { + let Some(provider_repo) = self.provider_repo.as_ref() else { + return Ok(vec![]); + }; - Ok(Some(ResolvedModelConfig { - provider_id: provider_id.clone(), - model: use_model.clone().unwrap_or_default(), - use_model, - })) + let providers = provider_repo.list().await?; + Ok(provider_model_options_from_rows(&providers)) } pub async fn get_platform_settings( @@ -238,6 +294,91 @@ impl ChannelSettingsService { Ok(()) } + pub async fn clear_model_setting(&self, platform: PluginType) -> Result<(), ChannelError> { + let key = model_key(platform); + self.pref_repo.delete_keys(&[&key]).await?; + Ok(()) + } + + pub async fn list_assistant_options(&self) -> Result, ChannelError> { + let (Some(definition_repo), Some(overlay_repo)) = + (&self.assistant_definition_repo, &self.assistant_overlay_repo) + else { + return Ok(vec![]); + }; + + let definitions = definition_repo.list().await?; + let overlays = overlay_repo.list().await?; + let mut options = Vec::new(); + + for definition in definitions + .into_iter() + .filter(|definition| definition.deleted_at.is_none()) + { + let overlay = overlays + .iter() + .find(|overlay| overlay.assistant_definition_id == definition.id); + if overlay.is_some_and(|overlay| !overlay.enabled) { + continue; + } + + let backend = self.effective_assistant_backend(&definition, &overlays).await?; + let agent_type = backend_to_agent_type(&backend); + let backend = if agent_type == "acp" { Some(backend) } else { None }; + options.push(ChannelAssistantOption { + assistant_id: definition.assistant_id, + name: definition.name, + agent_type, + backend, + }); + } + + options.sort_by_key(|option| option.name.to_lowercase()); + Ok(options) + } + + pub async fn list_agent_options(&self) -> Result, ChannelError> { + let Some(agent_metadata_repo) = self.agent_metadata_repo.as_ref() else { + return Ok(vec![]); + }; + + let rows = agent_metadata_repo.list_all().await?; + let provider_models = self.provider_model_options().await?; + let mut options = Vec::new(); + + for row in rows.into_iter().filter(is_channel_visible_agent_row) { + let runtime_backend = runtime_backend_for_agent(&row); + let backend = if row.agent_type == "acp" { + Some(runtime_backend) + } else { + None + }; + options.push(( + row.sort_order, + row.name.to_lowercase(), + ChannelAgentOption { + agent_id: row.id.clone(), + name: row.name.clone(), + agent_type: row.agent_type.clone(), + backend, + models: if row.agent_type == DEFAULT_AGENT_TYPE { + provider_models.clone() + } else { + parse_probed_agent_model_options( + &row.id, + row.dynamic_probe_result.as_deref(), + row.config_options.as_deref(), + ) + }, + last_probe_at: parse_dynamic_probe_checked_at(row.dynamic_probe_result.as_deref()), + }, + )); + } + + options.sort_by(|left, right| left.0.cmp(&right.0).then_with(|| left.1.cmp(&right.1))); + Ok(options.into_iter().map(|(_, _, option)| option).collect()) + } + async fn resolve_assistant_agent_config( &self, assistant_id: &str, @@ -245,11 +386,11 @@ impl ChannelSettingsService { let (Some(definition_repo), Some(overlay_repo)) = (&self.assistant_definition_repo, &self.assistant_overlay_repo) else { - return Ok(None); + return self.resolve_agent_metadata_config(assistant_id).await; }; let Some(definition) = definition_repo.get_by_assistant_id(assistant_id).await? else { - return Ok(None); + return self.resolve_agent_metadata_config(assistant_id).await; }; let agent_id = overlay_repo @@ -264,6 +405,25 @@ impl ChannelSettingsService { Ok(Some(ResolvedAgentConfig { agent_type, backend })) } + async fn resolve_agent_metadata_config(&self, agent_id: &str) -> Result, ChannelError> { + let Some(agent_metadata_repo) = self.agent_metadata_repo.as_ref() else { + return Ok(None); + }; + let rows = agent_metadata_repo.list_all().await?; + let Some(resolved) = resolve_agent_binding_from_rows(&rows, agent_id) else { + return Ok(None); + }; + let backend = if resolved.agent_type == "acp" { + Some(resolved.runtime_backend) + } else { + None + }; + Ok(Some(ResolvedAgentConfig { + agent_type: resolved.agent_type, + backend, + })) + } + async fn resolve_assistant_identity_for_legacy_binding( &self, assistant: &ChannelAssistantSettingResponse, @@ -405,6 +565,179 @@ impl ChannelSettingsService { } } +fn is_channel_visible_agent_row(row: &AgentMetadataRow) -> bool { + if !row.enabled { + return false; + } + if row.agent_type != DEFAULT_AGENT_TYPE && row.agent_type != "acp" { + return false; + } + match row.last_check_status.as_deref() { + Some("offline") | Some("unavailable") => false, + Some("online") | Some("available") => true, + _ => { + row.agent_source == "internal" + || row.last_success_at.is_some() + || row + .available_models + .as_deref() + .is_some_and(|value| !value.trim().is_empty()) + || row_has_direct_local_command(row) + } + } +} + +fn row_has_direct_local_command(row: &AgentMetadataRow) -> bool { + let command = row + .command + .as_deref() + .or(row.backend.as_deref()) + .map(str::trim) + .filter(|value| !value.is_empty() && *value != "-"); + let Some(command) = command else { + return false; + }; + if matches!(command, "npx" | "npm" | "pnpm" | "bun" | "yarn") { + return false; + } + command_exists(command) +} + +fn command_exists(command: &str) -> bool { + let path = Path::new(command); + if path.components().count() > 1 { + return path.is_file(); + } + env::var_os("PATH") + .map(|paths| env::split_paths(&paths).any(|dir| dir.join(command).is_file())) + .unwrap_or(false) +} + +fn parse_probed_agent_model_options( + provider_id: &str, + raw: Option<&str>, + config_options_raw: Option<&str>, +) -> Vec { + let Some(raw) = raw.map(str::trim).filter(|value| !value.is_empty()) else { + return vec![]; + }; + let Ok(probe) = serde_json::from_str::(raw) else { + return vec![]; + }; + if !probe.is_usable() { + return vec![]; + } + + let observed_models = if probe.available_models.is_empty() { + parse_config_option_models(config_options_raw) + } else { + probe + .available_models + .into_iter() + .map(|model| (model.clone(), model)) + .collect() + }; + let mut seen = std::collections::HashSet::new(); + let mut models = Vec::new(); + for (model, label) in observed_models { + let model = model.trim().to_owned(); + if model.is_empty() || !seen.insert(model.clone()) { + continue; + } + models.push(ChannelModelOption { + provider_id: provider_id.to_owned(), + label: label.trim().to_owned(), + model, + }); + } + models +} + +fn parse_config_option_models(raw: Option<&str>) -> Vec<(String, String)> { + let Some(raw) = raw.map(str::trim).filter(|value| !value.is_empty()) else { + return vec![]; + }; + let Ok(value) = serde_json::from_str::(raw) else { + return vec![]; + }; + let Some(options) = value + .get("config_options") + .or_else(|| value.get("configOptions")) + .or_else(|| value.as_array().map(|_| &value)) + .and_then(serde_json::Value::as_array) + else { + return vec![]; + }; + let Some(model_option) = options.iter().find(|option| { + option + .get("category") + .and_then(serde_json::Value::as_str) + .is_some_and(|category| category.eq_ignore_ascii_case("model")) + || option + .get("id") + .and_then(serde_json::Value::as_str) + .is_some_and(|id| matches!(id.to_ascii_lowercase().as_str(), "model" | "models")) + }) else { + return vec![]; + }; + + fn collect_options(value: &serde_json::Value, output: &mut Vec<(String, String)>) { + let Some(entries) = value.as_array() else { + return; + }; + for entry in entries { + if let Some(model) = entry.get("value").and_then(serde_json::Value::as_str) { + let label = entry + .get("name") + .or_else(|| entry.get("label")) + .and_then(serde_json::Value::as_str) + .unwrap_or(model); + output.push((model.to_owned(), label.to_owned())); + } else if let Some(children) = entry.get("options") { + collect_options(children, output); + } + } + } + + let mut models = Vec::new(); + if let Some(entries) = model_option.get("options") { + collect_options(entries, &mut models); + } + models +} + +fn parse_dynamic_probe_checked_at(raw: Option<&str>) -> Option { + raw.and_then(|value| serde_json::from_str::(value).ok()) + .map(|probe| probe.checked_at) +} + +fn provider_model_options_from_rows(providers: &[Provider]) -> Vec { + let mut options = Vec::new(); + for provider in providers.iter().filter(|provider| provider.enabled) { + let model_enabled = parse_model_enabled_map(provider.model_enabled.as_deref()); + let Ok(models) = serde_json::from_str::>(&provider.models) else { + continue; + }; + for model in models { + let model = model.trim().to_owned(); + if model.is_empty() || model_enabled.get(&model) == Some(&false) { + continue; + } + options.push(ChannelModelOption { + provider_id: provider.id.clone(), + model: model.clone(), + label: format!("{} / {}", provider.name, model), + }); + } + } + options +} + +fn parse_model_enabled_map(raw: Option<&str>) -> std::collections::HashMap { + raw.and_then(|value| serde_json::from_str::>(value).ok()) + .unwrap_or_default() +} + fn agent_key(platform: PluginType) -> String { format!("assistant.{platform}.agent") } @@ -461,6 +794,23 @@ fn parse_channel_model_setting(value: &str) -> Option Option { + let parsed: serde_json::Value = serde_json::from_str(value).unwrap_or_default(); + + let provider_id = parsed["id"].as_str().unwrap_or_default().to_owned(); + let use_model = parsed["use_model"].as_str().map(|s| s.to_owned()); + + if provider_id.is_empty() && use_model.is_none() { + return None; + } + + Some(ResolvedModelConfig { + provider_id: provider_id.clone(), + model: use_model.clone().unwrap_or_default(), + use_model, + }) +} + /// Maps a backend identifier to the corresponding `AgentType` serde name. /// /// ACP-style backends (claude, gemini, codex, etc.) all map to "acp". @@ -724,6 +1074,65 @@ mod tests { assert_eq!(backend_to_agent_type("unknown"), "acp"); } + #[test] + fn dynamic_probe_timestamp_is_exposed_to_channel_model_menu() { + let raw = r#"{"agent_id":"codex","checked_at":1750000000000,"steps":[],"available_models":["gpt-5"]}"#; + assert_eq!(parse_dynamic_probe_checked_at(Some(raw)), Some(1_750_000_000_000)); + assert_eq!(parse_dynamic_probe_checked_at(Some("not-json")), None); + assert_eq!(parse_dynamic_probe_checked_at(None), None); + } + + #[test] + fn channel_model_menu_uses_only_last_successful_dynamic_probe_models() { + let checked_at = 1_750_000_000_000; + let raw = serde_json::to_string(&healthy_probe_with_models( + "codex", + checked_at, + vec!["gpt-5.6".into(), "gpt-5.6".into(), "".into()], + )) + .unwrap(); + + let models = parse_probed_agent_model_options("codex", Some(&raw), None); + + assert_eq!(models.len(), 1); + assert_eq!(models[0].provider_id, "codex"); + assert_eq!(models[0].model, "gpt-5.6"); + assert_eq!(models[0].label, "gpt-5.6"); + assert!(parse_probed_agent_model_options("codex", Some("not-json"), None).is_empty()); + assert!(parse_probed_agent_model_options("codex", None, None).is_empty()); + } + + fn healthy_probe_with_models( + agent_id: &str, + checked_at: i64, + available_models: Vec, + ) -> aionui_api_types::AgentDynamicProbeResult { + use aionui_api_types::{AgentProbeStatus, AgentProbeStep, AgentProbeStepResult}; + + aionui_api_types::AgentDynamicProbeResult { + agent_id: agent_id.into(), + checked_at, + available_models, + steps: [ + AgentProbeStep::Spawn, + AgentProbeStep::Initialize, + AgentProbeStep::Models, + AgentProbeStep::MinimalPrompt, + AgentProbeStep::Cancel, + ] + .into_iter() + .map(|step| AgentProbeStepResult { + step, + status: AgentProbeStatus::Passed, + started_at: checked_at, + duration_ms: 1, + error_category: None, + error_message: None, + }) + .collect(), + } + } + // ── get_agent_config ────────────────────────────────────────────── #[tokio::test] @@ -895,6 +1304,48 @@ mod tests { assert!(config.is_none()); } + #[tokio::test] + async fn clear_model_setting_removes_platform_default_model() { + let repo = Arc::new(MockPrefRepo::with_data(vec![( + "assistant.telegram.defaultModel", + r#"{"id":"openai","use_model":"gpt-5"}"#, + )])); + let svc = ChannelSettingsService::new(repo.clone()); + + svc.clear_model_setting(PluginType::Telegram).await.unwrap(); + + let stored = repo.get_by_keys(&["assistant.telegram.defaultModel"]).await.unwrap(); + assert!(stored.is_empty()); + } + + #[tokio::test] + async fn list_assistant_options_returns_enabled_assistants() { + let repo = Arc::new(MockPrefRepo::new()); + let disabled = make_definition("bare-disabled", "codex"); + let definition_repo: Arc = Arc::new(MockAssistantDefinitionRepo { + rows: vec![make_definition("bare-aionrs", "aionrs"), disabled.clone()], + }); + let overlay_repo: Arc = Arc::new(MockAssistantOverlayRepo { + rows: vec![AssistantOverlayRow { + assistant_definition_id: disabled.id, + enabled: false, + sort_order: 0, + agent_id_override: None, + last_used_at: None, + created_at: 0, + updated_at: 0, + }], + }); + let svc = ChannelSettingsService::new(repo).with_assistant_repos(definition_repo, overlay_repo); + + let options = svc.list_assistant_options().await.unwrap(); + + assert_eq!(options.len(), 1); + assert_eq!(options[0].assistant_id, "bare-aionrs"); + assert_eq!(options[0].agent_type, "aionrs"); + assert_eq!(options[0].backend, None); + } + #[tokio::test] async fn set_assistant_setting_persists_assistant_only_payload() { let repo = Arc::new(MockPrefRepo::new()); diff --git a/crates/aionui-channel/src/development.rs b/crates/aionui-channel/src/development.rs new file mode 100644 index 000000000..ff03f66be --- /dev/null +++ b/crates/aionui-channel/src/development.rs @@ -0,0 +1,113 @@ +use async_trait::async_trait; +use sha2::{Digest, Sha256}; + +use crate::error::ChannelError; +use crate::types::PluginType; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum ChannelDevelopmentCommand { + Project, + RunInfo, + DiffSummary, + Test, + Stop, + Retry, + Handoff, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChannelDevelopmentContext { + pub source_user_id: String, + pub conversation_id: Option, + pub platform: PluginType, + pub chat_id: String, + pub message_thread_id: Option, +} + +#[async_trait] +pub trait ChannelDevelopmentPort: Send + Sync { + async fn execute( + &self, + context: ChannelDevelopmentContext, + command: ChannelDevelopmentCommand, + ) -> Result; +} + +/// Creates short-lived, tamper-evident browser handoff links for channel users. +/// Authentication is still required by the Web application; the signature only +/// protects the route parameters carried by an untrusted chat client. +#[derive(Clone)] +pub struct DevelopmentHandoffSigner { + secret: [u8; 32], + base_path: String, +} + +impl DevelopmentHandoffSigner { + pub fn new(secret: [u8; 32], base_path: impl Into) -> Self { + let base_path = base_path.into(); + let base_path = if base_path.starts_with('/') { + std::env::var("AIONUI_PUBLIC_URL") + .ok() + .map(|public_url| public_url.trim().trim_end_matches('/').to_owned()) + .filter(|public_url| public_url.starts_with("http://") || public_url.starts_with("https://")) + .map_or(base_path.clone(), |public_url| format!("{public_url}{base_path}")) + } else { + base_path + }; + Self { secret, base_path } + } + + pub fn sign(&self, project_id: &str, run_id: &str, expires_at: i64) -> String { + let payload = handoff_payload(project_id, run_id, expires_at); + let signature = self.signature(&payload); + format!( + "{}?projectId={}&runId={}&expires={expires_at}&signature={signature}", + self.base_path, + percent_encode(project_id), + percent_encode(run_id), + ) + } + + pub fn verify(&self, project_id: &str, run_id: &str, expires_at: i64, signature: &str, now: i64) -> bool { + if expires_at < now || expires_at.saturating_sub(now) > 24 * 60 * 60 * 1000 { + return false; + } + let expected = self.signature(&handoff_payload(project_id, run_id, expires_at)); + constant_time_eq(expected.as_bytes(), signature.as_bytes()) + } + + fn signature(&self, payload: &str) -> String { + let mut digest = Sha256::new(); + digest.update(b"aionui-development-handoff-v1\0"); + digest.update(self.secret); + digest.update(payload.as_bytes()); + digest.update(self.secret); + digest.finalize().iter().map(|byte| format!("{byte:02x}")).collect() + } +} + +fn handoff_payload(project_id: &str, run_id: &str, expires_at: i64) -> String { + format!("{project_id}\0{run_id}\0{expires_at}") +} + +fn percent_encode(value: &str) -> String { + value + .bytes() + .flat_map(|byte| match byte { + b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => { + vec![char::from(byte)] + } + _ => format!("%{byte:02X}").chars().collect(), + }) + .collect() +} + +fn constant_time_eq(left: &[u8], right: &[u8]) -> bool { + if left.len() != right.len() { + return false; + } + left.iter() + .zip(right) + .fold(0_u8, |difference, (left, right)| difference | (left ^ right)) + == 0 +} diff --git a/crates/aionui-channel/src/formatter.rs b/crates/aionui-channel/src/formatter.rs index b1bf039d1..aa3f3a8ef 100644 --- a/crates/aionui-channel/src/formatter.rs +++ b/crates/aionui-channel/src/formatter.rs @@ -2,7 +2,13 @@ use std::sync::LazyLock; use regex::Regex; -use crate::types::PluginType; +use crate::types::{ParseMode, PluginType}; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FormattedText { + pub text: String, + pub parse_mode: Option, +} /// Convert text to the target IM platform format. /// @@ -11,11 +17,27 @@ use crate::types::PluginType; /// - WeChat/WeCom: strip all HTML /// - Fallback: escape HTML special chars pub fn format_text_for_platform(text: &str, platform: PluginType) -> String { + format_outgoing_text_for_platform(text, platform).text +} + +pub fn format_outgoing_text_for_platform(text: &str, platform: PluginType) -> FormattedText { match platform { - PluginType::Telegram => markdown_to_telegram_html(text), - PluginType::Lark | PluginType::Dingtalk => html_to_markdown(text), - PluginType::Weixin => strip_html(text), - _ => escape_html(text), + PluginType::Telegram => FormattedText { + text: markdown_to_telegram_html(text), + parse_mode: Some(ParseMode::HTML), + }, + PluginType::Lark | PluginType::Dingtalk => FormattedText { + text: html_to_markdown(text), + parse_mode: None, + }, + PluginType::Weixin => FormattedText { + text: strip_html(text), + parse_mode: None, + }, + _ => FormattedText { + text: escape_html(text), + parse_mode: None, + }, } } @@ -30,7 +52,8 @@ static RE_ITALIC_UNDER: LazyLock = LazyLock::new(|| Regex::new(r"_(.+?)_" static RE_LINK: LazyLock = LazyLock::new(|| Regex::new(r"\[([^\]]+)\]\(([^)]+)\)").unwrap()); fn markdown_to_telegram_html(text: &str) -> String { - let s = escape_html(text); + let text = markdown_tables_to_cards(text); + let s = escape_html(&text); let s = RE_CODE_BLOCK.replace_all(&s, "
$1
"); let s = RE_INLINE_CODE.replace_all(&s, "$1"); let s = RE_BOLD_STAR.replace_all(&s, "$1"); @@ -41,6 +64,84 @@ fn markdown_to_telegram_html(text: &str) -> String { s.into_owned() } +fn markdown_tables_to_cards(text: &str) -> String { + let lines: Vec<&str> = text.lines().collect(); + let mut output = Vec::new(); + let mut i = 0; + + while i < lines.len() { + if i + 1 < lines.len() && is_table_row(lines[i]) && is_separator_row(lines[i + 1]) { + let headers = split_table_row(lines[i]); + i += 2; + + let mut rows = Vec::new(); + while i < lines.len() && is_table_row(lines[i]) { + rows.push(split_table_row(lines[i])); + i += 1; + } + + output.push(render_table_cards(&headers, &rows)); + continue; + } + + output.push(lines[i].to_owned()); + i += 1; + } + + output.join("\n") +} + +fn is_table_row(line: &str) -> bool { + let trimmed = line.trim(); + trimmed.starts_with('|') && trimmed.ends_with('|') && trimmed.matches('|').count() >= 2 +} + +fn is_separator_row(line: &str) -> bool { + if !is_table_row(line) { + return false; + } + split_table_row(line) + .iter() + .all(|cell| !cell.is_empty() && cell.chars().all(|ch| ch == '-' || ch == ':' || ch.is_whitespace())) +} + +fn split_table_row(line: &str) -> Vec { + line.trim() + .trim_matches('|') + .split('|') + .map(str::trim) + .map(ToOwned::to_owned) + .collect() +} + +fn render_table_cards(headers: &[String], rows: &[Vec]) -> String { + if headers.is_empty() || rows.is_empty() { + return String::new(); + } + if headers.len() > 5 || rows.len() > 12 { + return format!( + "**表格摘要：** 共 {} 列、{} 行。Telegram 不适合展示大表格，请在 WebUI 查看完整表格。", + headers.len(), + rows.len() + ); + } + + rows.iter() + .enumerate() + .map(|(idx, row)| { + let mut card = format!("**表格记录 {}**", idx + 1); + for (col_idx, header) in headers.iter().enumerate() { + let value = row.get(col_idx).map(String::as_str).unwrap_or(""); + if !value.trim().is_empty() { + card.push_str(&format!("\n**{}:** {}", header, value)); + } + } + card + }) + .collect::>() + .join("\n\n") +} + // ── Lark / DingTalk ────────────────────────────────────────────── static RE_PRE_CODE: LazyLock = LazyLock::new(|| Regex::new(r"
]*>([\s\S]*?)
").unwrap()); diff --git a/crates/aionui-channel/src/lib.rs b/crates/aionui-channel/src/lib.rs index 03d6a43af..3e673edde 100644 --- a/crates/aionui-channel/src/lib.rs +++ b/crates/aionui-channel/src/lib.rs @@ -2,8 +2,10 @@ //! External channel integration: plugin system, pairing handshake, and per-session messaging. pub mod action; +pub mod approval; pub mod channel_settings; pub mod constants; +pub mod development; pub mod error; pub mod formatter; pub mod manager; @@ -15,6 +17,7 @@ pub mod plugins; pub mod routes; pub mod session; pub mod stream_relay; +pub mod team_event_relay; pub mod types; #[cfg(feature = "weixin")] diff --git a/crates/aionui-channel/src/manager.rs b/crates/aionui-channel/src/manager.rs index c673c76c1..62bfbf798 100644 --- a/crates/aionui-channel/src/manager.rs +++ b/crates/aionui-channel/src/manager.rs @@ -82,7 +82,7 @@ impl ChannelManager { let statuses: Vec = rows .into_iter() .map(|row| { - let live_status = self.plugins.get(&row.id).map(|p| p.status().to_string()); + let live_status = self.plugins.get(&row.id).map(|p| p.status()); self.row_to_status_response(&row, live_status) }) .collect(); @@ -371,6 +371,30 @@ impl ChannelManager { plugin.edit_message(chat_id, message_id, message).await } + pub async fn send_chat_action(&self, plugin_id: &str, chat_id: &str, action: &str) -> Result<(), ChannelError> { + let plugin = self + .plugins + .get(plugin_id) + .ok_or_else(|| ChannelError::PluginNotFound(plugin_id.to_owned()))?; + plugin.send_chat_action(chat_id, action).await + } + + pub async fn send_chat_action_in_topic( + &self, + plugin_id: &str, + chat_id: &str, + action: &str, + message_thread_id: Option, + ) -> Result<(), ChannelError> { + let plugin = self + .plugins + .get(plugin_id) + .ok_or_else(|| ChannelError::PluginNotFound(plugin_id.to_owned()))?; + plugin + .send_chat_action_in_topic(chat_id, action, message_thread_id) + .await + } + // ── Private helpers ────────────────────────────────────────────── /// Parses a freshly supplied plugin config, returning it only when it @@ -505,7 +529,7 @@ impl ChannelManager { } }; - let live_status = self.plugins.get(plugin_id).map(|p| p.status().to_string()); + let live_status = self.plugins.get(plugin_id).map(|p| p.status()); let status_response = self.row_to_status_response(&row, live_status); let payload = PluginStatusChangedPayload { @@ -524,15 +548,21 @@ impl ChannelManager { } /// Converts a DB row + optional live status to a `PluginStatusResponse`. - fn row_to_status_response(&self, row: &ChannelPluginRow, live_status: Option) -> PluginStatusResponse { - let is_running = self.plugins.contains_key(&row.id); + fn row_to_status_response( + &self, + row: &ChannelPluginRow, + live_status: Option, + ) -> PluginStatusResponse { + let is_running = live_status == Some(PluginStatus::Running); let has_token = !row.config.is_empty(); PluginStatusResponse { plugin_id: row.id.clone(), plugin_type: row.r#type.clone(), name: row.name.clone(), enabled: row.enabled, - status: live_status.or_else(|| row.status.clone()), + status: live_status + .map(|status| status.to_string()) + .or_else(|| row.status.clone()), last_connected: row.last_connected, created_at: row.created_at, updated_at: row.updated_at, @@ -576,6 +606,26 @@ impl crate::stream_relay::ChannelSender for ChannelManager { ) -> Result<(), crate::error::ChannelError> { self.edit_message(plugin_id, chat_id, message_id, message).await } + + async fn send_chat_action( + &self, + plugin_id: &str, + chat_id: &str, + action: &str, + ) -> Result<(), crate::error::ChannelError> { + self.send_chat_action(plugin_id, chat_id, action).await + } + + async fn send_chat_action_in_topic( + &self, + plugin_id: &str, + chat_id: &str, + action: &str, + message_thread_id: Option, + ) -> Result<(), crate::error::ChannelError> { + self.send_chat_action_in_topic(plugin_id, chat_id, action, message_thread_id) + .await + } } #[cfg(test)] @@ -926,6 +976,7 @@ mod tests { media_actions: None, reply_to_message_id: None, silent: None, + topic: None, } } @@ -986,6 +1037,33 @@ mod tests { assert_eq!(statuses[0].status.as_deref(), Some("running")); } + #[tokio::test] + async fn get_status_does_not_report_error_plugin_as_connected() { + let (mgr, repo, _bc) = make_manager(); + let now = now_ms(); + repo.plugins.lock().unwrap().push(ChannelPluginRow { + id: "telegram".into(), + r#type: "telegram".into(), + name: "Telegram Bot".into(), + enabled: true, + config: "encrypted".into(), + status: Some("running".into()), + last_connected: Some(now), + created_at: now, + updated_at: now, + }); + + let mut plugin = MockPlugin::new(PluginType::Telegram); + plugin.status = PluginStatus::Error; + plugin.last_error = Some("poll loop stopped".into()); + mgr.plugins.insert("telegram".into(), Box::new(plugin)); + + let statuses = mgr.get_plugin_status().await.unwrap(); + + assert_eq!(statuses[0].status.as_deref(), Some("error")); + assert!(!statuses[0].connected); + } + // ── enable_plugin ────────────────────────────────────────────────── #[tokio::test] diff --git a/crates/aionui-channel/src/message_service.rs b/crates/aionui-channel/src/message_service.rs index 37b627fbf..90433119b 100644 --- a/crates/aionui-channel/src/message_service.rs +++ b/crates/aionui-channel/src/message_service.rs @@ -2,16 +2,18 @@ use std::sync::Arc; use aionui_ai_agent::{AgentStreamEvent, IWorkerTaskManager}; use aionui_api_types::{AssistantConversationRequest, CreateConversationRequest, SendMessageRequest}; -use aionui_common::{AgentType, ConversationSource}; +use aionui_common::{AgentType, ConversationSource, ProviderWithModel}; use aionui_conversation::ConversationService; use aionui_db::models::AssistantSessionRow; +use aionui_db::{ConversationRowUpdate, IConversationRepository}; +use async_trait::async_trait; use tokio::sync::broadcast; use tracing::{debug, info, warn}; -use crate::channel_settings::{ChannelSettingsService, resolved_model_to_provider}; +use crate::channel_settings::{ChannelSettingsService, ResolvedAgentConfig, resolved_model_to_provider}; use crate::constants::{STREAM_THROTTLE_INTERVAL, TOOL_CONFIRM_TIMEOUT}; use crate::error::ChannelError; -use crate::types::{ActionButton, OutgoingMessageType, PluginType, UnifiedOutgoingMessage}; +use crate::types::{ChannelConversationTitleHint, OutgoingMessageType, PluginType, UnifiedOutgoingMessage}; const DEPRECATED_AGENT_TYPE_MESSAGE: &str = "This agent type is no longer supported for new conversations."; @@ -27,9 +29,36 @@ pub struct ChannelMessageService { conversation_svc: Arc, task_manager: Arc, settings: Arc, + conversation_repo: Option>, + team_sender: Option>, owner_user_id: String, } +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum TeamChannelTarget { + Lead, + Agent { slot_id: String }, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TeamChannelRoute { + pub team_id: String, + pub target: TeamChannelTarget, +} + +#[async_trait] +pub trait ChannelTeamSender: Send + Sync { + async fn send_team_lead_message(&self, user_id: &str, team_id: &str, content: &str) -> Result<(), ChannelError>; + + async fn send_team_agent_message( + &self, + user_id: &str, + team_id: &str, + slot_id: &str, + content: &str, + ) -> Result<(), ChannelError>; +} + impl ChannelMessageService { pub fn new( conversation_svc: Arc, @@ -41,10 +70,22 @@ impl ChannelMessageService { conversation_svc, task_manager, settings, + conversation_repo: None, + team_sender: None, owner_user_id, } } + pub fn with_conversation_repo(mut self, conversation_repo: Arc) -> Self { + self.conversation_repo = Some(conversation_repo); + self + } + + pub fn with_team_sender(mut self, team_sender: Arc) -> Self { + self.team_sender = Some(team_sender); + self + } + /// Sends a text message from a channel user to the AI agent. /// /// 1. Ensures the session has a backing conversation (creates one if needed) @@ -59,13 +100,44 @@ impl ChannelMessageService { session: &AssistantSessionRow, text: &str, platform: PluginType, + ) -> Result { + self.send_to_agent_with_title_hint(session, text, platform, None).await + } + + pub async fn send_to_agent_with_title_hint( + &self, + session: &AssistantSessionRow, + text: &str, + platform: PluginType, + title_hint: Option, ) -> Result { // Ensure conversation exists let conversation_id = match &session.conversation_id { Some(cid) => cid.clone(), - None => self.create_conversation_for_session(session, platform).await?, + None => { + self.create_conversation_for_session(session, platform, title_hint.as_ref()) + .await? + } }; + if let Some(route) = self.resolve_team_channel_route(&conversation_id).await? { + self.send_to_team_route(&route, text).await?; + info!( + conversation_id = %conversation_id, + session_id = %session.id, + team_id = %route.team_id, + "channel message routed through team api" + ); + return Ok(SendResult { + conversation_id, + stream_rx: None, + team_routed: true, + }); + } + + self.repair_existing_aionrs_conversation_model(&conversation_id, platform) + .await?; + // Send message through ConversationService. `msg_id` is now // server-generated inside the service; channel plugins that need to // correlate the user message back to the conversation should use @@ -112,6 +184,7 @@ impl ChannelMessageService { Ok(SendResult { conversation_id, stream_rx: Some(stream_rx), + team_routed: false, }) } @@ -123,17 +196,30 @@ impl ChannelMessageService { &self, session: &AssistantSessionRow, platform: PluginType, + title_hint: Option<&ChannelConversationTitleHint>, ) -> Result { let source = platform_to_source(platform); - let agent_config = self - .settings - .get_agent_config(platform) - .await - .map_err(|e| ChannelError::MessageSendFailed(e.to_string()))?; - let assistant_setting = self.settings.get_assistant_setting(platform).await?; + let agent_config = if session.bound_agent_id.is_some() { + ResolvedAgentConfig { + agent_type: session.agent_type.clone(), + backend: session.bound_backend.clone(), + } + } else { + self.settings + .get_agent_config(platform) + .await + .map_err(|e| ChannelError::MessageSendFailed(e.to_string()))? + }; + let assistant_setting = if session.bound_agent_id.is_some() { + None + } else { + self.settings.get_assistant_setting(platform).await? + }; let assistant_id = assistant_setting .as_ref() .and_then(|setting| setting.assistant_id.as_deref()) + .map(str::trim) + .filter(|assistant_id| !assistant_id.is_empty()) .map(ToOwned::to_owned); let assistant_name = assistant_setting .as_ref() @@ -143,31 +229,51 @@ impl ChannelMessageService { .map(ToOwned::to_owned); let model_config = self.settings.get_model_config(platform).await?; let agent_type = parse_agent_type(&agent_config.agent_type)?; - let model = resolved_model_to_provider(model_config.as_ref()); - let mut extra = Self::build_channel_extra(if assistant_id.is_some() { - None - } else { - agent_config.backend.as_deref() - }); - let name = assistant_name.unwrap_or_else(|| { - channel_conversation_name( - platform, - &agent_config.agent_type, - agent_config.backend.as_deref(), - session.chat_id.as_deref(), - ) - }); - - // Top-level `model` is only accepted for aionrs; other types pass via `extra`. - let top_level_model = if agent_type == AgentType::Aionrs { - Some(model) - } else { - extra["model"] = serde_json::to_value(&model).unwrap_or_default(); - None + let model = match (&session.bound_provider_id, &session.bound_model) { + (Some(provider_id), Some(model)) => ProviderWithModel { + provider_id: provider_id.clone(), + model: model.clone(), + use_model: None, + }, + _ if session.bound_agent_id.is_some() && agent_type != AgentType::Aionrs => { + resolved_model_to_provider(None) + } + _ => resolved_model_to_provider(model_config.as_ref()), }; + let mut extra = Self::build_channel_extra_for_platform( + platform, + agent_config.backend.as_deref(), + session.chat_id.as_deref().unwrap_or_default(), + ); + if let Some(agent_id) = &session.bound_agent_id { + extra["bound_agent_id"] = serde_json::Value::String(agent_id.clone()); + } + if let Some(thread_id) = session.message_thread_id { + extra["telegram_message_thread_id"] = serde_json::Value::Number(thread_id.into()); + } + let name = title_hint + .map(|hint| hint.title.trim()) + .filter(|title| !title.is_empty()) + .map(ToOwned::to_owned) + .or(assistant_name) + .unwrap_or_else(|| { + channel_conversation_name( + platform, + &agent_config.agent_type, + agent_config.backend.as_deref(), + session.chat_id.as_deref(), + ) + }); + if let Some(hint) = title_hint { + extra["title_source"] = serde_json::Value::String(hint.source.clone()); + extra["auto_title"] = serde_json::Value::Bool(hint.source.ends_with("_first_message")); + extra["first_user_message_title"] = serde_json::Value::String(hint.title.clone()); + } + + let top_level_model = Self::place_model_for_conversation(agent_type, model, &mut extra); let req = CreateConversationRequest { - r#type: if assistant_id.is_some() { None } else { Some(agent_type) }, + r#type: Some(agent_type), name: Some(name), model: top_level_model, assistant: assistant_id.map(|assistant_id| AssistantConversationRequest { @@ -177,6 +283,12 @@ impl ChannelMessageService { }), source: Some(source), channel_chat_id: session.chat_id.clone(), + source_channel: Some(platform_source_channel(platform).to_owned()), + source_channel_id: None, + source_chat_id: session.chat_id.clone(), + source_user_id: None, + source_label: Some(platform_source_label(platform).to_owned()), + created_from: Some(platform_source_channel(platform).to_owned()), extra, }; @@ -195,6 +307,95 @@ impl ChannelMessageService { Ok(response.id) } + async fn repair_existing_aionrs_conversation_model( + &self, + conversation_id: &str, + platform: PluginType, + ) -> Result<(), ChannelError> { + let Some(repo) = &self.conversation_repo else { + return Ok(()); + }; + let Some(row) = repo + .get(conversation_id) + .await + .map_err(|e| ChannelError::MessageSendFailed(e.to_string()))? + else { + return Ok(()); + }; + if !aionrs_model_needs_channel_default_repair(&row.r#type, row.model.as_deref()) { + return Ok(()); + } + + let Some(model_config) = self.settings.get_model_config(platform).await? else { + return Err(ChannelError::MessageSendFailed( + "Aion CLI conversation is missing a model and no channel/default model is configured".into(), + )); + }; + let model = resolved_model_to_provider(Some(&model_config)); + if provider_model_is_empty(&model) { + return Err(ChannelError::MessageSendFailed( + "Aion CLI conversation is missing a usable provider/model binding".into(), + )); + } + let model_json = serde_json::to_string(&model).map_err(|e| { + ChannelError::MessageSendFailed(format!("Failed to serialize repaired Aion CLI model: {e}")) + })?; + + repo.update( + conversation_id, + &ConversationRowUpdate { + model: Some(Some(model_json)), + ..Default::default() + }, + ) + .await + .map_err(|e| ChannelError::MessageSendFailed(e.to_string()))?; + + info!( + conversation_id = %conversation_id, + provider_id = %model.provider_id, + model = %model.model, + "repaired stale aionrs channel conversation model" + ); + + Ok(()) + } + + async fn resolve_team_channel_route( + &self, + conversation_id: &str, + ) -> Result, ChannelError> { + let Some(repo) = &self.conversation_repo else { + return Ok(None); + }; + let Some(row) = repo + .get(conversation_id) + .await + .map_err(|e| ChannelError::MessageSendFailed(e.to_string()))? + else { + return Ok(None); + }; + Ok(team_channel_route_from_extra(&row.extra)) + } + + async fn send_to_team_route(&self, route: &TeamChannelRoute, text: &str) -> Result<(), ChannelError> { + let sender = self.team_sender.as_ref().ok_or_else(|| { + ChannelError::MessageSendFailed("Team-owned channel conversation requires Team API sender".into()) + })?; + match &route.target { + TeamChannelTarget::Lead => { + sender + .send_team_lead_message(&self.owner_user_id, &route.team_id, text) + .await + } + TeamChannelTarget::Agent { slot_id } => { + sender + .send_team_agent_message(&self.owner_user_id, &route.team_id, slot_id, text) + .await + } + } + } + /// Processes a stream event from the AI agent and converts it to /// an optional outgoing message for the IM platform. /// @@ -250,33 +451,17 @@ impl ChannelMessageService { media_actions: None, reply_to_message_id: None, silent: None, + topic: None, } } - /// Builds the final message after streaming completes, including - /// action buttons for the user. + /// Builds the final message after streaming completes. pub fn build_final_message(text: &str) -> UnifiedOutgoingMessage { UnifiedOutgoingMessage { - message_type: OutgoingMessageType::Buttons, + message_type: OutgoingMessageType::Text, text: Some(text.to_owned()), parse_mode: None, - buttons: Some(vec![vec![ - ActionButton { - label: "\u{1f504} Regenerate".into(), - action: "chat.regenerate".into(), - params: None, - }, - ActionButton { - label: "\u{25b6}\u{fe0f} Continue".into(), - action: "chat.continue".into(), - params: None, - }, - ActionButton { - label: "\u{2795} New Session".into(), - action: "session.new".into(), - params: None, - }, - ]]), + buttons: None, keyboard: None, image_url: None, file_url: None, @@ -284,6 +469,7 @@ impl ChannelMessageService { media_actions: None, reply_to_message_id: None, silent: None, + topic: None, } } @@ -301,6 +487,7 @@ impl ChannelMessageService { media_actions: None, reply_to_message_id: None, silent: None, + topic: None, } } @@ -316,8 +503,8 @@ impl ChannelMessageService { /// Build the `extra` JSON for channel conversations. /// - /// Sets `session_mode` to `"yolo"` so the agent auto-approves tool calls — - /// channel users have no interactive UI for confirmations. + /// Builds the channel runtime defaults. Callers that know the platform + /// can tighten the permission mode before creating a conversation. pub fn build_channel_extra(backend: Option<&str>) -> serde_json::Value { let mut extra = serde_json::json!({ "session_mode": "yolo", @@ -327,6 +514,102 @@ impl ChannelMessageService { } extra } + + pub fn build_channel_extra_for_platform( + platform: PluginType, + backend: Option<&str>, + chat_id: &str, + ) -> serde_json::Value { + let mut extra = Self::build_channel_extra(backend); + if platform == PluginType::Telegram { + extra["session_mode"] = serde_json::Value::String("default".into()); + } + extra["source_channel"] = serde_json::Value::String(platform_source_channel(platform).to_owned()); + if !chat_id.trim().is_empty() { + extra["source_chat_id"] = serde_json::Value::String(chat_id.to_owned()); + } + extra["source_label"] = serde_json::Value::String(platform_source_label(platform).to_owned()); + extra["created_from"] = serde_json::Value::String(platform_source_channel(platform).to_owned()); + extra + } + + /// Places model configuration where each conversation runtime expects it. + /// Aionrs accepts the typed top-level field. ACP keeps the provider metadata + /// in `extra.model` and also needs `current_model_id` to seed its startup + /// configuration before the first prompt is sent. + fn place_model_for_conversation( + agent_type: AgentType, + model: ProviderWithModel, + extra: &mut serde_json::Value, + ) -> Option { + if agent_type == AgentType::Aionrs { + return Some(model); + } + + if agent_type == AgentType::Acp { + let runtime_model = model + .use_model + .as_deref() + .filter(|value| !value.trim().is_empty()) + .unwrap_or(model.model.as_str()) + .trim(); + if !runtime_model.is_empty() { + extra["current_model_id"] = serde_json::Value::String(runtime_model.to_owned()); + } + } + extra["model"] = serde_json::to_value(&model).unwrap_or_default(); + None + } +} + +fn platform_source_channel(platform: PluginType) -> &'static str { + match platform { + PluginType::Telegram => "telegram", + PluginType::Lark => "lark", + PluginType::Dingtalk => "dingtalk", + PluginType::Weixin => "weixin", + PluginType::Slack => "slack", + PluginType::Discord => "discord", + } +} + +fn platform_source_label(platform: PluginType) -> &'static str { + match platform { + PluginType::Telegram => "Telegram", + PluginType::Lark => "Lark", + PluginType::Dingtalk => "DingTalk", + PluginType::Weixin => "WeCom", + PluginType::Slack => "Slack", + PluginType::Discord => "Discord", + } +} + +pub fn team_channel_route_from_extra(extra: &str) -> Option { + let value: serde_json::Value = serde_json::from_str(extra).ok()?; + let team_id = value + .get("teamId") + .and_then(serde_json::Value::as_str) + .filter(|value| !value.trim().is_empty())? + .to_owned(); + let role = value + .get("role") + .and_then(serde_json::Value::as_str) + .unwrap_or_default(); + let slot_id = value + .get("slot_id") + .and_then(serde_json::Value::as_str) + .filter(|value| !value.trim().is_empty()) + .map(str::to_owned); + + let target = if role == "lead" { + TeamChannelTarget::Lead + } else if let Some(slot_id) = slot_id { + TeamChannelTarget::Agent { slot_id } + } else { + TeamChannelTarget::Lead + }; + + Some(TeamChannelRoute { team_id, target }) } /// Result of sending a message to the agent. @@ -337,6 +620,7 @@ pub struct SendResult { /// `None` when the agent task could not be found after sending /// (should not happen in normal flow). pub stream_rx: Option>, + pub team_routed: bool, } /// Actions derived from agent stream events. @@ -390,6 +674,26 @@ fn parse_agent_type(s: &str) -> Result { Ok(agent_type) } +fn aionrs_model_needs_channel_default_repair(agent_type: &str, model: Option<&str>) -> bool { + agent_type == "aionrs" && stored_provider_model_is_empty(model) +} + +fn stored_provider_model_is_empty(model: Option<&str>) -> bool { + let Some(raw) = model else { + return true; + }; + let raw = raw.trim(); + if raw.is_empty() || raw == "null" { + return true; + } + + serde_json::from_str::(raw).map_or(true, |model| provider_model_is_empty(&model)) +} + +fn provider_model_is_empty(model: &ProviderWithModel) -> bool { + model.provider_id.trim().is_empty() || model.model.trim().is_empty() +} + fn channel_conversation_name( platform: PluginType, agent_type: &str, @@ -566,13 +870,11 @@ mod tests { // ── build_final_message ──────────────────────────────────────────── #[test] - fn final_message_has_buttons() { + fn final_message_has_no_legacy_buttons() { let msg = ChannelMessageService::build_final_message("Response text"); - assert_eq!(msg.message_type, OutgoingMessageType::Buttons); + assert_eq!(msg.message_type, OutgoingMessageType::Text); assert_eq!(msg.text.as_deref(), Some("Response text")); - let buttons = msg.buttons.unwrap(); - assert!(!buttons.is_empty()); - assert!(buttons[0].len() >= 2); + assert!(msg.buttons.is_none()); } // ── build_streaming_message ──────────────────────────────────────── @@ -619,6 +921,23 @@ mod tests { assert_eq!(extra["backend"], "claude"); } + #[test] + fn channel_extra_includes_source_metadata() { + let extra = + ChannelMessageService::build_channel_extra_for_platform(PluginType::Telegram, Some("claude"), "chat-1"); + assert_eq!(extra["source_channel"], "telegram"); + assert_eq!(extra["source_chat_id"], "chat-1"); + assert_eq!(extra["source_label"], "Telegram"); + assert_eq!(extra["created_from"], "telegram"); + assert_eq!(extra["session_mode"], "default"); + } + + #[test] + fn non_telegram_channel_extra_preserves_yolo_compatibility() { + let extra = ChannelMessageService::build_channel_extra_for_platform(PluginType::Lark, None, "chat-1"); + assert_eq!(extra["session_mode"], "yolo"); + } + // ── model placement by agent_type (regression: non-aionrs must not // use top-level model) ────────────────────────────────────────── @@ -632,16 +951,26 @@ mod tests { }; let mut extra = ChannelMessageService::build_channel_extra(Some("codex")); - let top_level_model = if agent_type == AgentType::Aionrs { - Some(model.clone()) - } else { - extra["model"] = serde_json::to_value(&model).unwrap(); - None - }; + let top_level_model = ChannelMessageService::place_model_for_conversation(agent_type, model, &mut extra); assert!(top_level_model.is_none(), "acp must not have top-level model"); assert_eq!(extra["model"]["provider_id"], "prov1"); assert_eq!(extra["model"]["use_model"], "global.anthropic.claude-sonnet-4-6"); + assert_eq!(extra["current_model_id"], "global.anthropic.claude-sonnet-4-6"); + } + + #[test] + fn acp_runtime_model_falls_back_to_model_name() { + let model = ProviderWithModel { + provider_id: "prov1".into(), + model: "gpt-5.5".into(), + use_model: None, + }; + let mut extra = ChannelMessageService::build_channel_extra(Some("codex")); + + ChannelMessageService::place_model_for_conversation(AgentType::Acp, model, &mut extra); + + assert_eq!(extra["current_model_id"], "gpt-5.5"); } #[test] @@ -665,6 +994,27 @@ mod tests { assert!(extra.get("model").is_none() || extra["model"].is_null()); } + #[test] + fn stale_aionrs_empty_model_requires_default_repair() { + let stale_model = r#"{"provider_id":"","model":"","use_model":null}"#; + + assert!(aionrs_model_needs_channel_default_repair("aionrs", Some(stale_model))); + } + + #[test] + fn valid_aionrs_model_does_not_require_default_repair() { + let valid_model = r#"{"provider_id":"prov2","model":"gpt-4o","use_model":null}"#; + + assert!(!aionrs_model_needs_channel_default_repair("aionrs", Some(valid_model))); + } + + #[test] + fn non_aionrs_empty_model_does_not_require_top_level_repair() { + let stale_model = r#"{"provider_id":"","model":"","use_model":null}"#; + + assert!(!aionrs_model_needs_channel_default_repair("acp", Some(stale_model))); + } + // ── channel_conversation_name ───────────────────────────────────── #[test] diff --git a/crates/aionui-channel/src/orchestrator.rs b/crates/aionui-channel/src/orchestrator.rs index db64e6148..9625ca5c4 100644 --- a/crates/aionui-channel/src/orchestrator.rs +++ b/crates/aionui-channel/src/orchestrator.rs @@ -1,13 +1,20 @@ +use std::collections::HashMap; +use std::future::Future; +use std::pin::Pin; use std::sync::Arc; -use tokio::sync::mpsc; +use tokio::sync::{Mutex, mpsc}; use tracing::{error, info, warn}; use crate::action::{ActionExecutor, MessageResult}; +use crate::approval::{ChannelApprovalContext, ChannelApprovalPort}; +use crate::formatter::format_outgoing_text_for_platform; use crate::message_service::ChannelMessageService; use crate::session::SessionManager; use crate::stream_relay::{ChannelSender, ChannelStreamRelay, RelayConfig}; -use crate::types::{ActionBehavior, OutgoingMessageType, UnifiedIncomingMessage, UnifiedOutgoingMessage}; +use crate::types::{ActionBehavior, OutgoingMessageType, PluginType, UnifiedIncomingMessage, UnifiedOutgoingMessage}; + +type SequencedJob = Pin + Send + 'static>>; /// Orchestrates the full channel message lifecycle. /// @@ -22,6 +29,49 @@ pub struct ChannelOrchestrator { message_service: Arc, session_manager: Arc, sender: Arc, + approval_port: Option>, + chat_sequencer: ChatMessageSequencer, +} + +#[derive(Clone, Default)] +struct ChatMessageSequencer { + queues: Arc>>>, +} + +impl ChatMessageSequencer { + async fn spawn(&self, platform: PluginType, chat_id: &str, message_thread_id: Option, job: F) + where + F: Future + Send + 'static, + { + let key = match message_thread_id { + Some(thread_id) => format!("{platform}:{chat_id}:{thread_id}"), + None => format!("{platform}:{chat_id}"), + }; + let sender = { + let mut queues = self.queues.lock().await; + queues + .entry(key.clone()) + .or_insert_with(|| { + let (tx, rx) = mpsc::unbounded_channel(); + spawn_chat_worker(key, rx); + tx + }) + .clone() + }; + + if sender.send(Box::pin(job)).is_err() { + warn!(platform = %platform, chat_id, "failed to enqueue channel message: chat worker stopped"); + } + } +} + +fn spawn_chat_worker(key: String, mut rx: mpsc::UnboundedReceiver) { + tokio::spawn(async move { + while let Some(job) = rx.recv().await { + job.await; + } + info!(chat_key = %key, "channel chat sequencer worker stopped"); + }); } impl ChannelOrchestrator { @@ -36,9 +86,16 @@ impl ChannelOrchestrator { message_service, session_manager, sender, + approval_port: None, + chat_sequencer: ChatMessageSequencer::default(), } } + pub fn with_approval_port(mut self, approval_port: Arc) -> Self { + self.approval_port = Some(approval_port); + self + } + /// Start the message loop. Runs until both channels close. pub async fn run( self, @@ -67,42 +124,56 @@ impl ChannelOrchestrator { let chat_id = msg.chat_id.clone(); let plugin_id = platform.to_string(); let text = msg.content.text.clone(); + let topic = msg.topic.clone(); let executor = Arc::clone(&self.action_executor); let msg_svc = Arc::clone(&self.message_service); let session_mgr = Arc::clone(&self.session_manager); let sender = Arc::clone(&self.sender); + let approval_port = self.approval_port.clone(); + let chat_sequencer = self.chat_sequencer.clone(); - tokio::spawn(async move { - match executor.handle_incoming_message(&msg).await { - Ok(MessageResult::Action(response)) => { - send_action_response(&sender, &plugin_id, &chat_id, &response).await; - } - Ok(MessageResult::Dispatched { - session_id, - conversation_id, - }) => { - handle_dispatched( - &msg_svc, - &session_mgr, - &sender, - &session_id, - conversation_id.as_deref(), - &text, - platform, - &plugin_id, - &chat_id, - ) - .await; - } - Ok(MessageResult::AlreadyProcessing) => { - info!(chat_id = %chat_id, "message ignored: already processing"); - } - Err(e) => { - error!(error = %e, "failed to handle incoming message"); - } - } - }); + chat_sequencer + .spawn( + platform, + &chat_id.clone(), + topic.as_ref().map(|value| value.message_thread_id), + async move { + match executor.handle_incoming_message(&msg).await { + Ok(MessageResult::Action(response)) => { + send_action_response(&sender, &plugin_id, &chat_id, topic.clone(), &response).await; + } + Ok(MessageResult::Dispatched { + session_id, + conversation_id, + title_hint, + }) => { + handle_dispatched( + &msg_svc, + &session_mgr, + &sender, + approval_port, + &session_id, + conversation_id.as_deref(), + title_hint, + &text, + platform, + &plugin_id, + &chat_id, + topic.clone(), + ) + .await; + } + Ok(MessageResult::AlreadyProcessing) => { + info!(chat_id = %chat_id, "message ignored: already processing"); + } + Err(e) => { + error!(error = %e, "failed to handle incoming message"); + } + } + }, + ) + .await; } } @@ -110,6 +181,7 @@ async fn send_action_response( sender: &Arc, plugin_id: &str, chat_id: &str, + topic: Option, response: &crate::types::ActionResponse, ) { if let Some(text) = &response.text { @@ -125,16 +197,21 @@ async fn send_action_response( media_actions: None, reply_to_message_id: None, silent: None, + topic, }; match response.behavior { ActionBehavior::Edit => { - if let Some(ref edit_id) = response.edit_message_id { - let _ = sender.edit_message(plugin_id, chat_id, edit_id, outgoing).await; + if let Some(ref edit_id) = response.edit_message_id + && let Err(error) = sender.edit_message(plugin_id, chat_id, edit_id, outgoing).await + { + warn!(error = %error, plugin_id, chat_id, message_id = %edit_id, "failed to edit action response"); } } _ => { - let _ = sender.send_message(plugin_id, chat_id, outgoing).await; + if let Err(error) = sender.send_message(plugin_id, chat_id, outgoing).await { + warn!(error = %error, plugin_id, chat_id, "failed to send action response"); + } } } } @@ -145,12 +222,15 @@ async fn handle_dispatched( msg_svc: &Arc, session_mgr: &Arc, sender: &Arc, + approval_port: Option>, session_id: &str, conversation_id: Option<&str>, + title_hint: Option, text: &str, platform: crate::types::PluginType, plugin_id: &str, chat_id: &str, + topic: Option, ) { let session = match session_mgr.get_session_by_id(session_id).await { Ok(Some(s)) => s, @@ -164,7 +244,21 @@ async fn handle_dispatched( } }; - let send_result = match msg_svc.send_to_agent(&session, text, platform).await { + if platform == PluginType::Telegram { + let _ = sender + .send_chat_action_in_topic( + plugin_id, + chat_id, + "typing", + topic.as_ref().map(|value| value.message_thread_id), + ) + .await; + } + + let send_result = match msg_svc + .send_to_agent_with_title_hint(&session, text, platform, title_hint) + .await + { Ok(r) => r, Err(e) => { error!(error = %e, "failed to send to agent"); @@ -180,6 +274,7 @@ async fn handle_dispatched( media_actions: None, reply_to_message_id: None, silent: None, + topic: topic.clone(), }; let _ = sender.send_message(plugin_id, chat_id, err_msg).await; return; @@ -203,9 +298,79 @@ async fn handle_dispatched( chat_id: chat_id.to_owned(), throttle_ms: 500, }; - let relay = ChannelStreamRelay::new(relay_config, Arc::clone(sender)); + let mut relay = ChannelStreamRelay::new(relay_config, Arc::clone(sender)).with_topic(topic.clone()); + if let Some(approval_port) = approval_port { + relay = relay.with_approval_port( + approval_port, + ChannelApprovalContext { + source_user_id: session.user_id.clone(), + conversation_id: send_result.conversation_id.clone(), + agent_id: session.bound_agent_id.clone(), + platform, + chat_id: chat_id.to_owned(), + message_thread_id: topic.as_ref().map(|value| value.message_thread_id), + }, + ); + } tokio::spawn(relay.run(rx)); } else { + if send_result.team_routed { + let formatted = format_outgoing_text_for_platform("⏳ 已收到，Team 正在处理...", platform); + let processing_msg = UnifiedOutgoingMessage { + message_type: OutgoingMessageType::Text, + text: Some(formatted.text), + parse_mode: formatted.parse_mode, + buttons: None, + keyboard: None, + image_url: None, + file_url: None, + file_name: None, + media_actions: None, + reply_to_message_id: None, + silent: None, + topic: topic.clone(), + }; + let processing_msg_id = sender.send_message(plugin_id, chat_id, processing_msg).await.ok(); + + if platform == PluginType::Telegram + && let Some(processing_msg_id) = processing_msg_id + { + let sender = Arc::clone(sender); + let plugin_id = plugin_id.to_owned(); + let chat_id = chat_id.to_owned(); + let topic = topic.clone(); + tokio::spawn(async move { + for _ in 0..15 { + let _ = sender + .send_chat_action_in_topic( + &plugin_id, + &chat_id, + "typing", + topic.as_ref().map(|value| value.message_thread_id), + ) + .await; + tokio::time::sleep(std::time::Duration::from_secs(4)).await; + } + let done_msg = UnifiedOutgoingMessage { + message_type: OutgoingMessageType::Text, + text: Some("✅ Team 已开始处理，稍后会发送结果。".into()), + parse_mode: None, + buttons: None, + keyboard: None, + image_url: None, + file_url: None, + file_name: None, + media_actions: None, + reply_to_message_id: None, + silent: None, + topic, + }; + let _ = sender + .edit_message(&plugin_id, &chat_id, &processing_msg_id, done_msg) + .await; + }); + } + } warn!( conversation_id = %send_result.conversation_id, "no agent task for stream subscription" @@ -220,3 +385,79 @@ fn handle_confirm(call_id: &str, value: &str) { // call_id→conversation_id lookup via IWorkerTaskManager. info!(call_id = %call_id, value = %value, "forwarding tool confirmation"); } + +#[cfg(test)] +mod tests { + use super::*; + use tokio::sync::oneshot; + use tokio::time::{Duration, sleep, timeout}; + + #[tokio::test] + async fn chat_message_sequencer_runs_same_chat_messages_in_enqueue_order() { + let sequencer = ChatMessageSequencer::default(); + let order = Arc::new(Mutex::new(Vec::new())); + let (release_tx, release_rx) = oneshot::channel::<()>(); + + { + let order = Arc::clone(&order); + sequencer + .spawn(PluginType::Telegram, "chat-1", None, async move { + order.lock().await.push("first-start"); + let _ = release_rx.await; + order.lock().await.push("first-end"); + }) + .await; + } + + { + let order = Arc::clone(&order); + let sequencer = sequencer.clone(); + sequencer + .spawn(PluginType::Telegram, "chat-1", None, async move { + order.lock().await.push("second"); + }) + .await; + } + + sleep(Duration::from_millis(25)).await; + assert_eq!(*order.lock().await, vec!["first-start"]); + + let _ = release_tx.send(()); + timeout(Duration::from_secs(1), async { + loop { + if order.lock().await.len() == 3 { + break; + } + sleep(Duration::from_millis(10)).await; + } + }) + .await + .expect("queued same-chat task should run after the first task finishes"); + + assert_eq!(*order.lock().await, vec!["first-start", "first-end", "second"]); + } + + #[tokio::test] + async fn chat_message_sequencer_does_not_block_other_topics_in_same_group() { + let sequencer = ChatMessageSequencer::default(); + let (release_tx, release_rx) = oneshot::channel::<()>(); + let (other_topic_tx, other_topic_rx) = oneshot::channel::<()>(); + + sequencer + .spawn(PluginType::Telegram, "group", Some(3), async move { + let _ = release_rx.await; + }) + .await; + sequencer + .spawn(PluginType::Telegram, "group", Some(5), async move { + let _ = other_topic_tx.send(()); + }) + .await; + + timeout(Duration::from_secs(1), other_topic_rx) + .await + .expect("a different topic should use an independent queue") + .expect("topic worker should signal completion"); + let _ = release_tx.send(()); + } +} diff --git a/crates/aionui-channel/src/plugin.rs b/crates/aionui-channel/src/plugin.rs index f192f7e7e..02864fe1d 100644 --- a/crates/aionui-channel/src/plugin.rs +++ b/crates/aionui-channel/src/plugin.rs @@ -63,6 +63,20 @@ pub trait ChannelPlugin: Send + Sync { message: UnifiedOutgoingMessage, ) -> Result<(), ChannelError>; + /// Send a lightweight platform activity indicator where supported. + async fn send_chat_action(&self, _chat_id: &str, _action: &str) -> Result<(), ChannelError> { + Ok(()) + } + + async fn send_chat_action_in_topic( + &self, + chat_id: &str, + action: &str, + _message_thread_id: Option, + ) -> Result<(), ChannelError> { + self.send_chat_action(chat_id, action).await + } + /// Number of currently active (chatting) users on this plugin. fn active_user_count(&self) -> usize; @@ -206,6 +220,7 @@ mod tests { media_actions: None, reply_to_message_id: None, silent: None, + topic: None, } } diff --git a/crates/aionui-channel/src/plugins/dingtalk/plugin.rs b/crates/aionui-channel/src/plugins/dingtalk/plugin.rs index 4e880ac19..6f234dac7 100644 --- a/crates/aionui-channel/src/plugins/dingtalk/plugin.rs +++ b/crates/aionui-channel/src/plugins/dingtalk/plugin.rs @@ -689,6 +689,7 @@ async fn handle_bot_message(data_str: &str, message_tx: &mpsc::Sender Result { + let url = format!("{}/getChatMember", self.base_url); + let resp: TgResponse = self + .client + .get(&url) + .query(&[("chat_id", chat_id), ("user_id", user_id)]) + .send() + .await + .map_err(|e| ChannelError::PlatformApi(format!("getChatMember request failed: {e}")))? + .json() + .await + .map_err(|e| ChannelError::PlatformApi(format!("getChatMember parse failed: {e}")))?; + if !resp.ok { + return Err(ChannelError::PlatformApi( + resp.description.unwrap_or_else(|| "getChatMember failed".into()), + )); + } + Ok(resp + .result + .and_then(|value| { + value + .get("status") + .and_then(|status| status.as_str()) + .map(str::to_owned) + }) + .unwrap_or_default()) + } /// Create a new API client for the given bot token. pub fn new(client: Client, token: &str) -> Self { Self { @@ -100,11 +128,27 @@ impl TelegramApi { if !resp.ok { let desc = resp.description.unwrap_or_default(); + warn!( + chat_id = req.chat_id, + parse_mode = ?req.parse_mode, + text_len = req.text.chars().count(), + error = %desc, + "Telegram sendMessage error" + ); return Err(ChannelError::MessageSendFailed(format!("sendMessage failed: {desc}"))); } - resp.result - .ok_or_else(|| ChannelError::MessageSendFailed("sendMessage returned no result".into())) + let sent = resp + .result + .ok_or_else(|| ChannelError::MessageSendFailed("sendMessage returned no result".into()))?; + debug!( + chat_id = req.chat_id, + message_id = sent.message_id, + parse_mode = ?req.parse_mode, + text_len = req.text.chars().count(), + "Telegram message sent" + ); + Ok(sent) } /// `editMessageText` — edit an existing text message. @@ -159,6 +203,63 @@ impl TelegramApi { Ok(()) } + + /// `setMyCommands` — configure the Telegram slash-command menu. + pub async fn set_my_commands(&self, commands: Vec, scope: BotCommandScope) -> Result<(), ChannelError> { + let url = format!("{}/setMyCommands", self.base_url); + let req = SetMyCommandsRequest { commands, scope }; + + let resp: TgResponse = self + .client + .post(&url) + .json(&req) + .send() + .await + .map_err(|e| ChannelError::PlatformApi(format!("setMyCommands request failed: {e}")))? + .json() + .await + .map_err(|e| ChannelError::PlatformApi(format!("setMyCommands parse failed: {e}")))?; + + if !resp.ok { + let desc = resp.description.unwrap_or_default(); + return Err(ChannelError::PlatformApi(format!("setMyCommands failed: {desc}"))); + } + + Ok(()) + } + + /// `sendChatAction` — show "typing..." or similar lightweight status. + pub async fn send_chat_action( + &self, + chat_id: i64, + action: &str, + message_thread_id: Option, + ) -> Result<(), ChannelError> { + let url = format!("{}/sendChatAction", self.base_url); + let req = SendChatActionRequest { + chat_id, + message_thread_id, + action: action.to_owned(), + }; + + let resp: TgResponse = self + .client + .post(&url) + .json(&req) + .send() + .await + .map_err(|e| ChannelError::PlatformApi(format!("sendChatAction request failed: {e}")))? + .json() + .await + .map_err(|e| ChannelError::PlatformApi(format!("sendChatAction parse failed: {e}")))?; + + if !resp.ok { + let desc = resp.description.unwrap_or_default(); + warn!("sendChatAction error: {desc}"); + } + + Ok(()) + } } #[cfg(test)] diff --git a/crates/aionui-channel/src/plugins/telegram/plugin.rs b/crates/aionui-channel/src/plugins/telegram/plugin.rs index 7fe301c6c..2577cfe0c 100644 --- a/crates/aionui-channel/src/plugins/telegram/plugin.rs +++ b/crates/aionui-channel/src/plugins/telegram/plugin.rs @@ -1,4 +1,5 @@ -use std::sync::Arc; +use std::future::Future; +use std::sync::{Arc, Mutex}; use std::time::Duration; use reqwest::Client; @@ -17,8 +18,9 @@ use crate::types::{ use super::api::TelegramApi; use super::types::{ - AnswerCallbackQueryRequest, EditMessageTextRequest, InlineKeyboardButton, InlineKeyboardMarkup, KeyboardButton, - ReplyKeyboardMarkup, ReplyMarkup, SendMessageRequest, TgCallbackQuery, TgMessage, + AnswerCallbackQueryRequest, BotCommand, BotCommandScope, EditMessageTextRequest, InlineKeyboardButton, + InlineKeyboardMarkup, KeyboardButton, ReplyKeyboardMarkup, ReplyMarkup, SendMessageRequest, TgCallbackQuery, + TgMessage, TgUpdate, }; /// Long-polling timeout in seconds (Telegram recommends 20-30s). @@ -35,6 +37,7 @@ pub struct TelegramPlugin { callbacks: Option, poll_handle: Option>, shutdown_tx: Option>, + poll_runtime: Arc, } impl Default for TelegramPlugin { @@ -47,6 +50,7 @@ impl Default for TelegramPlugin { callbacks: None, poll_handle: None, shutdown_tx: None, + poll_runtime: Arc::new(PollRuntimeState::new(PluginStatus::Created)), } } } @@ -57,6 +61,205 @@ impl TelegramPlugin { } } +#[derive(Debug)] +struct PollRuntimeState { + inner: Mutex, +} + +#[derive(Debug)] +struct PollRuntimeStateInner { + status: PluginStatus, + last_error: Option, +} + +impl PollRuntimeState { + fn new(status: PluginStatus) -> Self { + Self { + inner: Mutex::new(PollRuntimeStateInner { + status, + last_error: None, + }), + } + } + + #[cfg(test)] + fn running() -> Self { + Self::new(PluginStatus::Running) + } + + fn set_status(&self, status: PluginStatus) { + let mut inner = self.inner.lock().unwrap(); + inner.status = status; + if status != PluginStatus::Error { + inner.last_error = None; + } + } + + fn set_error(&self, error: String) { + let mut inner = self.inner.lock().unwrap(); + inner.status = PluginStatus::Error; + inner.last_error = Some(error); + } + + fn status(&self) -> PluginStatus { + self.inner.lock().unwrap().status + } + + #[cfg(test)] + fn last_error(&self) -> Option { + self.inner.lock().unwrap().last_error.clone() + } +} + +fn default_bot_commands() -> Vec { + vec![ + BotCommand { + command: "status".into(), + description: "查看当前 Telegram 绑定和会话状态".into(), + }, + BotCommand { + command: "model".into(), + description: "按钮查看或切换当前 Agent 可用模型".into(), + }, + BotCommand { + command: "topic_info".into(), + description: "查看当前话题绑定的 Agent".into(), + }, + BotCommand { + command: "new_session".into(), + description: "新建当前入口的会话".into(), + }, + BotCommand { + command: "project".into(), + description: "查看当前项目".into(), + }, + BotCommand { + command: "run_info".into(), + description: "查看当前开发运行".into(), + }, + BotCommand { + command: "diff_summary".into(), + description: "查看变更和证据摘要".into(), + }, + BotCommand { + command: "test".into(), + description: "执行项目配置的单元测试门禁".into(), + }, + BotCommand { + command: "stop".into(), + description: "停止当前开发运行".into(), + }, + BotCommand { + command: "retry".into(), + description: "重试最近失败的质量门禁".into(), + }, + BotCommand { + command: "handoff".into(), + description: "获取 Web 接力入口".into(), + }, + BotCommand { + command: "help".into(), + description: "查看 Telegram 使用帮助".into(), + }, + ] +} + +fn private_bot_commands() -> Vec { + vec![ + BotCommand { + command: "status".into(), + description: "查看当前 Telegram 绑定和会话状态".into(), + }, + BotCommand { + command: "agent".into(), + description: "查看或切换 Telegram Agent".into(), + }, + BotCommand { + command: "model".into(), + description: "按钮查看或切换当前 Agent 可用模型".into(), + }, + BotCommand { + command: "team".into(), + description: "查看团队入口和当前团队会话说明".into(), + }, + BotCommand { + command: "team_help".into(), + description: "查看 Team 功能说明".into(), + }, + BotCommand { + command: "team_list".into(), + description: "查看团队列表入口".into(), + }, + BotCommand { + command: "team_select".into(), + description: "按钮选择或绑定团队会话".into(), + }, + BotCommand { + command: "team_new".into(), + description: "交互式创建真实 Team".into(), + }, + BotCommand { + command: "personal".into(), + description: "切换到个人会话".into(), + }, + BotCommand { + command: "personal_list".into(), + description: "按钮选择已有个人会话".into(), + }, + BotCommand { + command: "new_session".into(), + description: "新建个人会话".into(), + }, + BotCommand { + command: "project".into(), + description: "查看当前项目".into(), + }, + BotCommand { + command: "run_info".into(), + description: "查看当前开发运行".into(), + }, + BotCommand { + command: "diff_summary".into(), + description: "查看变更和证据摘要".into(), + }, + BotCommand { + command: "test".into(), + description: "执行项目配置的单元测试门禁".into(), + }, + BotCommand { + command: "stop".into(), + description: "停止当前开发运行".into(), + }, + BotCommand { + command: "retry".into(), + description: "重试最近失败的质量门禁".into(), + }, + BotCommand { + command: "handoff".into(), + description: "获取 Web 接力入口".into(), + }, + BotCommand { + command: "help".into(), + description: "查看 Telegram 使用帮助".into(), + }, + ] +} + +fn admin_group_bot_commands() -> Vec { + let mut commands = default_bot_commands(); + commands.extend([ + BotCommand { + command: "topic_bind".into(), + description: "管理员：绑定当前话题到指定 Agent".into(), + }, + BotCommand { + command: "topic_unbind".into(), + description: "管理员：解除当前话题的 Agent 绑定".into(), + }, + ]); + commands +} + #[async_trait::async_trait] impl ChannelPlugin for TelegramPlugin { async fn initialize(&mut self, config: PluginConfig, callbacks: PluginCallbacks) -> Result<(), ChannelError> { @@ -97,6 +300,20 @@ impl ChannelPlugin for TelegramPlugin { display_name: me.first_name.clone(), }); + let command_scopes = [ + (default_bot_commands(), BotCommandScope::Default), + (private_bot_commands(), BotCommandScope::AllPrivateChats), + (default_bot_commands(), BotCommandScope::AllGroupChats), + (admin_group_bot_commands(), BotCommandScope::AllChatAdministrators), + ]; + for (commands, scope) in command_scopes { + let command_count = commands.len(); + match api.set_my_commands(commands, scope).await { + Ok(()) => info!(?scope, command_count, "registered Telegram bot commands"), + Err(error) => warn!(error = %error, ?scope, "failed to register Telegram bot commands"), + } + } + info!( bot_id = me.id, bot_username = ?me.username, @@ -112,10 +329,13 @@ impl ChannelPlugin for TelegramPlugin { async fn start(&mut self) -> Result<(), ChannelError> { self.status = PluginStatus::Starting; - if self.poll_handle.is_some() { + if self.poll_handle.as_ref().is_some_and(|handle| !handle.is_finished()) { self.status = PluginStatus::Running; return Ok(()); } + if self.poll_handle.as_ref().is_some_and(|handle| handle.is_finished()) { + self.poll_handle.take(); + } let api = self .api @@ -129,11 +349,13 @@ impl ChannelPlugin for TelegramPlugin { let (shutdown_tx, shutdown_rx) = watch::channel(false); self.shutdown_tx = Some(shutdown_tx); + self.poll_runtime.set_status(PluginStatus::Running); self.poll_handle = Some(tokio::spawn(poll_loop( api, callbacks.message_tx, callbacks.confirm_tx, shutdown_rx, + Arc::clone(&self.poll_runtime), ))); self.status = PluginStatus::Running; @@ -157,6 +379,7 @@ impl ChannelPlugin for TelegramPlugin { self.api = None; self.callbacks = None; + self.poll_runtime.set_status(PluginStatus::Stopped); self.status = PluginStatus::Stopped; info!("Telegram plugin stopped"); Ok(()) @@ -180,11 +403,13 @@ impl ChannelPlugin for TelegramPlugin { let req = SendMessageRequest { chat_id: chat_id_num, + message_thread_id: message.topic.as_ref().map(|topic| topic.message_thread_id), text, parse_mode, reply_to_message_id: reply_to, reply_markup, disable_notification: message.silent, + disable_web_page_preview: Some(true), }; let sent = api.send_message(&req).await?; @@ -222,6 +447,24 @@ impl ChannelPlugin for TelegramPlugin { api.edit_message_text(&req).await } + async fn send_chat_action(&self, chat_id: &str, action: &str) -> Result<(), ChannelError> { + self.send_chat_action_in_topic(chat_id, action, None).await + } + + async fn send_chat_action_in_topic( + &self, + chat_id: &str, + action: &str, + message_thread_id: Option, + ) -> Result<(), ChannelError> { + let api = self + .api + .as_ref() + .ok_or_else(|| ChannelError::PlatformApi("Plugin not initialized".into()))?; + let chat_id_num = parse_chat_id(chat_id)?; + api.send_chat_action(chat_id_num, action, message_thread_id).await + } + fn active_user_count(&self) -> usize { // Tracked externally by ChannelManager via SessionManager 0 @@ -236,6 +479,15 @@ impl ChannelPlugin for TelegramPlugin { } fn status(&self) -> PluginStatus { + if self.status == PluginStatus::Running { + let runtime_status = self.poll_runtime.status(); + if runtime_status != PluginStatus::Running { + return runtime_status; + } + if self.poll_handle.as_ref().is_some_and(|handle| handle.is_finished()) { + return PluginStatus::Stopped; + } + } self.status } @@ -256,19 +508,55 @@ async fn poll_loop( api: Arc, message_tx: mpsc::Sender, confirm_tx: mpsc::Sender<(String, String)>, - mut shutdown_rx: watch::Receiver, + shutdown_rx: watch::Receiver, + runtime: Arc, ) { + poll_loop_with_get_updates( + |offset, timeout| { + let api = Arc::clone(&api); + async move { api.get_updates(offset, timeout).await } + }, + message_tx, + confirm_tx, + shutdown_rx, + runtime, + Some(Arc::clone(&api)), + TELEGRAM_MAX_RECONNECT_ATTEMPTS, + backoff_delay, + ) + .await; +} + +#[allow( + clippy::too_many_arguments, + reason = "the polling seam keeps transport, channels, shutdown, callback API, and retry policy independently injectable in tests" +)] +async fn poll_loop_with_get_updates( + mut get_updates: GetUpdates, + message_tx: mpsc::Sender, + confirm_tx: mpsc::Sender<(String, String)>, + mut shutdown_rx: watch::Receiver, + runtime: Arc, + callback_api: Option>, + max_reconnect_attempts: u32, + backoff_delay_for_attempt: impl Fn(u32) -> Duration, +) where + GetUpdates: FnMut(Option, u32) -> GetUpdatesFuture, + GetUpdatesFuture: Future, ChannelError>>, +{ let mut offset: Option = None; let mut consecutive_errors: u32 = 0; + let mut stopped_by_shutdown = false; loop { // Check shutdown signal if *shutdown_rx.borrow() { debug!("Telegram poll loop received shutdown signal"); + stopped_by_shutdown = true; break; } - match api.get_updates(offset, POLL_TIMEOUT).await { + match get_updates(offset, POLL_TIMEOUT).await { Ok(updates) => { consecutive_errors = 0; @@ -277,30 +565,37 @@ async fn poll_loop( offset = Some(update.update_id + 1); if let Some(cb) = update.callback_query { - handle_callback_query(&api, &cb, &message_tx, &confirm_tx).await; + if let Some(api) = callback_api.as_deref() { + handle_callback_query(api, &cb, &message_tx, &confirm_tx).await; + } } else if let Some(msg) = update.message { - handle_message(&msg, &message_tx).await; + handle_message(callback_api.as_deref(), &msg, &message_tx).await; } } } Err(e) => { consecutive_errors += 1; + let error = e.to_string(); warn!( error = %e, consecutive_errors, "Telegram poll error" ); - if consecutive_errors >= TELEGRAM_MAX_RECONNECT_ATTEMPTS { + if consecutive_errors >= max_reconnect_attempts { + runtime.set_error(format!( + "Telegram polling stopped after {consecutive_errors} consecutive errors: {error}" + )); error!("Telegram max reconnect attempts reached, stopping poll loop"); break; } - let backoff = backoff_delay(consecutive_errors); + let backoff = backoff_delay_for_attempt(consecutive_errors); tokio::select! { _ = tokio::time::sleep(backoff) => {} _ = shutdown_rx.changed() => { debug!("Telegram poll loop shutdown during backoff"); + stopped_by_shutdown = true; break; } } @@ -308,6 +603,9 @@ async fn poll_loop( } } + if stopped_by_shutdown && runtime.status() == PluginStatus::Running { + runtime.set_status(PluginStatus::Stopped); + } debug!("Telegram poll loop exited"); } @@ -372,6 +670,11 @@ async fn handle_callback_query( }); let msg = UnifiedIncomingMessage { + topic: cb + .message + .as_ref() + .and_then(|message| message.message_thread_id) + .map(|message_thread_id| crate::types::ChannelTopicContext { message_thread_id }), id: cb.id.clone(), platform: PluginType::Telegram, chat_id: chat_id.to_string(), @@ -399,7 +702,7 @@ async fn handle_callback_query( } /// Handle a regular text/media message from Telegram. -async fn handle_message(msg: &TgMessage, message_tx: &mpsc::Sender) { +async fn handle_message(api: Option<&TelegramApi>, msg: &TgMessage, message_tx: &mpsc::Sender) { let from = match &msg.from { Some(u) => u, None => return, // system messages without a sender @@ -416,7 +719,23 @@ async fn handle_message(msg: &TgMessage, message_tx: &mpsc::Sender Option { } let category = match parts[0] { + "s" => ActionCategory::System, "platform" => ActionCategory::Platform, "system" => ActionCategory::System, "chat" => ActionCategory::Chat, _ => return None, }; - let action = parts[1].to_string(); + let action = match parts[1] { + "ms" => "model.select", + "mc" => "model.clear", + other => other, + } + .to_string(); let params = if parts.len() == 3 && !parts[2].is_empty() { let mut map = std::collections::HashMap::new(); @@ -666,13 +991,21 @@ fn action_category_prefix(action: &str) -> &'static str { /// /// This is the inverse of [`parse_callback_data`]. fn format_callback_data(btn: &ActionButton) -> String { - let category = action_category_prefix(&btn.action); + let category = match btn.action.as_str() { + "model.select" | "model.clear" => "s", + _ => action_category_prefix(&btn.action), + }; + let action = match btn.action.as_str() { + "model.select" => "ms", + "model.clear" => "mc", + other => other, + }; match &btn.params { Some(params) if !params.is_empty() => { let encoded: Vec = params.iter().map(|(k, v)| format!("{k}={v}")).collect(); - format!("{category}:{}:{}", btn.action, encoded.join(",")) + format!("{category}:{action}:{}", encoded.join(",")) } - _ => format!("{category}:{}", btn.action), + _ => format!("{category}:{action}"), } } @@ -687,6 +1020,41 @@ fn parse_chat_id(chat_id: &str) -> Result { .map_err(|_| ChannelError::InvalidConfig(format!("Invalid chat_id: {chat_id}"))) } +#[cfg(test)] +mod callback_data_tests { + use super::*; + use std::collections::HashMap; + + #[test] + fn model_select_callback_uses_compact_encoding_that_fits_telegram_limit() { + let button = ActionButton { + label: "openai-codex:gpt-5.3-codex-spark".into(), + action: "model.select".into(), + params: Some(HashMap::from([ + ("p".into(), "hermes-1".into()), + ("m".into(), "openai-codex:gpt-5.3-codex-spark".into()), + ])), + }; + + let encoded = format_callback_data(&button); + assert!( + encoded.len() <= 64, + "callback_data too long for Telegram: len={} data={encoded}", + encoded.len() + ); + + let parsed = parse_callback_data(&encoded).expect("callback should parse"); + assert_eq!(parsed.category, ActionCategory::System); + assert_eq!(parsed.action, "model.select"); + let params = parsed.params.expect("params should parse"); + assert_eq!(params.get("p").map(String::as_str), Some("hermes-1")); + assert_eq!( + params.get("m").map(String::as_str), + Some("openai-codex:gpt-5.3-codex-spark") + ); + } +} + /// Truncate a message to the platform limit, appending "..." if truncated. fn truncate_message(text: &str, limit: usize) -> String { if text.len() <= limit { @@ -981,6 +1349,7 @@ mod tests { media_actions: None, reply_to_message_id: None, silent: None, + topic: None, }; let markup = build_reply_markup(&msg); assert!(matches!(markup, Some(ReplyMarkup::InlineKeyboard(_)))); @@ -1004,6 +1373,7 @@ mod tests { media_actions: None, reply_to_message_id: None, silent: None, + topic: None, }; let markup = build_reply_markup(&msg); assert!(matches!(markup, Some(ReplyMarkup::ReplyKeyboard(_)))); @@ -1023,6 +1393,7 @@ mod tests { media_actions: None, reply_to_message_id: None, silent: None, + topic: None, }; assert!(build_reply_markup(&msg).is_none()); } @@ -1200,6 +1571,103 @@ mod tests { assert_eq!(plugin.active_user_count(), 0); } + #[test] + fn telegram_default_commands_are_safe_in_bound_group_topics() { + let commands = default_bot_commands(); + let names: Vec<_> = commands.iter().map(|cmd| cmd.command.as_str()).collect(); + assert!(names.contains(&"status")); + assert!(names.contains(&"topic_info")); + assert!(names.contains(&"model")); + assert!(names.contains(&"new_session")); + assert!(names.contains(&"help")); + assert!(names.contains(&"project")); + assert!(names.contains(&"run_info")); + assert!(names.contains(&"diff_summary")); + assert!(names.contains(&"test")); + assert!(names.contains(&"stop")); + assert!(names.contains(&"retry")); + assert!(names.contains(&"handoff")); + assert!(!names.iter().any(|name| name.starts_with("team"))); + assert!(!names.contains(&"agent")); + assert!(!names.iter().any(|name| name.starts_with("personal"))); + assert!(!names.contains(&"topic_bind")); + assert!(!names.contains(&"topic_unbind")); + } + + #[test] + fn telegram_private_commands_keep_full_bot_workflow() { + let commands = private_bot_commands(); + let names: Vec<_> = commands.iter().map(|cmd| cmd.command.as_str()).collect(); + assert!(names.contains(&"agent")); + assert!(names.contains(&"team")); + assert!(names.contains(&"team_help")); + assert!(names.contains(&"team_list")); + assert!(names.contains(&"team_select")); + assert!(names.contains(&"team_new")); + assert!(names.contains(&"personal")); + assert!(names.contains(&"personal_list")); + } + + #[test] + fn approval_callback_stays_within_telegram_limit() { + let button = ActionButton { + label: "Allow once".into(), + action: "approval.resolve".into(), + params: Some(HashMap::from([ + ("id".into(), "019f7b93e1b27c42".into()), + ("o".into(), "7".into()), + ])), + }; + let callback = format_callback_data(&button); + assert!(callback.len() <= 64, "callback too long: {callback}"); + let parsed = parse_callback_data(&callback).unwrap(); + assert_eq!(parsed.action, "approval.resolve"); + } + + #[test] + fn telegram_admin_commands_add_topic_management_without_team_workflow() { + let commands = admin_group_bot_commands(); + let names: Vec<_> = commands.iter().map(|cmd| cmd.command.as_str()).collect(); + assert!(names.contains(&"status")); + assert!(names.contains(&"topic_bind")); + assert!(names.contains(&"topic_unbind")); + assert!(names.contains(&"topic_info")); + assert!(!names.iter().any(|name| name.starts_with("team"))); + assert!(!names.contains(&"agent")); + } + + #[tokio::test] + async fn poll_loop_marks_runtime_error_after_reconnect_attempts_are_exhausted() { + let (message_tx, _message_rx) = mpsc::channel(1); + let (confirm_tx, _confirm_rx) = mpsc::channel(1); + let (_shutdown_tx, shutdown_rx) = watch::channel(false); + let runtime = Arc::new(PollRuntimeState::running()); + + poll_loop_with_get_updates( + |_offset, _timeout| async { + Err::, ChannelError>(ChannelError::PlatformApi( + "network unavailable".into(), + )) + }, + message_tx, + confirm_tx, + shutdown_rx, + Arc::clone(&runtime), + None, + 1, + |_| Duration::from_millis(0), + ) + .await; + + assert_eq!(runtime.status(), PluginStatus::Error); + assert!( + runtime + .last_error() + .as_deref() + .is_some_and(|error| error.contains("network unavailable")) + ); + } + // -- Test helpers ------------------------------------------------------- fn make_tg_message( @@ -1228,6 +1696,7 @@ mod tests { use super::super::types::TgChat; TgMessage { message_id: 1, + message_thread_id: None, from: None, chat: TgChat { id: 1, diff --git a/crates/aionui-channel/src/plugins/telegram/types.rs b/crates/aionui-channel/src/plugins/telegram/types.rs index 70a1fe962..aa4061f91 100644 --- a/crates/aionui-channel/src/plugins/telegram/types.rs +++ b/crates/aionui-channel/src/plugins/telegram/types.rs @@ -46,6 +46,8 @@ pub(crate) struct TgUpdate { #[derive(Debug, Clone, Deserialize)] pub(crate) struct TgMessage { pub message_id: i64, + #[serde(default)] + pub message_thread_id: Option, pub from: Option, pub chat: TgChat, pub date: i64, @@ -147,6 +149,8 @@ pub(crate) struct TgCallbackQuery { #[derive(Debug, Clone, Serialize)] pub(crate) struct SendMessageRequest { pub chat_id: i64, + #[serde(skip_serializing_if = "Option::is_none")] + pub message_thread_id: Option, pub text: String, #[serde(skip_serializing_if = "Option::is_none")] pub parse_mode: Option, @@ -156,6 +160,8 @@ pub(crate) struct SendMessageRequest { pub reply_markup: Option, #[serde(skip_serializing_if = "Option::is_none")] pub disable_notification: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub disable_web_page_preview: Option, } /// Request body for `editMessageText`. @@ -180,6 +186,39 @@ pub(crate) struct AnswerCallbackQueryRequest { pub show_alert: Option, } +/// Telegram bot command displayed in the `/` menu. +#[derive(Debug, Clone, Serialize)] +pub(crate) struct BotCommand { + pub command: String, + pub description: String, +} + +/// Telegram audience used to resolve the native `/` command menu. +#[derive(Debug, Clone, Copy, Serialize)] +#[serde(tag = "type", rename_all = "snake_case")] +pub(crate) enum BotCommandScope { + Default, + AllPrivateChats, + AllGroupChats, + AllChatAdministrators, +} + +/// Request body for `setMyCommands`. +#[derive(Debug, Clone, Serialize)] +pub(crate) struct SetMyCommandsRequest { + pub commands: Vec, + pub scope: BotCommandScope, +} + +/// Request body for `sendChatAction`. +#[derive(Debug, Clone, Serialize)] +pub(crate) struct SendChatActionRequest { + pub chat_id: i64, + #[serde(skip_serializing_if = "Option::is_none")] + pub message_thread_id: Option, + pub action: String, +} + // --------------------------------------------------------------------------- // Keyboard / Inline markup // --------------------------------------------------------------------------- @@ -327,19 +366,69 @@ mod tests { fn send_message_request_serializes() { let req = SendMessageRequest { chat_id: 42, + message_thread_id: None, text: "Hello".into(), parse_mode: Some("HTML".into()), reply_to_message_id: None, reply_markup: None, disable_notification: None, + disable_web_page_preview: Some(true), }; let json = serde_json::to_value(&req).unwrap(); assert_eq!(json["chat_id"], 42); assert_eq!(json["text"], "Hello"); assert_eq!(json["parse_mode"], "HTML"); + assert_eq!(json["disable_web_page_preview"], true); assert!(json.get("reply_to_message_id").is_none()); } + #[test] + fn send_message_request_serializes_forum_thread() { + let req = SendMessageRequest { + chat_id: -1003977604085, + message_thread_id: Some(3), + text: "reply".into(), + parse_mode: None, + reply_to_message_id: None, + reply_markup: None, + disable_notification: None, + disable_web_page_preview: None, + }; + + assert_eq!(serde_json::to_value(req).unwrap()["message_thread_id"], 3); + } + + #[test] + fn set_my_commands_request_serializes_group_scope() { + let req = SetMyCommandsRequest { + commands: vec![BotCommand { + command: "help".into(), + description: "查看帮助".into(), + }], + scope: BotCommandScope::AllGroupChats, + }; + + let json = serde_json::to_value(req).unwrap(); + assert_eq!(json["scope"]["type"], "all_group_chats"); + assert_eq!(json["commands"][0]["command"], "help"); + } + + #[test] + fn bot_command_scope_serializes_supported_menu_audiences() { + assert_eq!( + serde_json::to_value(BotCommandScope::Default).unwrap()["type"], + "default" + ); + assert_eq!( + serde_json::to_value(BotCommandScope::AllPrivateChats).unwrap()["type"], + "all_private_chats" + ); + assert_eq!( + serde_json::to_value(BotCommandScope::AllChatAdministrators).unwrap()["type"], + "all_chat_administrators" + ); + } + #[test] fn inline_keyboard_markup_serializes() { let markup = ReplyMarkup::InlineKeyboard(InlineKeyboardMarkup { @@ -452,4 +541,18 @@ mod tests { assert_eq!(sticker.file_id, "sticker_1"); assert_eq!(sticker.emoji.as_deref(), Some("😀")); } + + #[test] + fn forum_message_deserializes_message_thread_id() { + let message: TgMessage = serde_json::from_value(json!({ + "message_id": 9, + "message_thread_id": 3, + "date": 0, + "chat": { "id": -1003977604085i64, "type": "supergroup" }, + "text": "/topic_info" + })) + .unwrap(); + + assert_eq!(message.message_thread_id, Some(3)); + } } diff --git a/crates/aionui-channel/src/plugins/weixin/plugin.rs b/crates/aionui-channel/src/plugins/weixin/plugin.rs index d832c3bf9..e7653aa82 100644 --- a/crates/aionui-channel/src/plugins/weixin/plugin.rs +++ b/crates/aionui-channel/src/plugins/weixin/plugin.rs @@ -324,6 +324,7 @@ async fn handle_message( }; let unified = UnifiedIncomingMessage { + topic: None, id: msg.msg_id.clone().unwrap_or_default(), platform: PluginType::Weixin, chat_id: from_user_id.clone(), diff --git a/crates/aionui-channel/src/session.rs b/crates/aionui-channel/src/session.rs index 2184849bf..b0324028a 100644 --- a/crates/aionui-channel/src/session.rs +++ b/crates/aionui-channel/src/session.rs @@ -3,6 +3,7 @@ use std::sync::Arc; use aionui_common::{generate_id, now_ms}; use aionui_db::IChannelRepository; use aionui_db::models::AssistantSessionRow; +use aionui_db::models::{ChannelTopicModelOverrideRow, TelegramTopicBindingRow}; use tracing::{debug, info}; use crate::error::ChannelError; @@ -22,6 +23,106 @@ impl SessionManager { Self { repo } } + pub async fn get_topic_binding( + &self, + chat_id: &str, + message_thread_id: i64, + ) -> Result, ChannelError> { + Ok(self.repo.get_telegram_topic_binding(chat_id, message_thread_id).await?) + } + + pub async fn bind_topic( + &self, + chat_id: &str, + message_thread_id: i64, + agent_id: &str, + bound_by_user_id: &str, + ) -> Result<(), ChannelError> { + let existing = self.repo.get_telegram_topic_binding(chat_id, message_thread_id).await?; + let now = now_ms(); + self.repo + .upsert_telegram_topic_binding(&TelegramTopicBindingRow { + chat_id: chat_id.to_owned(), + message_thread_id, + agent_id: agent_id.to_owned(), + bound_by_user_id: bound_by_user_id.to_owned(), + created_at: now, + updated_at: now, + }) + .await?; + if existing.as_ref().is_some_and(|binding| binding.agent_id != agent_id) { + self.repo.delete_sessions_by_topic(chat_id, message_thread_id).await?; + self.repo + .delete_topic_model_overrides(chat_id, message_thread_id) + .await?; + } + Ok(()) + } + + pub async fn unbind_topic(&self, chat_id: &str, message_thread_id: i64) -> Result<(), ChannelError> { + self.repo + .delete_telegram_topic_binding(chat_id, message_thread_id) + .await?; + self.repo + .delete_topic_model_overrides(chat_id, message_thread_id) + .await?; + self.repo.delete_sessions_by_topic(chat_id, message_thread_id).await?; + Ok(()) + } + + pub async fn set_topic_model( + &self, + internal_user_id: &str, + chat_id: &str, + message_thread_id: i64, + agent_id: &str, + provider_id: &str, + model: &str, + ) -> Result<(), ChannelError> { + self.repo + .upsert_topic_model_override(&ChannelTopicModelOverrideRow { + platform: "telegram".into(), + internal_user_id: internal_user_id.into(), + chat_id: chat_id.into(), + message_thread_id, + agent_id: agent_id.into(), + provider_id: provider_id.into(), + model: model.into(), + updated_at: now_ms(), + }) + .await?; + self.repo + .delete_topic_session(internal_user_id, chat_id, message_thread_id) + .await?; + Ok(()) + } + + #[allow(clippy::too_many_arguments)] + pub async fn reset_topic_session( + &self, + user_id: &str, + chat_id: &str, + message_thread_id: i64, + agent_type: &str, + agent_id: &str, + backend: Option<&str>, + workspace: Option<&str>, + ) -> Result { + self.repo + .delete_topic_session(user_id, chat_id, message_thread_id) + .await?; + self.get_or_create_topic_session( + user_id, + chat_id, + message_thread_id, + agent_type, + agent_id, + backend, + workspace, + ) + .await + } + /// Finds an existing session for the user+chat pair, or creates one. /// /// - If found: updates `last_activity` and returns the existing session. @@ -44,6 +145,11 @@ impl SessionManager { conversation_id: None, workspace: workspace.map(String::from), chat_id: Some(chat_id.to_owned()), + message_thread_id: None, + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, created_at: now, last_activity: now, }; @@ -60,6 +166,44 @@ impl SessionManager { Ok(session) } + #[allow(clippy::too_many_arguments)] + pub async fn get_or_create_topic_session( + &self, + user_id: &str, + chat_id: &str, + message_thread_id: i64, + agent_type: &str, + agent_id: &str, + backend: Option<&str>, + workspace: Option<&str>, + ) -> Result { + let now = now_ms(); + let model_override = self + .repo + .get_topic_model_override("telegram", user_id, chat_id, message_thread_id) + .await? + .filter(|value| value.agent_id == agent_id); + let new_row = AssistantSessionRow { + id: generate_id(), + user_id: user_id.to_owned(), + agent_type: agent_type.to_owned(), + conversation_id: None, + workspace: workspace.map(String::from), + chat_id: Some(chat_id.to_owned()), + message_thread_id: Some(message_thread_id), + created_at: now, + last_activity: now, + bound_agent_id: Some(agent_id.to_owned()), + bound_backend: backend.map(str::to_owned), + bound_provider_id: model_override.as_ref().map(|value| value.provider_id.clone()), + bound_model: model_override.as_ref().map(|value| value.model.clone()), + }; + Ok(self + .repo + .get_or_create_topic_session(user_id, chat_id, message_thread_id, &new_row) + .await?) + } + /// Returns all active sessions. pub async fn get_active_sessions(&self) -> Result, ChannelError> { let sessions = self.repo.get_all_sessions().await?; @@ -89,6 +233,11 @@ impl SessionManager { conversation_id: None, workspace: workspace.map(String::from), chat_id: Some(chat_id.to_owned()), + message_thread_id: None, + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, created_at: now, last_activity: now, }; diff --git a/crates/aionui-channel/src/stream_relay.rs b/crates/aionui-channel/src/stream_relay.rs index 892be0f82..7eeec64fa 100644 --- a/crates/aionui-channel/src/stream_relay.rs +++ b/crates/aionui-channel/src/stream_relay.rs @@ -2,12 +2,14 @@ use std::sync::Arc; use std::time::{Duration, Instant}; use aionui_ai_agent::AgentStreamEvent; +use aionui_common::Confirmation; use async_trait::async_trait; use tokio::sync::broadcast; use tracing::{debug, error, info, warn}; +use crate::approval::{ChannelApprovalContext, ChannelApprovalPort}; use crate::error::ChannelError; -use crate::formatter::format_text_for_platform; +use crate::formatter::format_outgoing_text_for_platform; use crate::message_service::{ChannelMessageService, StreamAction}; use crate::types::{OutgoingMessageType, PluginType, UnifiedOutgoingMessage}; @@ -39,6 +41,20 @@ pub trait ChannelSender: Send + Sync { message_id: &str, message: UnifiedOutgoingMessage, ) -> Result<(), ChannelError>; + + async fn send_chat_action(&self, _plugin_id: &str, _chat_id: &str, _action: &str) -> Result<(), ChannelError> { + Ok(()) + } + + async fn send_chat_action_in_topic( + &self, + plugin_id: &str, + chat_id: &str, + action: &str, + _message_thread_id: Option, + ) -> Result<(), ChannelError> { + self.send_chat_action(plugin_id, chat_id, action).await + } } /// Relays agent stream events to an IM platform. @@ -51,11 +67,72 @@ pub trait ChannelSender: Send + Sync { pub struct ChannelStreamRelay { config: RelayConfig, sender: Arc, + topic: Option, + approval: Option<(Arc, ChannelApprovalContext)>, } impl ChannelStreamRelay { pub fn new(config: RelayConfig, sender: Arc) -> Self { - Self { config, sender } + Self { + config, + sender, + topic: None, + approval: None, + } + } + + pub fn with_topic(mut self, topic: Option) -> Self { + self.topic = topic; + self + } + + pub fn with_approval_port(mut self, port: Arc, context: ChannelApprovalContext) -> Self { + self.approval = Some((port, context)); + self + } + + fn attach_topic(&self, mut message: UnifiedOutgoingMessage) -> UnifiedOutgoingMessage { + message.topic = self.topic.clone(); + message + } + + async fn relay_approval(&self, event: &AgentStreamEvent) -> bool { + let AgentStreamEvent::AcpPermission(data) = event else { + return false; + }; + if self.config.platform != PluginType::Telegram { + return false; + } + let Some((port, context)) = &self.approval else { + warn!("Telegram permission event arrived without an approval port"); + return true; + }; + let Some(confirmation) = data.as_confirmation() else { + return true; + }; + let approval_id = match port.create(context.clone(), confirmation.clone()).await { + Ok(id) => id, + Err(error) => { + error!(error = %error, "failed to persist Telegram approval"); + let message = self.attach_topic(ChannelMessageService::build_streaming_message( + "❌ 无法创建审批请求，请在 Web 控制台检查运行状态。", + )); + let _ = self + .sender + .send_message(&self.config.plugin_id, &self.config.chat_id, message) + .await; + return true; + } + }; + let message = self.attach_topic(build_approval_message(&approval_id, &confirmation)); + if let Err(error) = self + .sender + .send_message(&self.config.plugin_id, &self.config.chat_id, message) + .await + { + error!(error = %error, approval_id, "failed to send Telegram approval buttons"); + } + true } /// Run the relay loop until the agent stream ends. @@ -74,66 +151,78 @@ impl ChannelStreamRelay { loop { match rx.recv().await { - Ok(event) => match ChannelMessageService::process_stream_event(&event) { - Some(StreamAction::AppendText(chunk)) => { - text_buffer.push_str(&chunk); - has_content = true; - } - Some(StreamAction::Thinking(_)) => {} - Some(StreamAction::ToolCall { .. }) if has_content && !text_buffer.trim().is_empty() => { - let formatted = format_text_for_platform(&text_buffer, self.config.platform); - let flush_msg = ChannelMessageService::build_streaming_message(&formatted); - let _ = self - .sender - .send_message(&self.config.plugin_id, &self.config.chat_id, flush_msg) - .await; - text_buffer.clear(); - has_content = false; + Ok(event) => { + if self.relay_approval(&event).await { + continue; } - Some(StreamAction::ToolCall { .. }) => {} - Some(StreamAction::Finish) => { - if has_content && !text_buffer.trim().is_empty() { - let formatted = format_text_for_platform(&text_buffer, self.config.platform); - let final_msg = ChannelMessageService::build_final_message(&formatted); + match ChannelMessageService::process_stream_event(&event) { + Some(StreamAction::AppendText(chunk)) => { + text_buffer.push_str(&chunk); + has_content = true; + } + Some(StreamAction::Thinking(_)) => {} + Some(StreamAction::ToolCall { .. }) if has_content && !text_buffer.trim().is_empty() => { + let formatted = format_outgoing_text_for_platform(&text_buffer, self.config.platform); + let mut flush_msg = + self.attach_topic(ChannelMessageService::build_streaming_message(&formatted.text)); + flush_msg.parse_mode = formatted.parse_mode; let _ = self .sender - .send_message(&self.config.plugin_id, &self.config.chat_id, final_msg) + .send_message(&self.config.plugin_id, &self.config.chat_id, flush_msg) .await; + text_buffer.clear(); + has_content = false; } - info!( - plugin_id = %self.config.plugin_id, - chat_id = %self.config.chat_id, - text_len = text_buffer.len(), - "channel stream relay finished (weixin)" - ); - break; - } - Some(StreamAction::Error(msg)) => { - let error_msg = UnifiedOutgoingMessage { - message_type: OutgoingMessageType::Text, - text: Some(format!("\u{274c} {msg}")), - parse_mode: None, - buttons: None, - keyboard: None, - image_url: None, - file_url: None, - file_name: None, - media_actions: None, - reply_to_message_id: None, - silent: None, - }; - let _ = self - .sender - .send_message(&self.config.plugin_id, &self.config.chat_id, error_msg) - .await; - break; + Some(StreamAction::ToolCall { .. }) => {} + Some(StreamAction::Finish) => { + if has_content && !text_buffer.trim().is_empty() { + let formatted = format_outgoing_text_for_platform(&text_buffer, self.config.platform); + let mut final_msg = + self.attach_topic(ChannelMessageService::build_final_message(&formatted.text)); + final_msg.parse_mode = formatted.parse_mode; + let _ = self + .sender + .send_message(&self.config.plugin_id, &self.config.chat_id, final_msg) + .await; + } + info!( + plugin_id = %self.config.plugin_id, + chat_id = %self.config.chat_id, + text_len = text_buffer.len(), + "channel stream relay finished (weixin)" + ); + break; + } + Some(StreamAction::Error(msg)) => { + let error_msg = UnifiedOutgoingMessage { + message_type: OutgoingMessageType::Text, + text: Some(format!("\u{274c} {msg}")), + parse_mode: None, + buttons: None, + keyboard: None, + image_url: None, + file_url: None, + file_name: None, + topic: self.topic.clone(), + media_actions: None, + reply_to_message_id: None, + silent: None, + }; + let _ = self + .sender + .send_message(&self.config.plugin_id, &self.config.chat_id, error_msg) + .await; + break; + } + None => {} } - None => {} - }, + } Err(broadcast::error::RecvError::Closed) => { if has_content && !text_buffer.trim().is_empty() { - let formatted = format_text_for_platform(&text_buffer, self.config.platform); - let final_msg = ChannelMessageService::build_final_message(&formatted); + let formatted = format_outgoing_text_for_platform(&text_buffer, self.config.platform); + let mut final_msg = + self.attach_topic(ChannelMessageService::build_final_message(&formatted.text)); + final_msg.parse_mode = formatted.parse_mode; let _ = self .sender .send_message(&self.config.plugin_id, &self.config.chat_id, final_msg) @@ -158,7 +247,7 @@ impl ChannelStreamRelay { async fn run_editable(self, mut rx: broadcast::Receiver) { let throttle = Duration::from_millis(self.config.throttle_ms); - let thinking_msg = ChannelMessageService::build_thinking_message(); + let thinking_msg = self.attach_topic(ChannelMessageService::build_thinking_message()); let thinking_msg_id = match self .sender .send_message(&self.config.plugin_id, &self.config.chat_id, thinking_msg) @@ -177,65 +266,75 @@ impl ChannelStreamRelay { loop { match rx.recv().await { - Ok(event) => match ChannelMessageService::process_stream_event(&event) { - Some(StreamAction::AppendText(chunk)) => { - text_buffer.push_str(&chunk); - has_content = true; - if last_edit.elapsed() >= throttle { - let formatted = format_text_for_platform(&text_buffer, self.config.platform); - let msg = ChannelMessageService::build_streaming_message(&formatted); + Ok(event) => { + if self.relay_approval(&event).await { + continue; + } + match ChannelMessageService::process_stream_event(&event) { + Some(StreamAction::AppendText(chunk)) => { + text_buffer.push_str(&chunk); + has_content = true; + if last_edit.elapsed() >= throttle { + let formatted = format_outgoing_text_for_platform(&text_buffer, self.config.platform); + let mut msg = + self.attach_topic(ChannelMessageService::build_streaming_message(&formatted.text)); + msg.parse_mode = formatted.parse_mode; + let _ = self + .sender + .edit_message(&self.config.plugin_id, &self.config.chat_id, &thinking_msg_id, msg) + .await; + last_edit = Instant::now(); + } + } + Some(StreamAction::Thinking(_)) => {} + Some(StreamAction::ToolCall { name, .. }) => { + let msg = self.attach_topic(ChannelMessageService::build_streaming_message(&format!( + "\u{23f3} {name}..." + ))); let _ = self .sender .edit_message(&self.config.plugin_id, &self.config.chat_id, &thinking_msg_id, msg) .await; - last_edit = Instant::now(); } + Some(StreamAction::Finish) => { + self.send_final_edit(&text_buffer, has_content, &thinking_msg_id).await; + info!( + plugin_id = %self.config.plugin_id, + chat_id = %self.config.chat_id, + text_len = text_buffer.len(), + "channel stream relay finished" + ); + break; + } + Some(StreamAction::Error(msg)) => { + let error_msg = UnifiedOutgoingMessage { + message_type: OutgoingMessageType::Text, + text: Some(format!("\u{274c} {msg}")), + parse_mode: None, + buttons: None, + keyboard: None, + image_url: None, + file_url: None, + file_name: None, + topic: self.topic.clone(), + media_actions: None, + reply_to_message_id: None, + silent: None, + }; + let _ = self + .sender + .edit_message( + &self.config.plugin_id, + &self.config.chat_id, + &thinking_msg_id, + error_msg, + ) + .await; + break; + } + None => {} } - Some(StreamAction::Thinking(_)) => {} - Some(StreamAction::ToolCall { name, .. }) => { - let msg = ChannelMessageService::build_streaming_message(&format!("\u{23f3} {name}...")); - let _ = self - .sender - .edit_message(&self.config.plugin_id, &self.config.chat_id, &thinking_msg_id, msg) - .await; - } - Some(StreamAction::Finish) => { - self.send_final_edit(&text_buffer, has_content, &thinking_msg_id).await; - info!( - plugin_id = %self.config.plugin_id, - chat_id = %self.config.chat_id, - text_len = text_buffer.len(), - "channel stream relay finished" - ); - break; - } - Some(StreamAction::Error(msg)) => { - let error_msg = UnifiedOutgoingMessage { - message_type: OutgoingMessageType::Text, - text: Some(format!("\u{274c} {msg}")), - parse_mode: None, - buttons: None, - keyboard: None, - image_url: None, - file_url: None, - file_name: None, - media_actions: None, - reply_to_message_id: None, - silent: None, - }; - let _ = self - .sender - .edit_message( - &self.config.plugin_id, - &self.config.chat_id, - &thinking_msg_id, - error_msg, - ) - .await; - break; - } - None => {} - }, + } Err(broadcast::error::RecvError::Closed) => { warn!("channel stream relay: broadcast closed without terminal event"); self.send_final_edit(&text_buffer, has_content, &thinking_msg_id).await; @@ -256,8 +355,9 @@ impl ChannelStreamRelay { async fn send_final_edit(&self, text_buffer: &str, has_content: bool, msg_id: &str) { if has_content { - let formatted = format_text_for_platform(text_buffer, self.config.platform); - let final_msg = ChannelMessageService::build_final_message(&formatted); + let formatted = format_outgoing_text_for_platform(text_buffer, self.config.platform); + let mut final_msg = self.attach_topic(ChannelMessageService::build_final_message(&formatted.text)); + final_msg.parse_mode = formatted.parse_mode; let _ = self .sender .edit_message(&self.config.plugin_id, &self.config.chat_id, msg_id, final_msg) @@ -266,6 +366,49 @@ impl ChannelStreamRelay { } } +fn build_approval_message(approval_id: &str, confirmation: &Confirmation) -> UnifiedOutgoingMessage { + let title = confirmation.title.as_deref().unwrap_or("Agent 请求执行操作"); + let mut description = confirmation.description.trim().to_owned(); + if description.chars().count() > 1_500 { + description = description.chars().take(1_500).collect::() + "…"; + } + let risk = match confirmation.command_type.as_deref() { + Some("read") => "低", + Some("edit") | Some("execute") => "高", + _ => "中", + }; + let text = format!("🔐 待审批操作\n{title}\n风险：{risk}\n审批 ID：{approval_id}\n\n{description}"); + let buttons = confirmation + .options + .iter() + .enumerate() + .map(|(index, option)| { + vec![crate::types::ActionButton { + label: option.label.clone(), + action: "approval.resolve".into(), + params: Some(std::collections::HashMap::from([ + ("id".into(), approval_id.to_owned()), + ("o".into(), index.to_string()), + ])), + }] + }) + .collect(); + UnifiedOutgoingMessage { + message_type: OutgoingMessageType::Text, + text: Some(text), + parse_mode: None, + buttons: Some(buttons), + keyboard: None, + image_url: None, + file_url: None, + file_name: None, + media_actions: None, + reply_to_message_id: None, + silent: None, + topic: None, + } +} + /// WeChat / WeCom channels cannot edit messages in place — each reply must be /// a new send. The relay uses this predicate to flush pending assistant text /// before rendering silent/non-text events (tool calls etc.) to avoid either diff --git a/crates/aionui-channel/src/team_event_relay.rs b/crates/aionui-channel/src/team_event_relay.rs new file mode 100644 index 000000000..93f013cc0 --- /dev/null +++ b/crates/aionui-channel/src/team_event_relay.rs @@ -0,0 +1,725 @@ +use std::collections::{HashMap, HashSet}; +use std::sync::Arc; + +use aionui_api_types::WebSocketMessage; +use aionui_common::now_ms; +use aionui_db::models::{AssistantSessionRow, AssistantUserRow}; +use aionui_db::{ + IApprovalRepository, IChannelRepository, IConversationRepository, IDevelopmentOperationsRepository, + IDevelopmentRepository, IProjectRepository, +}; +use tokio::sync::broadcast; +use tokio::time::{Duration, interval}; +use tracing::{debug, warn}; + +use crate::formatter::format_outgoing_text_for_platform; +use crate::message_service::ChannelMessageService; +use crate::stream_relay::ChannelSender; +use crate::types::{ActionButton, ChannelTopicContext, OutgoingMessageType, PluginType, UnifiedOutgoingMessage}; + +const MESSAGE_STREAM_EVENT: &str = "message.stream"; +const TEAMMATE_MESSAGE_EVENT: &str = "team.teammateMessage"; + +#[derive(Debug, Clone, PartialEq, Eq)] +enum RelayEmission { + Final { conversation_id: String, text: String }, + Error { conversation_id: String, text: String }, + Immediate { conversation_id: String, text: String }, +} + +#[derive(Debug, Default)] +struct TeamRelayAccumulator { + buffers: HashMap, +} + +impl TeamRelayAccumulator { + fn accept(&mut self, event: &WebSocketMessage) -> Option { + match event.name.as_str() { + MESSAGE_STREAM_EVENT => self.accept_message_stream(&event.data), + TEAMMATE_MESSAGE_EVENT => self.accept_teammate_message(&event.data), + _ => None, + } + } + + fn accept_message_stream(&mut self, data: &serde_json::Value) -> Option { + let conversation_id = data.get("conversation_id")?.as_str()?.to_owned(); + let event_type = data.get("type")?.as_str()?; + if data.get("hidden").and_then(serde_json::Value::as_bool).unwrap_or(false) { + return None; + } + + match event_type { + "text" | "content" => { + let content = data + .get("data") + .and_then(|v| v.get("content")) + .and_then(serde_json::Value::as_str) + .unwrap_or_default(); + if content.trim().is_empty() { + return None; + } + let buffer = self.buffers.entry(conversation_id).or_default(); + if data + .get("replace") + .and_then(serde_json::Value::as_bool) + .unwrap_or(false) + { + buffer.clear(); + } + buffer.push_str(content); + None + } + "finish" => { + let text = self.buffers.remove(&conversation_id).unwrap_or_default(); + if text.trim().is_empty() { + None + } else { + Some(RelayEmission::Final { conversation_id, text }) + } + } + "error" => { + let text = data + .get("data") + .and_then(|v| v.get("message").or_else(|| v.get("content"))) + .and_then(serde_json::Value::as_str) + .unwrap_or("Team processing failed") + .to_owned(); + self.buffers.remove(&conversation_id); + Some(RelayEmission::Error { conversation_id, text }) + } + _ => None, + } + } + + fn accept_teammate_message(&mut self, data: &serde_json::Value) -> Option { + let conversation_id = data.get("conversation_id")?.as_str()?.to_owned(); + let content = data.get("content")?.as_str()?.trim(); + if content.is_empty() { + return None; + } + let from_name = data + .get("from_name") + .and_then(serde_json::Value::as_str) + .unwrap_or("Teammate"); + Some(RelayEmission::Immediate { + conversation_id, + text: format!("{from_name}: {content}"), + }) + } +} + +pub struct ChannelTeamEventRelay { + event_rx: broadcast::Receiver>, + channel_repo: Arc, + conversation_repo: Arc, + sender: Arc, +} + +impl ChannelTeamEventRelay { + pub fn new( + event_rx: broadcast::Receiver>, + channel_repo: Arc, + conversation_repo: Arc, + sender: Arc, + ) -> Self { + Self { + event_rx, + channel_repo, + conversation_repo, + sender, + } + } + + pub async fn run(mut self) { + let mut accumulator = TeamRelayAccumulator::default(); + loop { + match self.event_rx.recv().await { + Ok(event) => { + if let Some(emission) = accumulator.accept(&event) { + self.deliver(emission).await; + } + } + Err(broadcast::error::RecvError::Lagged(count)) => { + warn!(count, "channel team event relay lagged"); + } + Err(broadcast::error::RecvError::Closed) => break, + } + } + } + + async fn deliver(&self, emission: RelayEmission) { + let (conversation_id, outgoing) = match emission { + RelayEmission::Final { conversation_id, text } => { + (conversation_id, ChannelMessageService::build_final_message(&text)) + } + RelayEmission::Error { conversation_id, text } => ( + conversation_id, + UnifiedOutgoingMessage { + topic: None, + message_type: OutgoingMessageType::Text, + text: Some(format!("❌ {text}")), + parse_mode: None, + buttons: None, + keyboard: None, + image_url: None, + file_url: None, + file_name: None, + media_actions: None, + reply_to_message_id: None, + silent: None, + }, + ), + RelayEmission::Immediate { conversation_id, text } => ( + conversation_id, + UnifiedOutgoingMessage { + topic: None, + message_type: OutgoingMessageType::Text, + text: Some(text), + parse_mode: None, + buttons: None, + keyboard: None, + image_url: None, + file_url: None, + file_name: None, + media_actions: None, + reply_to_message_id: None, + silent: None, + }, + ), + }; + + let sessions = match self.channel_repo.get_all_sessions().await { + Ok(sessions) => sessions, + Err(error) => { + warn!(error = %error, "failed to load channel sessions for team relay"); + return; + } + }; + let users = match self.channel_repo.get_all_users().await { + Ok(users) => users + .into_iter() + .map(|user| (user.id.clone(), user)) + .collect::>(), + Err(error) => { + warn!(error = %error, "failed to load channel users for team relay"); + HashMap::new() + } + }; + let conversation_row = match self.conversation_repo.get(&conversation_id).await { + Ok(Some(row)) => row, + Ok(None) => { + debug!(conversation_id = %conversation_id, "skipping channel team relay for missing conversation"); + return; + } + Err(error) => { + warn!(error = %error, conversation_id = %conversation_id, "failed to load conversation for team relay"); + return; + } + }; + if !is_team_owned_conversation_extra(&conversation_row.extra) { + debug!(conversation_id = %conversation_id, "skipping channel team relay for non-team conversation"); + return; + } + let conversation_plugin_id = source_to_plugin_id(conversation_row.source.as_deref()); + + for session in sessions { + if session.conversation_id.as_deref() != Some(conversation_id.as_str()) { + continue; + } + let Some(chat_id) = session.chat_id.as_deref() else { + continue; + }; + let Some(plugin_id) = plugin_id_for_session(&session, &users, conversation_plugin_id.as_deref()) else { + warn!( + conversation_id = %conversation_id, + session_id = %session.id, + user_id = %session.user_id, + "failed to resolve channel plugin for team relay" + ); + continue; + }; + let mut outgoing = format_outgoing_for_plugin(outgoing.clone(), &plugin_id); + outgoing.topic = session + .message_thread_id + .map(|message_thread_id| ChannelTopicContext { message_thread_id }); + match self.sender.send_message(&plugin_id, chat_id, outgoing.clone()).await { + Ok(_) => { + debug!(conversation_id = %conversation_id, chat_id = %chat_id, "team event relayed to channel") + } + Err(error) => { + warn!(error = %error, conversation_id = %conversation_id, chat_id = %chat_id, "failed to relay team event to channel") + } + } + } + } +} + +#[derive(Clone)] +pub struct ChannelDevelopmentNotifier { + owner_user_id: String, + channel_repo: Arc, + project_repo: Arc, + development_repo: Arc, + operations_repo: Arc, + approval_repo: Arc, + sender: Arc, +} + +impl ChannelDevelopmentNotifier { + pub fn new( + owner_user_id: String, + channel_repo: Arc, + project_repo: Arc, + development_repo: Arc, + operations_repo: Arc, + approval_repo: Arc, + sender: Arc, + ) -> Self { + Self { + owner_user_id, + channel_repo, + project_repo, + development_repo, + operations_repo, + approval_repo, + sender, + } + } + + pub async fn run(self) { + let mut seen = HashSet::new(); + let mut ticker = interval(Duration::from_secs(5)); + loop { + ticker.tick().await; + if let Err(error) = self.scan(&mut seen).await { + warn!(error = %error, "development channel notification scan failed"); + } + } + } + + async fn scan(&self, seen: &mut HashSet) -> Result<(), String> { + self.notify_pending_approvals(seen).await?; + for project in self + .project_repo + .list_for_user(&self.owner_user_id) + .await + .map_err(|error| error.to_string())? + { + let conversations = self + .project_repo + .list_resource_links(&project.id, &self.owner_user_id) + .await + .map_err(|error| error.to_string())? + .into_iter() + .filter(|link| link.resource_type == "conversation") + .map(|link| link.resource_id) + .collect::>(); + if conversations.is_empty() { + continue; + } + let runs = self + .development_repo + .list_runs(&self.owner_user_id, Some(&project.id)) + .await + .map_err(|error| error.to_string())?; + for run in runs { + let mut notices = Vec::new(); + if matches!(run.status.as_str(), "succeeded" | "failed") { + notices.push(( + format!("run:{}:{}", run.id, run.status), + if run.status == "succeeded" { + "completion" + } else { + "crash" + }, + format!("开发运行 {}：{}", run.id, run.status), + )); + } + for gate in self + .development_repo + .list_gates(&run.id, None) + .await + .map_err(|error| error.to_string())? + .into_iter() + .filter(|gate| matches!(gate.status.as_str(), "failed" | "timed_out" | "interrupted")) + { + let kind = if gate.status == "timed_out" { + "timeout" + } else { + "test_failure" + }; + notices.push(( + format!("gate:{}:{}", gate.id, gate.status), + kind, + format!("质量门禁 {}：{}", gate.gate_type, gate.status), + )); + } + for task in self + .development_repo + .list_tasks(&run.id) + .await + .map_err(|error| error.to_string())? + .into_iter() + .filter(|task| task.status == "conflict") + { + notices.push(( + format!("task:{}:conflict", task.id), + "conflict", + format!("任务发生冲突：{}", task.subject), + )); + } + for alert in self + .operations_repo + .list_alerts(&self.owner_user_id, &project.id, Some(&run.id), true) + .await + .map_err(|error| error.to_string())? + { + notices.push(( + format!("alert:{}:{}", alert.id, alert.updated_at), + if alert.alert_type == "budget" { + "budget" + } else { + "alert" + }, + alert.message, + )); + } + for recovery in self + .operations_repo + .list_recovery(&self.owner_user_id, &project.id, Some(&run.id), 20) + .await + .map_err(|error| error.to_string())? + { + notices.push(( + format!("recovery:{}:{}", recovery.id, recovery.decision), + "crash", + format!("运行恢复：{}（{}）", recovery.finding, recovery.decision), + )); + } + for (key, kind, detail) in notices { + if !seen.insert(key) { + continue; + } + let outgoing = notice_message(kind, &run.id, &detail); + for conversation_id in &conversations { + self.send_to_conversation(conversation_id, outgoing.clone()).await?; + } + } + } + } + Ok(()) + } + + async fn notify_pending_approvals(&self, seen: &mut HashSet) -> Result<(), String> { + let now = now_ms(); + for approval in self + .approval_repo + .list_for_user(&self.owner_user_id, None) + .await + .map_err(|error| error.to_string())? + .into_iter() + .filter(|approval| approval.status == "pending" && approval.expires_at > now) + { + if !seen.insert(format!("approval:{}", approval.id)) { + continue; + } + let (Some(plugin_id), Some(chat_id)) = + (approval.source_channel.as_deref(), approval.source_chat_id.as_deref()) + else { + continue; + }; + let options = serde_json::from_str::>(&approval.options).unwrap_or_default(); + let buttons = options + .iter() + .enumerate() + .map(|(index, option)| { + vec![ActionButton { + label: option + .get("label") + .and_then(serde_json::Value::as_str) + .unwrap_or("选择") + .to_owned(), + action: "approval.resolve".into(), + params: Some(HashMap::from([ + ("id".into(), approval.id.clone()), + ("o".into(), index.to_string()), + ])), + }] + }) + .collect::>(); + let mut outgoing = notice_message( + "approval", + approval.run_id.as_deref().unwrap_or("unknown"), + &format!("{} · 风险 {}", approval.action_type, approval.risk_level), + ); + outgoing.message_type = OutgoingMessageType::Buttons; + outgoing.buttons = Some(buttons); + outgoing.topic = approval + .source_thread_id + .map(|message_thread_id| ChannelTopicContext { message_thread_id }); + self.sender + .send_message(plugin_id, chat_id, format_outgoing_for_plugin(outgoing, plugin_id)) + .await + .map_err(|error| error.to_string())?; + } + Ok(()) + } + + async fn send_to_conversation( + &self, + conversation_id: &str, + outgoing: UnifiedOutgoingMessage, + ) -> Result<(), String> { + let sessions = self + .channel_repo + .get_all_sessions() + .await + .map_err(|error| error.to_string())?; + let users = self + .channel_repo + .get_all_users() + .await + .map_err(|error| error.to_string())? + .into_iter() + .map(|user| (user.id.clone(), user)) + .collect::>(); + for session in sessions + .into_iter() + .filter(|session| session.conversation_id.as_deref() == Some(conversation_id)) + { + let Some(chat_id) = session.chat_id.as_deref() else { + continue; + }; + let Some(plugin_id) = plugin_id_for_session(&session, &users, None) else { + continue; + }; + let mut message = format_outgoing_for_plugin(outgoing.clone(), &plugin_id); + message.topic = session + .message_thread_id + .map(|message_thread_id| ChannelTopicContext { message_thread_id }); + self.sender + .send_message(&plugin_id, chat_id, message) + .await + .map_err(|error| error.to_string())?; + } + Ok(()) + } +} + +fn notice_message(kind: &str, run_id: &str, detail: &str) -> UnifiedOutgoingMessage { + let title = match kind { + "approval" => "⏳ 需要审批", + "test_failure" => "❌ 测试失败", + "timeout" => "⏱️ 执行超时", + "crash" => "💥 运行异常", + "conflict" => "⚠️ 发现冲突", + "budget" => "💰 预算提醒", + "completion" => "✅ 运行完成", + _ => "ℹ️ 开发运行通知", + }; + UnifiedOutgoingMessage { + topic: None, + message_type: OutgoingMessageType::Text, + text: Some(format!( + "{title}\nRun: {run_id}\n{detail}\n使用 /run_info 查看状态，/handoff 转到 Web。" + )), + parse_mode: None, + buttons: None, + keyboard: None, + image_url: None, + file_url: None, + file_name: None, + media_actions: None, + reply_to_message_id: None, + silent: None, + } +} + +fn plugin_id_for_session( + session: &AssistantSessionRow, + users: &HashMap, + conversation_plugin_id: Option<&str>, +) -> Option { + users + .get(&session.user_id) + .and_then(|user| source_to_plugin_id(Some(user.platform_type.as_str()))) + .or_else(|| conversation_plugin_id.map(ToOwned::to_owned)) +} + +fn format_outgoing_for_plugin(mut outgoing: UnifiedOutgoingMessage, plugin_id: &str) -> UnifiedOutgoingMessage { + let Some(platform) = PluginType::from_str_opt(plugin_id) else { + return outgoing; + }; + let Some(text) = outgoing.text.as_deref() else { + return outgoing; + }; + let formatted = format_outgoing_text_for_platform(text, platform); + outgoing.text = Some(formatted.text); + outgoing.parse_mode = formatted.parse_mode; + outgoing +} + +fn source_to_plugin_id(source: Option<&str>) -> Option { + let plugin = match source? { + "telegram" => PluginType::Telegram, + "lark" => PluginType::Lark, + "dingtalk" => PluginType::Dingtalk, + "weixin" => PluginType::Weixin, + "slack" => PluginType::Slack, + "discord" => PluginType::Discord, + _ => return None, + }; + Some(plugin.to_string()) +} + +fn is_team_owned_conversation_extra(extra: &str) -> bool { + serde_json::from_str::(extra) + .ok() + .and_then(|value| { + value + .get("teamId") + .and_then(serde_json::Value::as_str) + .map(str::trim) + .map(str::to_owned) + }) + .is_some_and(|team_id| !team_id.is_empty()) +} + +#[cfg(test)] +mod tests { + use super::*; + use aionui_common::now_ms; + use serde_json::json; + + #[test] + fn accumulator_buffers_stream_chunks_until_finish() { + let mut acc = TeamRelayAccumulator::default(); + assert_eq!( + acc.accept(&WebSocketMessage::new( + MESSAGE_STREAM_EVENT, + json!({"conversation_id":"c1","type":"content","data":{"content":"hello "},"hidden":false}) + )), + None + ); + assert_eq!( + acc.accept(&WebSocketMessage::new( + MESSAGE_STREAM_EVENT, + json!({"conversation_id":"c1","type":"content","data":{"content":"team"},"hidden":false}) + )), + None + ); + assert_eq!( + acc.accept(&WebSocketMessage::new( + MESSAGE_STREAM_EVENT, + json!({"conversation_id":"c1","type":"finish","data":{},"hidden":false}) + )), + Some(RelayEmission::Final { + conversation_id: "c1".into(), + text: "hello team".into(), + }) + ); + } + + #[test] + fn accumulator_formats_teammate_message() { + let mut acc = TeamRelayAccumulator::default(); + assert_eq!( + acc.accept(&WebSocketMessage::new( + TEAMMATE_MESSAGE_EVENT, + json!({"conversation_id":"c1","from_name":"Risk","content":"watch leverage"}) + )), + Some(RelayEmission::Immediate { + conversation_id: "c1".into(), + text: "Risk: watch leverage".into(), + }) + ); + } + + #[test] + fn relay_resolves_plugin_from_bound_channel_session_before_conversation_source() { + let now = now_ms(); + let session = AssistantSessionRow { + id: "session-1".into(), + user_id: "user-1".into(), + agent_type: "acp".into(), + conversation_id: Some("team-lead-conversation".into()), + workspace: None, + chat_id: Some("chat-1".into()), + message_thread_id: None, + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, + created_at: now, + last_activity: now, + }; + let user = AssistantUserRow { + id: "user-1".into(), + platform_user_id: "telegram-user".into(), + platform_type: "telegram".into(), + display_name: None, + authorized_at: now, + last_active: None, + session_id: None, + }; + let users = HashMap::from([(user.id.clone(), user)]); + + assert_eq!( + plugin_id_for_session(&session, &users, Some("lark")), + Some("telegram".into()), + "team conversations created by WebUI may have source=aionui, so channel relay must route by bound session" + ); + } + + #[test] + fn team_relay_only_treats_conversation_extra_with_team_id_as_team_owned() { + assert!(is_team_owned_conversation_extra(r#"{"teamId":"team-1"}"#)); + assert!(!is_team_owned_conversation_extra("{}")); + assert!(!is_team_owned_conversation_extra(r#"{"teamId":""}"#)); + assert!(!is_team_owned_conversation_extra("not-json")); + } + + #[test] + fn development_notices_cover_all_proactive_categories_without_payload_details() { + let cases = [ + ("approval", "需要审批"), + ("test_failure", "测试失败"), + ("timeout", "执行超时"), + ("crash", "运行异常"), + ("conflict", "发现冲突"), + ("budget", "预算提醒"), + ("completion", "运行完成"), + ]; + for (kind, expected) in cases { + let message = notice_message(kind, "run-1", "sanitized detail"); + let text = message.text.unwrap(); + assert!(text.contains(expected), "kind={kind}: {text}"); + assert!(text.contains("Run: run-1")); + assert!(text.contains("/handoff")); + } + } + + #[test] + fn team_relay_restores_the_session_topic_on_outgoing_messages() { + let mut message = notice_message("completion", "run-1", "done"); + let session = AssistantSessionRow { + id: "session-topic".into(), + user_id: "user-1".into(), + agent_type: "acp".into(), + conversation_id: Some("conversation-1".into()), + workspace: None, + chat_id: Some("chat-1".into()), + message_thread_id: Some(7), + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, + created_at: 1, + last_activity: 1, + }; + message.topic = session + .message_thread_id + .map(|message_thread_id| ChannelTopicContext { message_thread_id }); + assert_eq!(message.topic.unwrap().message_thread_id, 7); + } +} diff --git a/crates/aionui-channel/src/types.rs b/crates/aionui-channel/src/types.rs index 8c3d3e22c..814529e2c 100644 --- a/crates/aionui-channel/src/types.rs +++ b/crates/aionui-channel/src/types.rs @@ -1,4 +1,10 @@ use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ChannelConversationTitleHint { + pub title: String, + pub source: String, +} use std::collections::HashMap; use std::fmt; @@ -271,6 +277,11 @@ pub struct BotInfo { // --------------------------------------------------------------------------- /// Message received from an IM platform, normalized to a common format. +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct ChannelTopicContext { + pub message_thread_id: i64, +} + #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] pub struct UnifiedIncomingMessage { pub id: String, @@ -280,6 +291,8 @@ pub struct UnifiedIncomingMessage { pub content: UnifiedMessageContent, pub timestamp: i64, #[serde(skip_serializing_if = "Option::is_none")] + pub topic: Option, + #[serde(skip_serializing_if = "Option::is_none")] pub reply_to_message_id: Option, #[serde(skip_serializing_if = "Option::is_none")] pub action: Option, @@ -369,6 +382,8 @@ pub struct UnifiedOutgoingMessage { pub reply_to_message_id: Option, #[serde(skip_serializing_if = "Option::is_none")] pub silent: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub topic: Option, } /// Outgoing message type discriminant. @@ -731,6 +746,7 @@ mod tests { attachments: None, }, timestamp: 1700000000, + topic: None, reply_to_message_id: None, action: None, raw: None, @@ -795,6 +811,7 @@ mod tests { media_actions: None, reply_to_message_id: None, silent: None, + topic: None, }; let json = serde_json::to_value(&msg).unwrap(); assert_eq!(json["type"], "text"); @@ -826,6 +843,7 @@ mod tests { media_actions: None, reply_to_message_id: None, silent: None, + topic: None, }; let json = serde_json::to_value(&msg).unwrap(); assert_eq!(json["type"], "buttons"); @@ -984,6 +1002,7 @@ mod tests { attachments: None, }, timestamp: 1000, + topic: None, reply_to_message_id: None, action: None, raw: None, @@ -1007,6 +1026,7 @@ mod tests { media_actions: None, reply_to_message_id: None, silent: Some(true), + topic: None, }; let json = serde_json::to_string(&msg).unwrap(); let parsed: UnifiedOutgoingMessage = serde_json::from_str(&json).unwrap(); diff --git a/crates/aionui-channel/tests/formatter_test.rs b/crates/aionui-channel/tests/formatter_test.rs index 03fb4b755..c3e5c5d88 100644 --- a/crates/aionui-channel/tests/formatter_test.rs +++ b/crates/aionui-channel/tests/formatter_test.rs @@ -1,5 +1,5 @@ -use aionui_channel::formatter::format_text_for_platform; -use aionui_channel::types::PluginType; +use aionui_channel::formatter::{format_outgoing_text_for_platform, format_text_for_platform}; +use aionui_channel::types::{ParseMode, PluginType}; // ── Telegram: escape HTML, then convert markdown to HTML tags ──── @@ -37,6 +37,23 @@ fn telegram_link() { ); } +#[test] +fn telegram_simple_markdown_table_becomes_cards() { + let input = + "| Role | Model |\n|---|---|\n| Research Lead | deepseek-v4-pro |\n| Risk Validator | deepseek-v4-flash |"; + let result = format_text_for_platform(input, PluginType::Telegram); + assert!(result.contains("Role: Research Lead"), "got: {result}"); + assert!(result.contains("Model: deepseek-v4-pro"), "got: {result}"); + assert!(!result.contains("|---|"), "got: {result}"); +} + +#[test] +fn telegram_outgoing_text_uses_html_parse_mode() { + let result = format_outgoing_text_for_platform("**bold**", PluginType::Telegram); + assert_eq!(result.parse_mode, Some(ParseMode::HTML)); + assert_eq!(result.text, "bold"); +} + // ── Lark / DingTalk: HTML tags → markdown syntax ───────────────── #[test] diff --git a/crates/aionui-channel/tests/manager_integration.rs b/crates/aionui-channel/tests/manager_integration.rs index 5504949ae..ede80974a 100644 --- a/crates/aionui-channel/tests/manager_integration.rs +++ b/crates/aionui-channel/tests/manager_integration.rs @@ -226,6 +226,7 @@ fn make_test_outgoing() -> UnifiedOutgoingMessage { media_actions: None, reply_to_message_id: None, silent: None, + topic: None, } } diff --git a/crates/aionui-channel/tests/message_service_integration.rs b/crates/aionui-channel/tests/message_service_integration.rs index 085cedc2d..c4e54c253 100644 --- a/crates/aionui-channel/tests/message_service_integration.rs +++ b/crates/aionui-channel/tests/message_service_integration.rs @@ -251,6 +251,11 @@ async fn send_to_agent_warms_cold_task_before_returning_stream_subscription() { conversation_id: None, workspace: None, chat_id: Some("7088048016".to_owned()), + message_thread_id: None, + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, created_at: 1, last_activity: 1, }; @@ -328,6 +333,11 @@ async fn send_to_agent_persists_assistant_snapshot_for_channel_bound_assistant() conversation_id: None, workspace: None, chat_id: Some("7088048016".to_owned()), + message_thread_id: None, + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, created_at: 1, last_activity: 1, }; @@ -403,6 +413,11 @@ async fn send_to_agent_rejects_unresolvable_channel_assistant_binding() { conversation_id: None, workspace: None, chat_id: Some("7088048017".to_owned()), + message_thread_id: None, + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, created_at: 1, last_activity: 1, }; @@ -468,6 +483,11 @@ async fn send_to_agent_without_saved_binding_defaults_to_bare_aionrs_assistant() conversation_id: None, workspace: None, chat_id: Some("7088048018".to_owned()), + message_thread_id: None, + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, created_at: 1, last_activity: 1, }; @@ -544,6 +564,11 @@ async fn send_to_agent_without_assistant_name_falls_back_to_legacy_channel_name( conversation_id: None, workspace: None, chat_id: Some("7088048016".to_owned()), + message_thread_id: None, + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, created_at: 1, last_activity: 1, }; diff --git a/crates/aionui-channel/tests/orchestrator_test.rs b/crates/aionui-channel/tests/orchestrator_test.rs index 3b7c710aa..3f63957d8 100644 --- a/crates/aionui-channel/tests/orchestrator_test.rs +++ b/crates/aionui-channel/tests/orchestrator_test.rs @@ -25,6 +25,7 @@ fn make_text_message(user_id: &str, chat_id: &str, text: &str) -> UnifiedIncomin attachments: None, }, timestamp: 0, + topic: None, reply_to_message_id: None, action: None, raw: None, diff --git a/crates/aionui-channel/tests/session_action_integration.rs b/crates/aionui-channel/tests/session_action_integration.rs index 5700a4965..ffd354bd8 100644 --- a/crates/aionui-channel/tests/session_action_integration.rs +++ b/crates/aionui-channel/tests/session_action_integration.rs @@ -97,6 +97,7 @@ fn make_text_message(user_id: &str, chat_id: &str, text: &str) -> UnifiedIncomin attachments: None, }, timestamp: now_ms(), + topic: None, reply_to_message_id: None, action: None, raw: None, @@ -125,6 +126,7 @@ fn make_action_message( attachments: None, }, timestamp: now_ms(), + topic: None, reply_to_message_id: None, action: Some(UnifiedAction { action: action_name.into(), diff --git a/crates/aionui-channel/tests/stream_relay_test.rs b/crates/aionui-channel/tests/stream_relay_test.rs index 6691cec3b..b6e468f65 100644 --- a/crates/aionui-channel/tests/stream_relay_test.rs +++ b/crates/aionui-channel/tests/stream_relay_test.rs @@ -1,13 +1,43 @@ -use std::sync::Arc; +use std::sync::{Arc, Mutex}; use aionui_ai_agent::AgentStreamEvent; use aionui_ai_agent::protocol::events::{ - ErrorEventData, FinishEventData, TextEventData, ToolCallEventData, ToolCallStatus, + AcpPermissionEventData, ErrorEventData, FinishEventData, TextEventData, ToolCallEventData, ToolCallStatus, }; +use aionui_channel::approval::{ChannelApprovalContext, ChannelApprovalPort, ChannelApprovalResolutionContext}; +use aionui_channel::error::ChannelError; use aionui_channel::stream_relay::{ChannelStreamRelay, MessageRecorder, RelayConfig}; use aionui_channel::types::PluginType; +use aionui_common::{Confirmation, ConfirmationOption}; +use async_trait::async_trait; use tokio::sync::broadcast; +#[derive(Default)] +struct RecordingApprovalPort { + created: Mutex>, +} + +#[async_trait] +impl ChannelApprovalPort for RecordingApprovalPort { + async fn create( + &self, + context: ChannelApprovalContext, + confirmation: Confirmation, + ) -> Result { + self.created.lock().unwrap().push((context, confirmation)); + Ok("approval1234567".into()) + } + + async fn resolve( + &self, + _context: ChannelApprovalResolutionContext, + _approval_id: &str, + _option_index: usize, + ) -> Result { + Ok("approved".into()) + } +} + // ── RelayConfig construction ───────────────────────────────────── #[test] @@ -62,7 +92,7 @@ async fn relay_sends_thinking_then_final_message() { let edits = recorder.take_edits(); let last = edits.last().unwrap(); assert!(last.text.as_deref().unwrap().contains("Hello World")); - assert!(last.buttons.is_some()); + assert!(last.buttons.is_none()); } #[tokio::test] @@ -254,3 +284,70 @@ async fn relay_handles_channel_closed() { assert!(!edits.is_empty()); assert!(edits.last().unwrap().text.as_deref().unwrap().contains("partial")); } + +#[tokio::test] +async fn telegram_permission_event_creates_topic_scoped_approval_buttons() { + let (event_tx, _) = broadcast::channel::(64); + let recorder = Arc::new(MessageRecorder::new()); + let approvals = Arc::new(RecordingApprovalPort::default()); + let config = RelayConfig { + platform: PluginType::Telegram, + plugin_id: "telegram".into(), + chat_id: "chat_1".into(), + throttle_ms: 10, + }; + let context = ChannelApprovalContext { + source_user_id: "assistant-user-1".into(), + conversation_id: "conversation-1".into(), + agent_id: Some("claude-code".into()), + platform: PluginType::Telegram, + chat_id: "chat_1".into(), + message_thread_id: Some(5), + }; + let relay = ChannelStreamRelay::new(config, recorder.clone()) + .with_approval_port(approvals.clone(), context) + .with_topic(Some(aionui_channel::types::ChannelTopicContext { + message_thread_id: 5, + })); + let rx = event_tx.subscribe(); + event_tx + .send(AgentStreamEvent::AcpPermission(AcpPermissionEventData::Confirmation( + Confirmation { + id: "confirmation-1".into(), + call_id: "call-1".into(), + title: Some("Run tests?".into()), + action: None, + description: "cargo test".into(), + command_type: Some("execute".into()), + options: vec![ + ConfirmationOption { + label: "Allow once".into(), + value: serde_json::json!("allow_once"), + params: None, + }, + ConfirmationOption { + label: "Reject".into(), + value: serde_json::json!("reject"), + params: None, + }, + ], + }, + ))) + .unwrap(); + event_tx + .send(AgentStreamEvent::Finish(FinishEventData { session_id: None })) + .unwrap(); + + relay.run(rx).await; + + assert_eq!(approvals.created.lock().unwrap().len(), 1); + let sends = recorder.take_sends(); + let prompt = sends + .iter() + .find(|message| message.buttons.is_some()) + .expect("approval prompt"); + assert_eq!(prompt.topic.as_ref().unwrap().message_thread_id, 5); + let buttons = prompt.buttons.as_ref().unwrap(); + assert_eq!(buttons[0][0].action, "approval.resolve"); + assert_eq!(buttons[0][0].params.as_ref().unwrap()["id"], "approval1234567"); +} diff --git a/crates/aionui-channel/tests/team_channel_routing.rs b/crates/aionui-channel/tests/team_channel_routing.rs new file mode 100644 index 000000000..bd5c6d386 --- /dev/null +++ b/crates/aionui-channel/tests/team_channel_routing.rs @@ -0,0 +1,29 @@ +use aionui_channel::message_service::{TeamChannelTarget, team_channel_route_from_extra}; + +#[test] +fn team_channel_route_detects_lead_conversation() { + let route = team_channel_route_from_extra(r#"{"teamId":"team-1","slot_id":"lead-1","role":"lead"}"#) + .expect("team-owned conversation should produce a channel route"); + + assert_eq!(route.team_id, "team-1"); + assert_eq!(route.target, TeamChannelTarget::Lead); +} + +#[test] +fn team_channel_route_detects_specific_agent_conversation() { + let route = team_channel_route_from_extra(r#"{"teamId":"team-1","slot_id":"risk-1","role":"teammate"}"#) + .expect("team-owned teammate conversation should produce a channel route"); + + assert_eq!(route.team_id, "team-1"); + assert_eq!( + route.target, + TeamChannelTarget::Agent { + slot_id: "risk-1".into() + } + ); +} + +#[test] +fn team_channel_route_ignores_personal_conversation() { + assert!(team_channel_route_from_extra(r#"{"session_mode":"yolo"}"#).is_none()); +} diff --git a/crates/aionui-channel/tests/telegram_development.rs b/crates/aionui-channel/tests/telegram_development.rs new file mode 100644 index 000000000..33915786b --- /dev/null +++ b/crates/aionui-channel/tests/telegram_development.rs @@ -0,0 +1,42 @@ +use aionui_channel::development::DevelopmentHandoffSigner; + +#[test] +fn handoff_links_are_scoped_signed_and_expiring() { + let signer = DevelopmentHandoffSigner::new([7; 32], "/#/projects"); + let expires_at = 10_000; + let link = signer.sign("project one", "run/one", expires_at); + + assert!(link.contains("projectId=project%20one")); + assert!(link.contains("runId=run%2Fone")); + let signature = link.split("signature=").nth(1).unwrap(); + assert!(signer.verify("project one", "run/one", expires_at, signature, 9_000)); + assert!(!signer.verify("project two", "run/one", expires_at, signature, 9_000)); + assert!(!signer.verify("project one", "run/one", expires_at, signature, 10_001)); +} + +#[test] +fn handoff_links_reject_unreasonably_long_lifetimes() { + let signer = DevelopmentHandoffSigner::new([3; 32], "/#/projects"); + let expires_at = 24 * 60 * 60 * 1000 + 1; + let link = signer.sign("project", "run", expires_at); + let signature = link.split("signature=").nth(1).unwrap(); + assert!(!signer.verify("project", "run", expires_at, signature, 0)); +} + +#[test] +fn relative_handoff_links_use_the_configured_public_web_url() { + let previous = std::env::var_os("AIONUI_PUBLIC_URL"); + unsafe { + std::env::set_var("AIONUI_PUBLIC_URL", "http://127.0.0.1:25809/"); + } + + let signer = DevelopmentHandoffSigner::new([5; 32], "/#/projects"); + let link = signer.sign("project", "run", 10_000); + + match previous { + Some(value) => unsafe { std::env::set_var("AIONUI_PUBLIC_URL", value) }, + None => unsafe { std::env::remove_var("AIONUI_PUBLIC_URL") }, + } + + assert!(link.starts_with("http://127.0.0.1:25809/#/projects?"), "got: {link}"); +} diff --git a/crates/aionui-common/src/constants.rs b/crates/aionui-common/src/constants.rs index 530535862..cf794ae83 100644 --- a/crates/aionui-common/src/constants.rs +++ b/crates/aionui-common/src/constants.rs @@ -98,6 +98,13 @@ fn bool_field(value: &serde_json::Value, key: &str) -> bool { value.get(key).and_then(serde_json::Value::as_bool) == Some(true) } +// --- Image processing --- + +pub const SUPPORTED_IMAGE_EXTENSIONS: &[&str] = &[".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".tiff", ".svg"]; +/// Remote image download size limit (5 MB). +pub const REMOTE_IMAGE_MAX_SIZE: usize = 5 * 1024 * 1024; +pub const REMOTE_IMAGE_MAX_REDIRECTS: u32 = 5; + #[cfg(test)] mod tests { use super::*; @@ -163,10 +170,3 @@ mod tests { assert!(!supports_team_cli_fallback(Some(&json!({"execution": {"cli": false}})))); } } - -// --- Image processing --- - -pub const SUPPORTED_IMAGE_EXTENSIONS: &[&str] = &[".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".tiff", ".svg"]; -/// Remote image download size limit (5 MB). -pub const REMOTE_IMAGE_MAX_SIZE: usize = 5 * 1024 * 1024; -pub const REMOTE_IMAGE_MAX_REDIRECTS: u32 = 5; diff --git a/crates/aionui-common/src/enums.rs b/crates/aionui-common/src/enums.rs index 9eb45dd7f..346223b93 100644 --- a/crates/aionui-common/src/enums.rs +++ b/crates/aionui-common/src/enums.rs @@ -249,6 +249,10 @@ pub enum AgentKillReason { /// The requested runtime capabilities changed, so the in-memory task must /// be rebuilt before handling the next turn. RuntimeCapabilityChanged, + /// A development-run budget policy stopped this Agent after a completed + /// usage observation. The conversation remains available for an audited + /// operator decision or a later policy-compliant retry. + BudgetExceeded, } /// Preview content type for document preview history. diff --git a/crates/aionui-conversation/src/convert.rs b/crates/aionui-conversation/src/convert.rs index 05caa23a4..492c7da44 100644 --- a/crates/aionui-conversation/src/convert.rs +++ b/crates/aionui-conversation/src/convert.rs @@ -73,6 +73,12 @@ pub fn row_to_response_with_extra( pinned: row.pinned, pinned_at: row.pinned_at, channel_chat_id: row.channel_chat_id, + source_channel: row.source_channel, + source_channel_id: row.source_channel_id, + source_chat_id: row.source_chat_id, + source_user_id: row.source_user_id, + source_label: row.source_label, + created_from: row.created_from, assistant: None, created_at: row.created_at, modified_at: row.updated_at, @@ -288,6 +294,12 @@ pub fn search_row_to_item(row: MessageSearchRow, data_dir: &Path) -> Result>>>, assistant_dispatcher: Arc>>>, agent_availability_feedback: Arc>>>, + turn_observer: Arc>>>, + turn_guard: Arc>>>, runtime_state: Arc, runtime_helper_bin: Option, runtime_base_url: Option, @@ -357,6 +359,46 @@ pub enum ConversationAgentTurnStatus { Failed, } +#[derive(Debug, Clone)] +pub struct ConversationTurnObservation { + pub user_id: String, + pub conversation_id: String, + pub turn_id: String, + pub status: ConversationAgentTurnStatus, + pub agent_id: Option, + pub provider: String, + pub model: String, + pub team_id: Option, + pub slot_id: Option, + pub usage: Option, + pub duration_ms: i64, + pub retry_count: i64, + pub occurred_at: i64, +} + +#[async_trait::async_trait] +pub trait ConversationTurnObserver: Send + Sync { + async fn observe(&self, observation: ConversationTurnObservation); +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ConversationTurnAdmissionRequest { + pub user_id: String, + pub conversation_id: String, + pub team_id: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ConversationTurnAdmission { + Allowed, + Denied { reason: String }, +} + +#[async_trait::async_trait] +pub trait ConversationTurnGuard: Send + Sync { + async fn authorize(&self, request: ConversationTurnAdmissionRequest) -> Result; +} + #[derive(Debug, Clone)] pub struct ConversationAgentTurnOutcome { pub conversation_id: String, @@ -391,6 +433,8 @@ impl ConversationService { assistant_preference_repo: Arc::new(RwLock::new(None)), assistant_dispatcher: Arc::new(RwLock::new(None)), agent_availability_feedback: Arc::new(RwLock::new(None)), + turn_observer: Arc::new(RwLock::new(None)), + turn_guard: Arc::new(RwLock::new(None)), runtime_state: Arc::new(ConversationRuntimeStateService::default()), runtime_helper_bin: None, runtime_base_url: None, @@ -461,6 +505,26 @@ impl ConversationService { } } + pub fn with_turn_observer(&self, observer: Arc) { + if let Ok(mut guard) = self.turn_observer.write() { + *guard = Some(observer); + } + } + + pub fn with_turn_guard(&self, turn_guard: Arc) { + if let Ok(mut guard) = self.turn_guard.write() { + *guard = Some(turn_guard); + } + } + + /// Whether both post-turn observation and pre-turn admission have been + /// installed. Schedulers use this as a startup invariant before they begin + /// dispatching work from persisted jobs. + pub fn has_turn_policy(&self) -> bool { + self.turn_observer.read().is_ok_and(|guard| guard.is_some()) + && self.turn_guard.read().is_ok_and(|guard| guard.is_some()) + } + /// Register a hook to be notified when a conversation is deleted. /// /// Hooks are dispatched sequentially in registration order before @@ -549,6 +613,34 @@ impl ConversationService { .and_then(|guard| guard.as_ref().cloned()) } + pub(crate) fn turn_observer(&self) -> Option> { + self.turn_observer.read().ok().and_then(|guard| guard.as_ref().cloned()) + } + + async fn authorize_turn( + &self, + user_id: &str, + conversation_id: &str, + team_id: Option<&str>, + ) -> Result<(), ConversationError> { + let turn_guard = self.turn_guard.read().ok().and_then(|guard| guard.as_ref().cloned()); + let Some(turn_guard) = turn_guard else { + return Ok(()); + }; + match turn_guard + .authorize(ConversationTurnAdmissionRequest { + user_id: user_id.to_owned(), + conversation_id: conversation_id.to_owned(), + team_id: team_id.map(str::to_owned), + }) + .await + { + Ok(ConversationTurnAdmission::Allowed) => Ok(()), + Ok(ConversationTurnAdmission::Denied { reason }) => Err(ConversationError::Forbidden { reason }), + Err(reason) => Err(ConversationError::Internal { reason }), + } + } + pub(crate) fn runtime_persistence(&self) -> RuntimePersistenceCoordinator { RuntimePersistenceCoordinator::new(self.runtime_state()) } @@ -695,7 +787,10 @@ impl ConversationService { let id = generate_short_id(); let now = now_ms(); let source = req.source.unwrap_or(ConversationSource::Aionui); + let legacy_source = enum_to_db(&source)?; + let source_metadata = + ConversationSourceMetadata::from_request(&req, &req.extra, &legacy_source, req.channel_chat_id.as_deref()); let mut extra = req.extra; let assistant_id = req @@ -1106,8 +1201,14 @@ impl ConversationService { .transpose() .map_err(|e| ConversationError::internal(format!("Failed to serialize model: {e}")))?, status: Some(enum_to_db(&ConversationStatus::Pending)?), - source: Some(enum_to_db(&source)?), + source: Some(legacy_source), channel_chat_id: req.channel_chat_id, + source_channel: source_metadata.source_channel, + source_channel_id: source_metadata.source_channel_id, + source_chat_id: source_metadata.source_chat_id, + source_user_id: source_metadata.source_user_id, + source_label: source_metadata.source_label, + created_from: source_metadata.created_from, pinned: false, pinned_at: None, created_at: now, @@ -2608,6 +2709,7 @@ impl ConversationService { } reject_deprecated_runtime_row(&row)?; + self.authorize_turn(user_id, conversation_id, None).await?; let turn_id = Self::mint_turn_id(); let turn_claim = self.runtime_state.try_claim_turn(conversation_id, &turn_id)?; @@ -2735,6 +2837,9 @@ impl ConversationService { })?; reject_deprecated_runtime_row(&row)?; + let team_id = team_id_from_extra(&row.extra); + self.authorize_turn(&request.user_id, &request.conversation_id, team_id.as_deref()) + .await?; let turn_id = Self::mint_turn_id(); let turn_claim = self.runtime_state.try_claim_turn(&request.conversation_id, &turn_id)?; @@ -2946,17 +3051,18 @@ impl ConversationService { }); } + self.runtime_state.mark_cancelling(conversation_id); + let Some(agent) = task_manager.get_task(conversation_id) else { info!( conversation_id, - turn_id, "No active agent to cancel; returning runtime summary" + turn_id, "No active agent to cancel yet; marked pending turn cancellation" ); return Ok(CancelConversationResponse { runtime: self.runtime_summary_for(conversation_id).await, }); }; - self.runtime_state.mark_cancelling(conversation_id); if let Err(e) = agent.cancel().await { self.runtime_state.clear_cancelling(conversation_id); warn!(conversation_id, turn_id, error = %ErrorChain(&e), "Failed to cancel agent"); @@ -3110,6 +3216,9 @@ impl ConversationService { })?; reject_deprecated_runtime_row(&row)?; + let team_id = team_id_from_extra(&row.extra); + self.authorize_turn(user_id, conversation_id, team_id.as_deref()) + .await?; if let Some(agent) = task_manager.get_task(conversation_id) { debug!(conversation_id, phase, "Conversation runtime already active"); @@ -3946,6 +4055,89 @@ fn enum_to_db(val: &T) -> Result .ok_or_else(|| ConversationError::internal("Expected string enum value")) } +#[derive(Debug, Clone, Default)] +struct ConversationSourceMetadata { + source_channel: Option, + source_channel_id: Option, + source_chat_id: Option, + source_user_id: Option, + source_label: Option, + created_from: Option, +} + +impl ConversationSourceMetadata { + fn from_request( + req: &CreateConversationRequest, + extra: &serde_json::Value, + legacy_source: &str, + channel_chat_id: Option<&str>, + ) -> Self { + let source_channel = clean_source(req.source_channel.as_deref()) + .or_else(|| extra_string(extra, "source_channel")) + .or_else(|| source_channel_from_legacy(legacy_source)); + let source_chat_id = clean_source(req.source_chat_id.as_deref()) + .or_else(|| extra_string(extra, "source_chat_id")) + .or_else(|| clean_source(channel_chat_id)); + let source_label = clean_source(req.source_label.as_deref()) + .or_else(|| extra_string(extra, "source_label")) + .or_else(|| { + source_channel + .as_deref() + .map(source_label_for_channel) + .map(str::to_owned) + }); + let created_from = clean_source(req.created_from.as_deref()) + .or_else(|| extra_string(extra, "created_from")) + .or_else(|| source_channel.clone()); + + Self { + source_channel, + source_channel_id: clean_source(req.source_channel_id.as_deref()) + .or_else(|| extra_string(extra, "source_channel_id")), + source_chat_id, + source_user_id: clean_source(req.source_user_id.as_deref()) + .or_else(|| extra_string(extra, "source_user_id")), + source_label, + created_from, + } + } +} + +fn clean_source(value: Option<&str>) -> Option { + value + .map(str::trim) + .filter(|value| !value.is_empty()) + .map(str::to_owned) +} + +fn extra_string(extra: &serde_json::Value, key: &str) -> Option { + extra + .get(key) + .and_then(serde_json::Value::as_str) + .and_then(|value| clean_source(Some(value))) +} + +fn source_channel_from_legacy(source: &str) -> Option { + clean_source(Some(match source { + "aionui" => "webui", + other => other, + })) +} + +fn source_label_for_channel(channel: &str) -> &'static str { + match channel { + "aionui" | "webui" => "WebUI", + "desktop" => "Desktop", + "telegram" => "Telegram", + "discord" => "Discord", + "lark" => "Lark", + "wecom" => "WeCom", + "weixin" => "Weixin", + "dingtalk" => "DingTalk", + _ => "Unknown Source", + } +} + /// Persist the agent's session key into `conversation.extra.sessionKey`. /// /// Called after send_message completes so the session can be resumed @@ -4169,6 +4361,12 @@ mod tests { pinned: false, pinned_at: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, assistant: None, created_at: 0, modified_at: 0, diff --git a/crates/aionui-conversation/src/service_test.rs b/crates/aionui-conversation/src/service_test.rs index a3148c3e1..4b956a37c 100644 --- a/crates/aionui-conversation/src/service_test.rs +++ b/crates/aionui-conversation/src/service_test.rs @@ -52,7 +52,10 @@ use tokio::sync::{Notify, broadcast}; use crate::service::ConversationService; use crate::skill_resolver::{FixedSkillResolver, ResolvedAgentSkill, SkillResolver}; -use crate::{ConversationAgentTurnRequest, ConversationAgentTurnStatus, ConversationError}; +use crate::{ + ConversationAgentTurnRequest, ConversationAgentTurnStatus, ConversationError, ConversationTurnAdmission, + ConversationTurnAdmissionRequest, ConversationTurnGuard, ConversationTurnObservation, ConversationTurnObserver, +}; #[path = "service_test/acp_error_recovery_test.rs"] mod acp_error_recovery_test; @@ -185,6 +188,29 @@ struct RecordingAvailabilityFeedback { failures: Mutex>, } +#[derive(Default)] +struct RecordingTurnObserver { + observations: Mutex>, +} + +#[async_trait::async_trait] +impl ConversationTurnObserver for RecordingTurnObserver { + async fn observe(&self, observation: ConversationTurnObservation) { + self.observations.lock().unwrap().push(observation); + } +} + +struct DenyingTurnGuard; + +#[async_trait::async_trait] +impl ConversationTurnGuard for DenyingTurnGuard { + async fn authorize(&self, _request: ConversationTurnAdmissionRequest) -> Result { + Ok(ConversationTurnAdmission::Denied { + reason: "development run is paused by its budget policy".into(), + }) + } +} + #[async_trait::async_trait] impl AgentAvailabilityFeedbackPort for RecordingAvailabilityFeedback { async fn record_session_success(&self, agent_id: &str) -> Result<(), AgentError> { @@ -701,6 +727,7 @@ fn stub_agent_metadata_rows() -> Vec { last_check_at: None, last_success_at: None, last_failure_at: None, + dynamic_probe_result: None, command_override: None, env_override: None, created_at: 1, @@ -801,6 +828,7 @@ fn claude_metadata_row() -> AgentMetadataRow { last_check_at: None, last_success_at: None, last_failure_at: None, + dynamic_probe_result: None, command_override: None, env_override: None, created_at: 1, @@ -986,6 +1014,16 @@ fn make_service() -> ( make_service_with_resolver(Arc::new(FixedSkillResolver { names: vec![] })) } +#[test] +fn turn_policy_is_ready_only_after_observer_and_guard_are_both_installed() { + let (service, _, _, _) = make_service(); + assert!(!service.has_turn_policy()); + service.with_turn_observer(Arc::new(RecordingTurnObserver::default())); + assert!(!service.has_turn_policy()); + service.with_turn_guard(Arc::new(DenyingTurnGuard)); + assert!(service.has_turn_policy()); +} + fn make_service_with_resolver( skill_resolver: Arc, ) -> ( @@ -1349,6 +1387,12 @@ async fn insert_conversation_with_type(repo: &Arc, user_id: &str, agen status: Some("finished".into()), source: Some("aionui".into()), channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: 1, @@ -2771,6 +2815,70 @@ impl IAgentTask for BlockingCancelAgent { impl IMockAgent for BlockingCancelAgent {} +struct CountingSendAgent { + conversation_id: String, + event_tx: broadcast::Sender, + send_count: AtomicUsize, +} + +impl CountingSendAgent { + fn new(conversation_id: &str) -> Self { + let (event_tx, _) = broadcast::channel(64); + Self { + conversation_id: conversation_id.to_owned(), + event_tx, + send_count: AtomicUsize::new(0), + } + } + + fn send_count(&self) -> usize { + self.send_count.load(Ordering::SeqCst) + } +} + +#[async_trait::async_trait] +impl IAgentTask for CountingSendAgent { + fn agent_type(&self) -> AgentType { + AgentType::Acp + } + + fn conversation_id(&self) -> &str { + &self.conversation_id + } + + fn workspace(&self) -> &str { + "/tmp/test" + } + + fn status(&self) -> Option { + Some(ConversationStatus::Running) + } + + fn last_activity_at(&self) -> TimestampMs { + 0 + } + + fn subscribe(&self) -> broadcast::Receiver { + self.event_tx.subscribe() + } + + async fn send_message(&self, _data: SendMessageData) -> Result<(), AgentSendError> { + self.send_count.fetch_add(1, Ordering::SeqCst); + let _ = self.event_tx.send(AgentStreamEvent::Finish(FinishEventData::default())); + Ok(()) + } + + async fn cancel(&self) -> Result<(), AgentError> { + Ok(()) + } + + fn kill(&self, _reason: Option) -> Result<(), AgentError> { + Ok(()) + } +} + +impl IMockAgent for CountingSendAgent {} + // ── Mock WorkerTaskManager ────────────────────────────────────── struct MockTaskManager { @@ -2912,6 +3020,55 @@ impl DelayedFailingBuildTaskManager { } } +struct DelayedReadyTaskManager { + delay: Duration, + agent: AgentInstance, +} + +impl DelayedReadyTaskManager { + fn new(delay: Duration, agent: AgentInstance) -> Self { + Self { delay, agent } + } +} + +#[async_trait::async_trait] +impl IWorkerTaskManager for DelayedReadyTaskManager { + fn get_task(&self, _conversation_id: &str) -> Option { + None + } + + async fn get_or_build_task( + &self, + _conversation_id: &str, + _options: BuildTaskOptions, + ) -> Result { + tokio::time::sleep(self.delay).await; + Ok(self.agent.clone()) + } + + fn kill(&self, _conversation_id: &str, _reason: Option) -> Result<(), AgentError> { + Ok(()) + } + + fn kill_and_wait( + &self, + _conversation_id: &str, + _reason: Option, + ) -> std::pin::Pin + Send>> { + Box::pin(std::future::ready(())) + } + + async fn clear(&self) {} + + fn active_count(&self) -> usize { + 0 + } + + fn collect_idle(&self, _idle_threshold_ms: TimestampMs) -> Vec { + Vec::new() + } +} + #[async_trait::async_trait] impl IWorkerTaskManager for AgentErrorFailingBuildTaskManager { fn get_task(&self, _conversation_id: &str) -> Option { @@ -3211,6 +3368,7 @@ struct ScriptedAgent { scripts: Mutex>>, sent_contents: Mutex>, send_error: Option, + usage: Option, } impl ScriptedAgent { @@ -3224,6 +3382,7 @@ impl ScriptedAgent { scripts: Mutex::new(VecDeque::from(scripts)), sent_contents: Mutex::new(vec![]), send_error: None, + usage: None, } } @@ -3242,6 +3401,11 @@ impl ScriptedAgent { self } + fn with_usage(mut self, usage: serde_json::Value) -> Self { + self.usage = Some(usage); + self + } + fn sent_contents(&self) -> Vec { self.sent_contents.lock().unwrap().clone() } @@ -3299,7 +3463,12 @@ impl IAgentTask for ScriptedAgent { } } -impl IMockAgent for ScriptedAgent {} +#[async_trait::async_trait] +impl IMockAgent for ScriptedAgent { + async fn get_usage(&self) -> Result, AgentError> { + Ok(self.usage.clone()) + } +} // ── send_message tests ────────────────────────────────────────── @@ -3361,6 +3530,46 @@ async fn send_message_returns_accepted() { assert_ne!(response.msg_id, response.turn_id, "turn_id must not reuse msg_id"); } +#[tokio::test] +async fn turn_guard_blocks_messages_agent_turns_and_runtime_recovery_before_side_effects() { + let (svc, _broadcaster, repo, task_mgr) = make_service(); + svc.with_turn_guard(Arc::new(DenyingTurnGuard)); + let conv = svc.create("user_1", make_create_req()).await.unwrap(); + + let send_error = svc + .send_message("user_1", &conv.id, make_send_req(), &task_mgr) + .await + .unwrap_err(); + assert!(matches!( + send_error, + ConversationError::Forbidden { ref reason } if reason.contains("budget policy") + )); + assert!(repo_messages_asc(&repo, &conv.id, 10).await.is_empty()); + assert!(!svc.runtime_state().is_claimed(&conv.id)); + assert_eq!(task_mgr.active_count(), 0); + + let turn_error = svc + .run_agent_turn(ConversationAgentTurnRequest { + user_id: "user_1".into(), + conversation_id: conv.id.clone(), + content: "scheduled work".into(), + files: Vec::new(), + inject_skills: Vec::new(), + required_runtime_mode: None, + persist_user_message: true, + user_message_hidden: false, + on_started: None, + }) + .await + .unwrap_err(); + assert!(matches!(turn_error, ConversationError::Forbidden { .. })); + assert!(repo_messages_asc(&repo, &conv.id, 10).await.is_empty()); + + let runtime_error = svc.ensure_runtime("user_1", &conv.id, &task_mgr).await.unwrap_err(); + assert!(matches!(runtime_error, ConversationError::Forbidden { .. })); + assert_eq!(task_mgr.active_count(), 0); +} + #[tokio::test] async fn send_message_injects_conversation_runtime_context() { let (svc, _broadcaster, _repo, _default_task_mgr) = make_service(); @@ -5142,6 +5351,55 @@ async fn send_message_records_agent_availability_feedback_on_send_success() { assert!(feedback.failures.lock().unwrap().is_empty()); } +#[tokio::test] +async fn send_message_reports_completed_agent_turn_usage() { + let (svc, _broadcaster, _repo, _default_task_mgr) = make_service(); + let task_mgr = Arc::new(MockTaskManager::new()); + let observer = Arc::new(RecordingTurnObserver::default()); + svc.with_turn_observer(observer.clone()); + + let mut create_req = make_create_req(); + create_req.extra = json!({ + "backend": "codex", + "agent_id": "agent-budget-1", + "agent_source": "builtin", + "workspace": ensure_test_workspace_path() + }); + let conv = svc.create("user_1", create_req).await.unwrap(); + let usage = json!({ + "size": 258400, + "used": 1200, + "cost": { "amount": 0.25, "currency": "USD" } + }); + let scripted_agent = Arc::new( + ScriptedAgent::new( + &conv.id, + vec![vec![AgentStreamEvent::Finish(FinishEventData::default())]], + ) + .with_usage(usage.clone()), + ); + task_mgr.insert_agent(&conv.id, AgentInstance::Mock(scripted_agent)); + + let task_mgr_dyn: Arc = task_mgr.clone(); + let response = svc + .send_message("user_1", &conv.id, make_send_req(), &task_mgr_dyn) + .await + .unwrap(); + wait_for_turn_released(&svc, &conv.id).await; + + let observations = observer.observations.lock().unwrap(); + assert_eq!(observations.len(), 1); + let observation = &observations[0]; + assert_eq!(observation.user_id, "user_1"); + assert_eq!(observation.conversation_id, conv.id); + assert_eq!(observation.turn_id, response.turn_id); + assert_eq!(observation.status, ConversationAgentTurnStatus::Completed); + assert_eq!(observation.agent_id.as_deref(), Some("agent-budget-1")); + assert_eq!(observation.usage.as_ref(), Some(&usage)); + assert_eq!(observation.retry_count, 0); + assert!(observation.duration_ms >= 0); +} + #[tokio::test] async fn send_message_recovers_when_finished_task_has_no_runtime_terminal() { let (svc, _broadcaster, repo, _default_task_mgr) = make_service(); @@ -5528,6 +5786,37 @@ async fn cancel_with_mismatched_turn_id_does_not_cancel_and_returns_current_runt assert!(svc.runtime_state().is_claimed(&conv.id)); } +#[tokio::test(start_paused = true)] +async fn cancel_during_agent_build_prevents_late_prompt_dispatch() { + let (svc, _broadcaster, _repo, _task_mgr) = make_service(); + + let conv = svc.create("user_1", make_create_req()).await.unwrap(); + let agent = Arc::new(CountingSendAgent::new(&conv.id)); + let task_mgr: Arc = Arc::new(DelayedReadyTaskManager::new( + Duration::from_secs(5), + AgentInstance::Mock(agent.clone()), + )); + + let send = svc + .send_message("user_1", &conv.id, make_send_req(), &task_mgr) + .await + .unwrap(); + + let cancel = svc.cancel("user_1", &conv.id, &send.turn_id, &task_mgr).await.unwrap(); + + assert_eq!(cancel.runtime.turn_id.as_deref(), Some(send.turn_id.as_str())); + assert!(cancel.runtime.is_processing); + assert!(svc.runtime_state().is_cancelling(&conv.id)); + + tokio::task::yield_now().await; + tokio::time::advance(Duration::from_secs(5) + Duration::from_millis(1)).await; + tokio::task::yield_now().await; + wait_for_turn_released(&svc, &conv.id).await; + + assert_eq!(agent.send_count(), 0); + assert!(!svc.runtime_state().is_cancelling(&conv.id)); +} + #[tokio::test] async fn cancel_keeps_turn_claim_until_agent_terminal_event() { let (svc, _broadcaster, _repo, _task_mgr) = make_service(); @@ -5600,12 +5889,13 @@ async fn cancel_timeout_kills_acp_task_when_turn_still_claimed() { let conv = svc.create("user_1", make_create_req()).await.unwrap(); let agent = Arc::new(BlockingCancelAgent::new(&conv.id)); - task_mgr.insert_agent(&conv.id, AgentInstance::Mock(agent)); + task_mgr.insert_agent(&conv.id, AgentInstance::Mock(agent.clone())); let send = svc .send_message("user_1", &conv.id, make_send_req(), &task_mgr_dyn) .await .unwrap(); + agent.wait_until_send_started().await; svc.cancel("user_1", &conv.id, &send.turn_id, &task_mgr_dyn) .await @@ -7215,6 +7505,12 @@ async fn get_backfills_legacy_row_and_persists() { status: Some("finished".into()), source: Some("aionui".into()), channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: 0, @@ -7263,6 +7559,12 @@ async fn list_backfills_mixed_rows() { status: None, source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: 1, @@ -7283,6 +7585,12 @@ async fn list_backfills_mixed_rows() { status: None, source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: 2, @@ -7400,6 +7708,12 @@ async fn seed_aionrs_conversation_with_snapshot( status: Some("finished".into()), source: Some("aionui".into()), channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: 1, diff --git a/crates/aionui-conversation/src/session_context.rs b/crates/aionui-conversation/src/session_context.rs index d11e7a23a..e516e1d0b 100644 --- a/crates/aionui-conversation/src/session_context.rs +++ b/crates/aionui-conversation/src/session_context.rs @@ -671,6 +671,12 @@ mod tests { status: None, source: Some("chat".into()), channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: 0, diff --git a/crates/aionui-conversation/src/task_options.rs b/crates/aionui-conversation/src/task_options.rs index 21c35d691..a86a51d74 100644 --- a/crates/aionui-conversation/src/task_options.rs +++ b/crates/aionui-conversation/src/task_options.rs @@ -104,6 +104,12 @@ mod tests { status: None, source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: 0, diff --git a/crates/aionui-conversation/src/turn_orchestrator.rs b/crates/aionui-conversation/src/turn_orchestrator.rs index db2078da4..517c7c521 100644 --- a/crates/aionui-conversation/src/turn_orchestrator.rs +++ b/crates/aionui-conversation/src/turn_orchestrator.rs @@ -11,7 +11,8 @@ use crate::agent_health_policy::{AgentHealthAction, AgentHealthPolicy}; use crate::runtime_state::RuntimeLifecycleState; use crate::runtime_state::TurnClaim; use crate::service::{ - ConversationService, MAX_SYSTEM_RESPONSE_CONTINUATIONS_PER_TURN, agent_error_top_level_code, persist_session_key, + ConversationAgentTurnStatus, ConversationService, ConversationTurnObservation, + MAX_SYSTEM_RESPONSE_CONTINUATIONS_PER_TURN, agent_error_top_level_code, persist_session_key, }; use crate::stream_relay::{RelayOutcome, StreamRelay, TurnAttemptSummary}; use crate::turn_continuation_policy::{ContinuationDecision, TurnContinuationPolicy}; @@ -196,6 +197,15 @@ impl ConversationTurnOrchestrator { while let Some((current_send, msg_id)) = pending_send.take() { let lifecycle = runtime_state.lifecycle_for(&input.conv_id); + if lifecycle == RuntimeLifecycleState::Cancelling { + info!( + conversation_id = %input.conv_id, + turn_id = %input.turn_id, + "Agent prompt dispatch skipped because turn was cancelled before send" + ); + break; + } + let defer_clean_terminal_errors = input.defer_clean_terminal_errors && agent.agent_type() == AgentType::Acp && lifecycle == RuntimeLifecycleState::Active @@ -348,6 +358,7 @@ impl ConversationTurnOrchestrator { } pub(crate) async fn run_user_turn(self, input: TurnStartInput) -> ConversationTurnResult { + let turn_started_at = now_ms(); let mut turn_claim = input.turn_claim; let conv_id = input.conversation.id.clone(); let turn_id = input.turn_id.clone(); @@ -505,6 +516,37 @@ impl ConversationTurnOrchestrator { record_agent_session_success(&self.service, availability_agent_id(&input.build_options).as_deref()).await; } + if let Some(observer) = self.service.turn_observer() { + let occurred_at = now_ms(); + let usage = match self.task_manager.get_task(&conv_id) { + Some(agent) => agent.get_usage().await.ok().flatten(), + None => None, + }; + let context = &input.build_options.context; + let model = context.model.use_model.as_ref().unwrap_or(&context.model.model).clone(); + observer + .observe(ConversationTurnObservation { + user_id: input.user_id.clone(), + conversation_id: conv_id.clone(), + turn_id: turn_id.clone(), + status: if final_failed { + ConversationAgentTurnStatus::Failed + } else { + ConversationAgentTurnStatus::Completed + }, + agent_id: availability_agent_id(&input.build_options), + provider: context.model.provider_id.clone(), + model, + team_id: context.team.as_ref().map(|team| team.team_id.clone()), + slot_id: context.team.as_ref().and_then(|team| team.slot_id.clone()), + usage, + duration_ms: occurred_at.saturating_sub(turn_started_at), + retry_count: i64::from(replayed), + occurred_at, + }) + .await; + } + let was_deleting = turn_claim.release_for_turn(&turn_id); self.service .complete_released_turn(&conv_id, &turn_id, was_deleting) diff --git a/crates/aionui-conversation/tests/acp_tool_call_persistence.rs b/crates/aionui-conversation/tests/acp_tool_call_persistence.rs index 45bcefde3..a68c71a3d 100644 --- a/crates/aionui-conversation/tests/acp_tool_call_persistence.rs +++ b/crates/aionui-conversation/tests/acp_tool_call_persistence.rs @@ -30,6 +30,12 @@ async fn run_acp_tool_call_update_without_insert_creates_placeholder() { status: Some("running".into()), source: Some("aionui".into()), channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: now_ms(), @@ -104,6 +110,12 @@ async fn run_acp_tool_call_late_initial_event_merges_with_update_placeholder() { status: Some("running".into()), source: Some("aionui".into()), channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: now_ms(), diff --git a/crates/aionui-conversation/tests/stream_relay_tips.rs b/crates/aionui-conversation/tests/stream_relay_tips.rs index 926f61527..a60a16c99 100644 --- a/crates/aionui-conversation/tests/stream_relay_tips.rs +++ b/crates/aionui-conversation/tests/stream_relay_tips.rs @@ -28,6 +28,12 @@ async fn setup_repo() -> (Arc, aionui_db::Database status: Some("running".into()), source: Some("aionui".into()), channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: now, diff --git a/crates/aionui-conversation/tests/stream_relay_tool_call.rs b/crates/aionui-conversation/tests/stream_relay_tool_call.rs index 834a62dd2..c04c73610 100644 --- a/crates/aionui-conversation/tests/stream_relay_tool_call.rs +++ b/crates/aionui-conversation/tests/stream_relay_tool_call.rs @@ -57,6 +57,12 @@ async fn setup_repo() -> (Arc, aionui_db::Database status: Some("running".into()), source: Some("aionui".into()), channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: now, diff --git a/crates/aionui-cron/src/executor.rs b/crates/aionui-cron/src/executor.rs index f899ea43d..48b2886c4 100644 --- a/crates/aionui-cron/src/executor.rs +++ b/crates/aionui-cron/src/executor.rs @@ -556,6 +556,12 @@ impl JobExecutor { assistant, source: None, channel_chat_id: None, + source_channel: Some("webui".into()), + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: Some("WebUI".into()), + created_from: Some("cron".into()), extra, }; @@ -2811,6 +2817,12 @@ mod tests { status: Some("finished".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: 0, @@ -2937,6 +2949,12 @@ mod tests { status: Some("finished".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: 0, diff --git a/crates/aionui-cron/src/skill_suggest.rs b/crates/aionui-cron/src/skill_suggest.rs index 029f59bd5..9a4644dc1 100644 --- a/crates/aionui-cron/src/skill_suggest.rs +++ b/crates/aionui-cron/src/skill_suggest.rs @@ -194,6 +194,12 @@ mod tests { status: Some("finished".into()), source: Some("aionui".into()), channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: now_ms(), diff --git a/crates/aionui-cron/tests/service_integration.rs b/crates/aionui-cron/tests/service_integration.rs index 61cb7b928..06b517ce4 100644 --- a/crates/aionui-cron/tests/service_integration.rs +++ b/crates/aionui-cron/tests/service_integration.rs @@ -161,6 +161,12 @@ impl StubConvRepo { status: Some("active".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: "{}".into(), pinned: false, pinned_at: None, @@ -200,6 +206,12 @@ impl IConversationRepository for StubConvRepo { status: Some("active".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::json!({ "backend": "gemini", "agent_name": "Gemini", @@ -230,6 +242,12 @@ impl IConversationRepository for StubConvRepo { status: Some("active".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::json!({ "backend": "hermes", "agent_name": "Hermes", @@ -260,6 +278,12 @@ impl IConversationRepository for StubConvRepo { status: Some("active".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::json!({ "backend": "gemini", "agent_name": "Gemini", @@ -290,6 +314,12 @@ impl IConversationRepository for StubConvRepo { status: Some("active".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::json!({ "backend": "codex", "agent_name": "Codex", @@ -320,6 +350,12 @@ impl IConversationRepository for StubConvRepo { status: Some("active".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::json!({ "backend": "claude", "agent_name": "Claude", @@ -350,6 +386,12 @@ impl IConversationRepository for StubConvRepo { status: Some("active".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::json!({ "backend": "claude", "agent_name": "Gemini", @@ -380,6 +422,12 @@ impl IConversationRepository for StubConvRepo { status: Some("active".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::json!({ "backend": "anthropic", "agent_name": "Aion CLI", @@ -403,6 +451,12 @@ impl IConversationRepository for StubConvRepo { status: Some("active".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::json!({ "assistant_id": "assistant-override", "backend": "claude", @@ -426,6 +480,12 @@ impl IConversationRepository for StubConvRepo { status: Some("active".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::json!({ "assistant_id": "missing-assistant", "backend": "claude", @@ -448,6 +508,12 @@ impl IConversationRepository for StubConvRepo { status: Some("active".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::json!({ "backend": "claude", "agent_name": "Legacy Extra Assistant", @@ -469,6 +535,12 @@ impl IConversationRepository for StubConvRepo { status: Some("active".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: "{}".into(), pinned: false, pinned_at: None, @@ -542,6 +614,12 @@ impl IConversationRepository for StubConvRepo { status: Some("active".into()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: "{}".into(), pinned: false, pinned_at: None, diff --git a/crates/aionui-db/migrations/028_source_channel_metadata.sql b/crates/aionui-db/migrations/028_source_channel_metadata.sql new file mode 100644 index 000000000..231083d44 --- /dev/null +++ b/crates/aionui-db/migrations/028_source_channel_metadata.sql @@ -0,0 +1,143 @@ +-- Add explicit source-channel metadata for conversations and teams. +-- +-- Older rows stored this mostly in `source`, `channel_chat_id`, or +-- `extra.source_channel`. New rows should persist first-class fields so UI +-- grouping and future channel integrations do not depend on JSON inference. + +ALTER TABLE conversations ADD COLUMN source_channel TEXT; +ALTER TABLE conversations ADD COLUMN source_channel_id TEXT; +ALTER TABLE conversations ADD COLUMN source_chat_id TEXT; +ALTER TABLE conversations ADD COLUMN source_user_id TEXT; +ALTER TABLE conversations ADD COLUMN source_label TEXT; +ALTER TABLE conversations ADD COLUMN created_from TEXT; + +UPDATE conversations +SET + source_channel = COALESCE( + NULLIF(json_extract(extra, '$.source_channel'), ''), + CASE + WHEN source = 'aionui' THEN 'webui' + WHEN source IS NOT NULL AND source <> '' THEN source + ELSE NULL + END + ), + source_channel_id = NULLIF(json_extract(extra, '$.source_channel_id'), ''), + source_chat_id = COALESCE( + NULLIF(json_extract(extra, '$.source_chat_id'), ''), + NULLIF(channel_chat_id, '') + ), + source_user_id = NULLIF(json_extract(extra, '$.source_user_id'), ''), + source_label = COALESCE( + NULLIF(json_extract(extra, '$.source_label'), ''), + CASE + WHEN COALESCE(NULLIF(json_extract(extra, '$.source_channel'), ''), source) IN ('aionui', 'webui') THEN 'WebUI' + WHEN COALESCE(NULLIF(json_extract(extra, '$.source_channel'), ''), source) = 'telegram' THEN 'Telegram' + WHEN COALESCE(NULLIF(json_extract(extra, '$.source_channel'), ''), source) = 'discord' THEN 'Discord' + WHEN COALESCE(NULLIF(json_extract(extra, '$.source_channel'), ''), source) = 'lark' THEN 'Lark' + WHEN COALESCE(NULLIF(json_extract(extra, '$.source_channel'), ''), source) = 'wecom' THEN 'WeCom' + WHEN COALESCE(NULLIF(json_extract(extra, '$.source_channel'), ''), source) = 'weixin' THEN 'Weixin' + WHEN COALESCE(NULLIF(json_extract(extra, '$.source_channel'), ''), source) = 'dingtalk' THEN 'DingTalk' + ELSE NULL + END + ), + created_from = COALESCE( + NULLIF(json_extract(extra, '$.created_from'), ''), + CASE + WHEN source = 'aionui' THEN 'webui' + WHEN source IS NOT NULL AND source <> '' THEN source + ELSE NULL + END + ) +WHERE source_channel IS NULL; + +ALTER TABLE teams ADD COLUMN source_channel TEXT; +ALTER TABLE teams ADD COLUMN source_channel_id TEXT; +ALTER TABLE teams ADD COLUMN source_chat_id TEXT; +ALTER TABLE teams ADD COLUMN source_user_id TEXT; +ALTER TABLE teams ADD COLUMN source_label TEXT; +ALTER TABLE teams ADD COLUMN created_from TEXT; + +UPDATE teams +SET + source_channel = ( + SELECT COALESCE( + c.source_channel, + NULLIF(json_extract(c.extra, '$.source_channel'), ''), + CASE + WHEN c.source = 'aionui' THEN 'webui' + WHEN c.source IS NOT NULL AND c.source <> '' THEN c.source + ELSE NULL + END + ) + FROM conversations c + WHERE c.id = COALESCE( + NULLIF(json_extract(teams.agents, '$[0].conversation_id'), ''), + NULLIF(json_extract(teams.agents, '$[0].conversationId'), '') + ) + ), + source_channel_id = ( + SELECT COALESCE(c.source_channel_id, NULLIF(json_extract(c.extra, '$.source_channel_id'), '')) + FROM conversations c + WHERE c.id = COALESCE( + NULLIF(json_extract(teams.agents, '$[0].conversation_id'), ''), + NULLIF(json_extract(teams.agents, '$[0].conversationId'), '') + ) + ), + source_chat_id = ( + SELECT COALESCE(c.source_chat_id, NULLIF(json_extract(c.extra, '$.source_chat_id'), ''), NULLIF(c.channel_chat_id, '')) + FROM conversations c + WHERE c.id = COALESCE( + NULLIF(json_extract(teams.agents, '$[0].conversation_id'), ''), + NULLIF(json_extract(teams.agents, '$[0].conversationId'), '') + ) + ), + source_user_id = ( + SELECT COALESCE(c.source_user_id, NULLIF(json_extract(c.extra, '$.source_user_id'), '')) + FROM conversations c + WHERE c.id = COALESCE( + NULLIF(json_extract(teams.agents, '$[0].conversation_id'), ''), + NULLIF(json_extract(teams.agents, '$[0].conversationId'), '') + ) + ), + source_label = ( + SELECT COALESCE( + c.source_label, + NULLIF(json_extract(c.extra, '$.source_label'), ''), + CASE + WHEN COALESCE(c.source_channel, NULLIF(json_extract(c.extra, '$.source_channel'), ''), c.source) IN ('aionui', 'webui') THEN 'WebUI' + WHEN COALESCE(c.source_channel, NULLIF(json_extract(c.extra, '$.source_channel'), ''), c.source) = 'telegram' THEN 'Telegram' + WHEN COALESCE(c.source_channel, NULLIF(json_extract(c.extra, '$.source_channel'), ''), c.source) = 'discord' THEN 'Discord' + WHEN COALESCE(c.source_channel, NULLIF(json_extract(c.extra, '$.source_channel'), ''), c.source) = 'lark' THEN 'Lark' + WHEN COALESCE(c.source_channel, NULLIF(json_extract(c.extra, '$.source_channel'), ''), c.source) = 'wecom' THEN 'WeCom' + WHEN COALESCE(c.source_channel, NULLIF(json_extract(c.extra, '$.source_channel'), ''), c.source) = 'weixin' THEN 'Weixin' + WHEN COALESCE(c.source_channel, NULLIF(json_extract(c.extra, '$.source_channel'), ''), c.source) = 'dingtalk' THEN 'DingTalk' + ELSE NULL + END + ) + FROM conversations c + WHERE c.id = COALESCE( + NULLIF(json_extract(teams.agents, '$[0].conversation_id'), ''), + NULLIF(json_extract(teams.agents, '$[0].conversationId'), '') + ) + ), + created_from = ( + SELECT COALESCE( + c.created_from, + NULLIF(json_extract(c.extra, '$.created_from'), ''), + CASE + WHEN c.source = 'aionui' THEN 'webui' + WHEN c.source IS NOT NULL AND c.source <> '' THEN c.source + ELSE NULL + END + ) + FROM conversations c + WHERE c.id = COALESCE( + NULLIF(json_extract(teams.agents, '$[0].conversation_id'), ''), + NULLIF(json_extract(teams.agents, '$[0].conversationId'), '') + ) + ) +WHERE source_channel IS NULL; + +CREATE INDEX IF NOT EXISTS idx_conversations_source_channel ON conversations(source_channel); +CREATE INDEX IF NOT EXISTS idx_conversations_source_channel_chat ON conversations(source_channel, source_chat_id, updated_at DESC); +CREATE INDEX IF NOT EXISTS idx_teams_source_channel ON teams(source_channel); diff --git a/crates/aionui-db/migrations/029_telegram_topic_single_agent.sql b/crates/aionui-db/migrations/029_telegram_topic_single_agent.sql new file mode 100644 index 000000000..096665045 --- /dev/null +++ b/crates/aionui-db/migrations/029_telegram_topic_single_agent.sql @@ -0,0 +1,31 @@ +-- Telegram forum topics: one fixed Agent per topic. +ALTER TABLE assistant_sessions ADD COLUMN message_thread_id INTEGER; +ALTER TABLE assistant_sessions ADD COLUMN bound_agent_id TEXT; +ALTER TABLE assistant_sessions ADD COLUMN bound_backend TEXT; +ALTER TABLE assistant_sessions ADD COLUMN bound_provider_id TEXT; +ALTER TABLE assistant_sessions ADD COLUMN bound_model TEXT; + +CREATE UNIQUE INDEX IF NOT EXISTS idx_assistant_sessions_user_chat_thread + ON assistant_sessions(user_id, chat_id, message_thread_id); + +CREATE TABLE IF NOT EXISTS telegram_topic_bindings ( + chat_id TEXT NOT NULL, + message_thread_id INTEGER NOT NULL, + agent_id TEXT NOT NULL, + bound_by_user_id TEXT NOT NULL, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + PRIMARY KEY (chat_id, message_thread_id) +); + +CREATE TABLE IF NOT EXISTS channel_topic_model_overrides ( + platform TEXT NOT NULL, + internal_user_id TEXT NOT NULL, + chat_id TEXT NOT NULL, + message_thread_id INTEGER NOT NULL, + agent_id TEXT NOT NULL, + provider_id TEXT NOT NULL, + model TEXT NOT NULL, + updated_at INTEGER NOT NULL, + PRIMARY KEY (platform, internal_user_id, chat_id, message_thread_id) +); diff --git a/crates/aionui-db/migrations/030_development_projects.sql b/crates/aionui-db/migrations/030_development_projects.sql new file mode 100644 index 000000000..6d0ddf05c --- /dev/null +++ b/crates/aionui-db/migrations/030_development_projects.sql @@ -0,0 +1,62 @@ +CREATE TABLE projects ( + id TEXT PRIMARY KEY NOT NULL, + user_id TEXT NOT NULL, + name TEXT NOT NULL, + local_path TEXT NOT NULL, + repository_url TEXT, + default_branch TEXT, + project_type TEXT NOT NULL DEFAULT 'unknown' + CHECK (project_type IN ('single', 'monorepo', 'unknown')), + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE, + UNIQUE (user_id, local_path) +); + +CREATE INDEX idx_projects_user_updated + ON projects(user_id, updated_at DESC); + +CREATE TABLE project_command_profiles ( + project_id TEXT PRIMARY KEY NOT NULL, + install_command TEXT, + format_command TEXT, + lint_command TEXT, + typecheck_command TEXT, + unit_test_command TEXT, + integration_test_command TEXT, + e2e_command TEXT, + build_command TEXT, + security_scan_command TEXT, + command_timeout_seconds INTEGER NOT NULL DEFAULT 900 + CHECK (command_timeout_seconds > 0), + updated_at INTEGER NOT NULL, + FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE +); + +CREATE TABLE project_runtime_profiles ( + project_id TEXT PRIMARY KEY NOT NULL, + environment_kind TEXT NOT NULL DEFAULT 'local' + CHECK (environment_kind IN ('local', 'container')), + language TEXT, + package_manager TEXT, + runtime_version TEXT, + env_keys TEXT NOT NULL DEFAULT '[]' CHECK (json_valid(env_keys)), + metadata TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(metadata)), + updated_at INTEGER NOT NULL, + FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE +); + +CREATE TABLE project_resource_links ( + project_id TEXT NOT NULL, + user_id TEXT NOT NULL, + resource_type TEXT NOT NULL CHECK (resource_type IN ('conversation', 'team')), + resource_id TEXT NOT NULL, + created_at INTEGER NOT NULL, + PRIMARY KEY (project_id, user_id, resource_type, resource_id), + UNIQUE (user_id, resource_type, resource_id), + FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE, + FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE +); + +CREATE INDEX idx_project_resource_links_project + ON project_resource_links(project_id, resource_type, created_at DESC); diff --git a/crates/aionui-db/migrations/031_agent_workspace_leases.sql b/crates/aionui-db/migrations/031_agent_workspace_leases.sql new file mode 100644 index 000000000..57ab2ef5d --- /dev/null +++ b/crates/aionui-db/migrations/031_agent_workspace_leases.sql @@ -0,0 +1,28 @@ +CREATE TABLE IF NOT EXISTS agent_workspace_leases ( + id TEXT PRIMARY KEY NOT NULL, + team_id TEXT NOT NULL, + user_id TEXT NOT NULL, + slot_id TEXT NOT NULL, + workspace_mode TEXT NOT NULL, + repository_path TEXT NOT NULL, + worktree_path TEXT NOT NULL, + branch_name TEXT NOT NULL, + base_commit TEXT NOT NULL, + allowed_paths TEXT NOT NULL DEFAULT '["."]', + lease_status TEXT NOT NULL DEFAULT 'provisioning', + cleanup_status TEXT NOT NULL DEFAULT 'none', + conflict_files TEXT NOT NULL DEFAULT '[]', + last_error TEXT, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + released_at INTEGER, + UNIQUE(team_id, slot_id), + UNIQUE(worktree_path), + UNIQUE(repository_path, branch_name) +); + +CREATE INDEX IF NOT EXISTS idx_workspace_leases_team + ON agent_workspace_leases(team_id, slot_id); + +CREATE INDEX IF NOT EXISTS idx_workspace_leases_reconcile + ON agent_workspace_leases(lease_status, updated_at); diff --git a/crates/aionui-db/migrations/032_development_quality_gates.sql b/crates/aionui-db/migrations/032_development_quality_gates.sql new file mode 100644 index 000000000..d2f7564c7 --- /dev/null +++ b/crates/aionui-db/migrations/032_development_quality_gates.sql @@ -0,0 +1,132 @@ +DROP INDEX IF EXISTS idx_team_tasks_team_id; + +ALTER TABLE team_tasks RENAME TO _team_tasks_phase3_legacy; + +CREATE TABLE team_tasks ( + id TEXT PRIMARY KEY NOT NULL, + team_id TEXT NOT NULL, + run_id TEXT, + subject TEXT NOT NULL, + description TEXT, + status TEXT NOT NULL DEFAULT 'pending' + CHECK (status IN ( + 'pending', 'ready', 'claimed', 'in_progress', 'waiting_approval', + 'verifying', 'review', 'rework', 'completed', 'failed', 'cancelled', 'deleted' + )), + owner TEXT, + blocked_by TEXT NOT NULL DEFAULT '[]', + blocks TEXT NOT NULL DEFAULT '[]', + metadata TEXT, + acceptance_criteria TEXT NOT NULL DEFAULT '[]', + task_type TEXT NOT NULL DEFAULT 'implementation', + risk_level TEXT NOT NULL DEFAULT 'medium' + CHECK (risk_level IN ('low', 'medium', 'high', 'critical')), + assigned_workspace_lease_id TEXT, + review_status TEXT NOT NULL DEFAULT 'pending' + CHECK (review_status IN ('pending', 'in_review', 'approved', 'changes_requested', 'not_required')), + verification_status TEXT NOT NULL DEFAULT 'pending' + CHECK (verification_status IN ('pending', 'running', 'passed', 'failed', 'not_required')), + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL +); + +INSERT INTO team_tasks ( + id, team_id, subject, description, status, owner, blocked_by, blocks, metadata, created_at, updated_at +) +SELECT id, team_id, subject, description, status, owner, blocked_by, blocks, metadata, created_at, updated_at +FROM _team_tasks_phase3_legacy; + +DROP TABLE _team_tasks_phase3_legacy; + +CREATE INDEX idx_team_tasks_team_id ON team_tasks(team_id); +CREATE INDEX idx_team_tasks_run_id ON team_tasks(run_id, status); +CREATE INDEX idx_team_tasks_workspace_lease ON team_tasks(assigned_workspace_lease_id); + +CREATE TABLE development_runs ( + id TEXT PRIMARY KEY NOT NULL, + user_id TEXT NOT NULL, + project_id TEXT NOT NULL, + team_id TEXT, + source_channel TEXT, + source_user_id TEXT, + execution_mode TEXT NOT NULL CHECK (execution_mode IN ('single', 'team')), + status TEXT NOT NULL DEFAULT 'draft' + CHECK (status IN ( + 'draft', 'preflight', 'running', 'waiting_approval', 'verifying', 'reviewing', + 'integrating', 'rework', 'paused', 'succeeded', 'failed', 'cancelled' + )), + request_summary TEXT NOT NULL, + acceptance_criteria TEXT NOT NULL DEFAULT '[]', + baseline_commit TEXT, + integration_branch TEXT, + started_at INTEGER, + finished_at INTEGER, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + FOREIGN KEY(project_id) REFERENCES projects(id) ON DELETE CASCADE +); + +CREATE INDEX idx_development_runs_user_project ON development_runs(user_id, project_id, updated_at DESC); +CREATE INDEX idx_development_runs_team ON development_runs(team_id, updated_at DESC); + +CREATE TABLE task_artifacts ( + id TEXT PRIMARY KEY NOT NULL, + run_id TEXT NOT NULL, + task_id TEXT, + artifact_type TEXT NOT NULL CHECK (artifact_type IN ('diff', 'test', 'log', 'report', 'commit', 'review', 'no_code_change')), + path_or_uri TEXT NOT NULL, + checksum TEXT NOT NULL, + producer_agent_id TEXT, + metadata TEXT, + created_at INTEGER NOT NULL, + FOREIGN KEY(run_id) REFERENCES development_runs(id) ON DELETE CASCADE, + FOREIGN KEY(task_id) REFERENCES team_tasks(id) ON DELETE CASCADE +); + +CREATE INDEX idx_task_artifacts_task ON task_artifacts(task_id, created_at ASC); +CREATE INDEX idx_task_artifacts_run ON task_artifacts(run_id, created_at ASC); + +CREATE TABLE quality_gate_runs ( + id TEXT PRIMARY KEY NOT NULL, + run_id TEXT NOT NULL, + task_id TEXT, + gate_type TEXT NOT NULL, + command TEXT NOT NULL, + working_directory TEXT NOT NULL, + exit_code INTEGER, + status TEXT NOT NULL CHECK (status IN ('queued', 'running', 'passed', 'failed', 'timed_out', 'cancelled')), + stdout_artifact_id TEXT, + stderr_artifact_id TEXT, + duration_ms INTEGER, + required INTEGER NOT NULL DEFAULT 1, + started_at INTEGER, + finished_at INTEGER, + created_at INTEGER NOT NULL, + FOREIGN KEY(run_id) REFERENCES development_runs(id) ON DELETE CASCADE, + FOREIGN KEY(task_id) REFERENCES team_tasks(id) ON DELETE CASCADE, + FOREIGN KEY(stdout_artifact_id) REFERENCES task_artifacts(id) ON DELETE SET NULL, + FOREIGN KEY(stderr_artifact_id) REFERENCES task_artifacts(id) ON DELETE SET NULL +); + +CREATE INDEX idx_quality_gate_runs_task ON quality_gate_runs(task_id, gate_type, created_at DESC); +CREATE INDEX idx_quality_gate_runs_run ON quality_gate_runs(run_id, created_at DESC); + +CREATE TABLE review_findings ( + id TEXT PRIMARY KEY NOT NULL, + run_id TEXT NOT NULL, + task_id TEXT NOT NULL, + reviewer_agent_id TEXT NOT NULL, + producer_agent_id TEXT, + severity TEXT NOT NULL CHECK (severity IN ('info', 'warning', 'major', 'critical', 'blocker')), + file_path TEXT, + line_number INTEGER, + reason TEXT NOT NULL, + suggestion TEXT, + status TEXT NOT NULL DEFAULT 'open' CHECK (status IN ('open', 'resolved', 'dismissed')), + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + FOREIGN KEY(run_id) REFERENCES development_runs(id) ON DELETE CASCADE, + FOREIGN KEY(task_id) REFERENCES team_tasks(id) ON DELETE CASCADE +); + +CREATE INDEX idx_review_findings_task ON review_findings(task_id, status, severity); diff --git a/crates/aionui-db/migrations/033_development_run_roles.sql b/crates/aionui-db/migrations/033_development_run_roles.sql new file mode 100644 index 000000000..ed923e7da --- /dev/null +++ b/crates/aionui-db/migrations/033_development_run_roles.sql @@ -0,0 +1,10 @@ +CREATE TABLE development_run_roles ( + run_id TEXT NOT NULL, + slot_id TEXT NOT NULL, + role TEXT NOT NULL CHECK (role IN ('implementer', 'tester', 'reviewer', 'integrator')), + assigned_at INTEGER NOT NULL, + PRIMARY KEY(run_id, slot_id, role), + FOREIGN KEY(run_id) REFERENCES development_runs(id) ON DELETE CASCADE +); + +CREATE INDEX idx_development_run_roles_run_role ON development_run_roles(run_id, role, slot_id); diff --git a/crates/aionui-db/migrations/034_approval_requests.sql b/crates/aionui-db/migrations/034_approval_requests.sql new file mode 100644 index 000000000..c2f164a31 --- /dev/null +++ b/crates/aionui-db/migrations/034_approval_requests.sql @@ -0,0 +1,41 @@ +CREATE TABLE approval_requests ( + id TEXT PRIMARY KEY NOT NULL, + requester_user_id TEXT NOT NULL, + project_id TEXT, + run_id TEXT, + task_id TEXT, + conversation_id TEXT NOT NULL, + agent_id TEXT, + call_id TEXT NOT NULL, + action_type TEXT NOT NULL, + command TEXT, + working_directory TEXT, + risk_level TEXT NOT NULL DEFAULT 'medium' + CHECK (risk_level IN ('low', 'medium', 'high', 'critical')), + options TEXT NOT NULL DEFAULT '[]', + status TEXT NOT NULL DEFAULT 'pending' + CHECK (status IN ('pending', 'approved', 'rejected', 'expired', 'cancelled')), + approver_user_id TEXT, + source_channel TEXT, + source_user_id TEXT, + source_chat_id TEXT, + source_thread_id INTEGER, + expires_at INTEGER NOT NULL, + consumed_at INTEGER, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + UNIQUE(conversation_id, call_id), + FOREIGN KEY(requester_user_id) REFERENCES users(id) ON DELETE CASCADE, + FOREIGN KEY(project_id) REFERENCES projects(id) ON DELETE SET NULL, + FOREIGN KEY(run_id) REFERENCES development_runs(id) ON DELETE SET NULL, + FOREIGN KEY(task_id) REFERENCES team_tasks(id) ON DELETE SET NULL, + FOREIGN KEY(conversation_id) REFERENCES conversations(id) ON DELETE CASCADE, + FOREIGN KEY(approver_user_id) REFERENCES users(id) ON DELETE SET NULL +); + +CREATE INDEX idx_approval_requests_user_status + ON approval_requests(requester_user_id, status, created_at DESC); +CREATE INDEX idx_approval_requests_expiry + ON approval_requests(status, expires_at); +CREATE INDEX idx_approval_requests_run_status + ON approval_requests(run_id, status, created_at DESC); diff --git a/crates/aionui-db/migrations/035_development_delivery.sql b/crates/aionui-db/migrations/035_development_delivery.sql new file mode 100644 index 000000000..9e8e5c417 --- /dev/null +++ b/crates/aionui-db/migrations/035_development_delivery.sql @@ -0,0 +1,47 @@ +CREATE TABLE development_deliveries ( + id TEXT PRIMARY KEY, + run_id TEXT NOT NULL UNIQUE REFERENCES development_runs(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + provider TEXT NOT NULL DEFAULT 'github', + repository TEXT, + branch TEXT NOT NULL, + base_branch TEXT NOT NULL, + commit_sha TEXT, + status TEXT NOT NULL DEFAULT 'draft' CHECK (status IN ( + 'draft', 'prepared', 'no_change', 'pushed', 'pr_open', 'ci_pending', + 'ci_failed', 'ci_passed', 'rework_required', 'merge_ready', 'merged', 'failed' + )), + push_status TEXT NOT NULL DEFAULT 'pending', + pr_number INTEGER, + pr_url TEXT, + pr_status TEXT NOT NULL DEFAULT 'not_created', + ci_status TEXT NOT NULL DEFAULT 'not_started', + review_status TEXT NOT NULL DEFAULT 'pending', + merge_status TEXT NOT NULL DEFAULT 'blocked', + report_json TEXT NOT NULL DEFAULT '{}', + last_error TEXT, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL +); + +CREATE INDEX idx_development_deliveries_owner ON development_deliveries(user_id, updated_at DESC); +CREATE INDEX idx_development_deliveries_project ON development_deliveries(project_id, updated_at DESC); + +CREATE TABLE development_ci_checks ( + id TEXT PRIMARY KEY, + delivery_id TEXT NOT NULL REFERENCES development_deliveries(id) ON DELETE CASCADE, + provider_check_id TEXT NOT NULL, + name TEXT NOT NULL, + status TEXT NOT NULL CHECK (status IN ('queued', 'in_progress', 'passed', 'failed', 'cancelled', 'skipped')), + details_url TEXT, + summary TEXT, + rework_task_id TEXT, + started_at INTEGER, + completed_at INTEGER, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + UNIQUE(delivery_id, provider_check_id) +); + +CREATE INDEX idx_development_ci_checks_delivery ON development_ci_checks(delivery_id, updated_at DESC); diff --git a/crates/aionui-db/migrations/036_development_operations.sql b/crates/aionui-db/migrations/036_development_operations.sql new file mode 100644 index 000000000..c8b83b713 --- /dev/null +++ b/crates/aionui-db/migrations/036_development_operations.sql @@ -0,0 +1,171 @@ +CREATE TABLE development_policies ( + id TEXT PRIMARY KEY, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + isolation_mode TEXT NOT NULL DEFAULT 'host' CHECK (isolation_mode IN ('host', 'docker', 'devcontainer')), + container_image TEXT, + devcontainer_config_path TEXT, + container_cpu_millis INTEGER NOT NULL DEFAULT 1000 CHECK (container_cpu_millis BETWEEN 100 AND 64000), + container_memory_mb INTEGER NOT NULL DEFAULT 2048 CHECK (container_memory_mb BETWEEN 128 AND 262144), + container_pids_limit INTEGER NOT NULL DEFAULT 256 CHECK (container_pids_limit BETWEEN 16 AND 32768), + network_mode TEXT NOT NULL DEFAULT 'none' CHECK (network_mode IN ('none', 'bridge')), + allowed_secret_keys_json TEXT NOT NULL DEFAULT '[]' + CHECK (json_valid(allowed_secret_keys_json) AND json_type(allowed_secret_keys_json) = 'array'), + max_duration_ms INTEGER NOT NULL DEFAULT 14400000 CHECK (max_duration_ms > 0), + max_parallel_agents INTEGER NOT NULL DEFAULT 4 CHECK (max_parallel_agents BETWEEN 1 AND 64), + max_retries INTEGER NOT NULL DEFAULT 3 CHECK (max_retries BETWEEN 0 AND 100), + max_cost_microunits INTEGER NOT NULL DEFAULT 0 CHECK (max_cost_microunits >= 0), + alert_percent INTEGER NOT NULL DEFAULT 80 CHECK (alert_percent BETWEEN 1 AND 100), + over_limit_action TEXT NOT NULL DEFAULT 'pause' CHECK (over_limit_action IN ('notify', 'pause', 'terminate')), + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + UNIQUE(user_id, project_id) +); + +CREATE INDEX idx_development_policies_owner ON development_policies(user_id, updated_at DESC); + +CREATE TABLE development_usage_events ( + id TEXT PRIMARY KEY, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + run_id TEXT REFERENCES development_runs(id) ON DELETE CASCADE, + task_id TEXT REFERENCES team_tasks(id) ON DELETE SET NULL, + usage_type TEXT NOT NULL CHECK (usage_type IN ('agent_turn', 'quality_gate', 'delivery', 'recovery', 'other')), + source TEXT NOT NULL CHECK (source IN ('provider', 'agent', 'platform', 'operator')), + confidence TEXT NOT NULL CHECK (confidence IN ('measured', 'reported', 'estimated')), + input_tokens INTEGER NOT NULL DEFAULT 0 CHECK (input_tokens >= 0), + output_tokens INTEGER NOT NULL DEFAULT 0 CHECK (output_tokens >= 0), + cost_microunits INTEGER NOT NULL DEFAULT 0 CHECK (cost_microunits >= 0), + duration_ms INTEGER NOT NULL DEFAULT 0 CHECK (duration_ms >= 0), + retry_count INTEGER NOT NULL DEFAULT 0 CHECK (retry_count >= 0), + metadata_json TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(metadata_json)), + created_at INTEGER NOT NULL +); + +CREATE INDEX idx_development_usage_owner_project ON development_usage_events(user_id, project_id, created_at DESC); +CREATE INDEX idx_development_usage_run ON development_usage_events(run_id, created_at DESC); + +CREATE TRIGGER development_usage_events_no_update +BEFORE UPDATE ON development_usage_events +BEGIN + SELECT RAISE(ABORT, 'development usage events are append-only'); +END; + +CREATE TRIGGER development_usage_events_no_delete +BEFORE DELETE ON development_usage_events +BEGIN + SELECT RAISE(ABORT, 'development usage events are append-only'); +END; + +CREATE TABLE development_audit_events ( + id TEXT PRIMARY KEY, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + actor_type TEXT NOT NULL CHECK (actor_type IN ('user', 'agent', 'system', 'channel')), + actor_id TEXT NOT NULL, + action TEXT NOT NULL, + target_type TEXT NOT NULL, + target_id TEXT NOT NULL, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + run_id TEXT REFERENCES development_runs(id) ON DELETE CASCADE, + task_id TEXT REFERENCES team_tasks(id) ON DELETE SET NULL, + result TEXT NOT NULL CHECK (result IN ('success', 'denied', 'failed')), + redacted_payload_json TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(redacted_payload_json)), + created_at INTEGER NOT NULL +); + +CREATE INDEX idx_development_audit_owner_project ON development_audit_events(user_id, project_id, created_at DESC); +CREATE INDEX idx_development_audit_run ON development_audit_events(run_id, created_at DESC); + +CREATE TRIGGER development_audit_events_no_update +BEFORE UPDATE ON development_audit_events +BEGIN + SELECT RAISE(ABORT, 'development audit events are append-only'); +END; + +CREATE TRIGGER development_audit_events_no_delete +BEFORE DELETE ON development_audit_events +BEGIN + SELECT RAISE(ABORT, 'development audit events are append-only'); +END; + +CREATE TABLE development_alerts ( + id TEXT PRIMARY KEY, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + run_id TEXT REFERENCES development_runs(id) ON DELETE CASCADE, + alert_type TEXT NOT NULL CHECK (alert_type IN ('budget', 'environment', 'recovery', 'security', 'delivery')), + severity TEXT NOT NULL CHECK (severity IN ('info', 'warning', 'critical')), + status TEXT NOT NULL DEFAULT 'open' CHECK (status IN ('open', 'acknowledged', 'resolved')), + message TEXT NOT NULL, + dedupe_key TEXT NOT NULL, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + resolved_at INTEGER, + UNIQUE(user_id, dedupe_key) +); + +CREATE INDEX idx_development_alerts_owner_project ON development_alerts(user_id, project_id, status, updated_at DESC); +CREATE INDEX idx_development_alerts_run ON development_alerts(run_id, status, updated_at DESC); + +CREATE TABLE development_recovery_records ( + id TEXT PRIMARY KEY, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + run_id TEXT REFERENCES development_runs(id) ON DELETE CASCADE, + recovery_key TEXT NOT NULL, + finding TEXT NOT NULL, + decision TEXT NOT NULL CHECK (decision IN ('healthy', 'manual_required', 'resume', 'terminate', 'interrupted')), + status_before TEXT, + status_after TEXT, + details_json TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(details_json)), + created_at INTEGER NOT NULL, + UNIQUE(user_id, recovery_key) +); + +CREATE INDEX idx_development_recovery_owner_project + ON development_recovery_records(user_id, project_id, created_at DESC); +CREATE INDEX idx_development_recovery_run ON development_recovery_records(run_id, created_at DESC); + +DROP INDEX idx_quality_gate_runs_task; +DROP INDEX idx_quality_gate_runs_run; +ALTER TABLE quality_gate_runs RENAME TO _quality_gate_runs_phase6_legacy; + +CREATE TABLE quality_gate_runs ( + id TEXT PRIMARY KEY NOT NULL, + run_id TEXT NOT NULL, + task_id TEXT, + gate_type TEXT NOT NULL, + command TEXT NOT NULL, + working_directory TEXT NOT NULL, + exit_code INTEGER, + status TEXT NOT NULL CHECK (status IN ( + 'queued', 'running', 'passed', 'failed', 'timed_out', 'cancelled', 'interrupted' + )), + stdout_artifact_id TEXT, + stderr_artifact_id TEXT, + duration_ms INTEGER, + isolation_mode TEXT NOT NULL DEFAULT 'host' + CHECK (isolation_mode IN ('host', 'docker', 'devcontainer')), + execution_id TEXT, + required INTEGER NOT NULL DEFAULT 1, + started_at INTEGER, + finished_at INTEGER, + created_at INTEGER NOT NULL, + FOREIGN KEY(run_id) REFERENCES development_runs(id) ON DELETE CASCADE, + FOREIGN KEY(task_id) REFERENCES team_tasks(id) ON DELETE CASCADE, + FOREIGN KEY(stdout_artifact_id) REFERENCES task_artifacts(id) ON DELETE SET NULL, + FOREIGN KEY(stderr_artifact_id) REFERENCES task_artifacts(id) ON DELETE SET NULL +); + +INSERT INTO quality_gate_runs ( + id, run_id, task_id, gate_type, command, working_directory, exit_code, status, + stdout_artifact_id, stderr_artifact_id, duration_ms, required, started_at, finished_at, created_at +) +SELECT + id, run_id, task_id, gate_type, command, working_directory, exit_code, status, + stdout_artifact_id, stderr_artifact_id, duration_ms, required, started_at, finished_at, created_at +FROM _quality_gate_runs_phase6_legacy; + +DROP TABLE _quality_gate_runs_phase6_legacy; +CREATE INDEX idx_quality_gate_runs_task ON quality_gate_runs(task_id, gate_type, created_at DESC); +CREATE INDEX idx_quality_gate_runs_run ON quality_gate_runs(run_id, created_at DESC); diff --git a/crates/aionui-db/migrations/037_agent_dynamic_probe.sql b/crates/aionui-db/migrations/037_agent_dynamic_probe.sql new file mode 100644 index 000000000..d062ebd65 --- /dev/null +++ b/crates/aionui-db/migrations/037_agent_dynamic_probe.sql @@ -0,0 +1 @@ +ALTER TABLE agent_metadata ADD COLUMN dynamic_probe_result TEXT; diff --git a/crates/aionui-db/migrations/038_project_repository_lifecycle.sql b/crates/aionui-db/migrations/038_project_repository_lifecycle.sql new file mode 100644 index 000000000..5a3ccf094 --- /dev/null +++ b/crates/aionui-db/migrations/038_project_repository_lifecycle.sql @@ -0,0 +1,40 @@ +CREATE TABLE project_repository_facts ( + project_id TEXT PRIMARY KEY NOT NULL, + repository_url TEXT, + default_branch TEXT, + baseline_commit TEXT, + repository_dirty INTEGER NOT NULL DEFAULT 0 CHECK (repository_dirty IN (0, 1)), + dirty_worktree_choice TEXT NOT NULL CHECK (dirty_worktree_choice IN ('preserve', 'snapshot', 'reject')), + dirty_snapshot_ref TEXT, + credential_reference TEXT, + detected_languages_json TEXT NOT NULL DEFAULT '[]' CHECK (json_valid(detected_languages_json)), + detected_package_managers_json TEXT NOT NULL DEFAULT '[]' CHECK (json_valid(detected_package_managers_json)), + detected_rules_files_json TEXT NOT NULL DEFAULT '[]' CHECK (json_valid(detected_rules_files_json)), + monorepo_packages_json TEXT NOT NULL DEFAULT '[]' CHECK (json_valid(monorepo_packages_json)), + submodules_json TEXT NOT NULL DEFAULT '[]' CHECK (json_valid(submodules_json)), + lfs_detected INTEGER NOT NULL DEFAULT 0 CHECK (lfs_detected IN (0, 1)), + detected_at INTEGER NOT NULL, + FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE +); + +ALTER TABLE project_resource_links RENAME TO project_resource_links_legacy; + +CREATE TABLE project_resource_links ( + project_id TEXT NOT NULL, + user_id TEXT NOT NULL, + resource_type TEXT NOT NULL CHECK (resource_type IN ('conversation', 'team', 'cron', 'channel')), + resource_id TEXT NOT NULL, + created_at INTEGER NOT NULL, + PRIMARY KEY (project_id, user_id, resource_type, resource_id), + UNIQUE (user_id, resource_type, resource_id), + FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE, + FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE +); + +INSERT INTO project_resource_links (project_id, user_id, resource_type, resource_id, created_at) +SELECT project_id, user_id, resource_type, resource_id, created_at FROM project_resource_links_legacy; + +DROP TABLE project_resource_links_legacy; + +CREATE INDEX idx_project_resource_links_project + ON project_resource_links(project_id, resource_type, created_at DESC); diff --git a/crates/aionui-db/migrations/039_project_knowledge.sql b/crates/aionui-db/migrations/039_project_knowledge.sql new file mode 100644 index 000000000..154ec0daf --- /dev/null +++ b/crates/aionui-db/migrations/039_project_knowledge.sql @@ -0,0 +1,50 @@ +CREATE TABLE project_knowledge_indexes ( + project_id TEXT PRIMARY KEY NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + provider TEXT NOT NULL, + provider_project_name TEXT NOT NULL, + provider_version TEXT, + status TEXT NOT NULL CHECK(status IN ('healthy', 'stale', 'indexing', 'failed', 'unavailable')), + generation INTEGER NOT NULL DEFAULT 0 CHECK(generation >= 0), + source_commit TEXT, + indexed_at INTEGER, + changed_paths_json TEXT NOT NULL DEFAULT '[]', + error_category TEXT, + updated_at INTEGER NOT NULL +); + +CREATE UNIQUE INDEX idx_project_knowledge_provider_name + ON project_knowledge_indexes(provider, provider_project_name); +CREATE INDEX idx_project_knowledge_status + ON project_knowledge_indexes(status, updated_at); + +CREATE TABLE project_knowledge_facts ( + id TEXT PRIMARY KEY NOT NULL, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + generation INTEGER NOT NULL CHECK(generation > 0), + kind TEXT NOT NULL CHECK(kind IN ('symbol', 'caller', 'test', 'route', 'data_entity', 'architecture')), + name TEXT NOT NULL, + qualified_name TEXT, + source_path TEXT NOT NULL, + source_line INTEGER CHECK(source_line IS NULL OR source_line > 0), + indexed_at INTEGER NOT NULL +); + +CREATE INDEX idx_project_knowledge_facts_generation + ON project_knowledge_facts(project_id, generation, kind, name); + +CREATE TABLE project_knowledge_contexts ( + id TEXT PRIMARY KEY NOT NULL, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + provider_project_name TEXT NOT NULL, + generation INTEGER NOT NULL CHECK(generation > 0), + query TEXT NOT NULL, + symbols_json TEXT NOT NULL DEFAULT '[]', + callers_json TEXT NOT NULL DEFAULT '[]', + tests_json TEXT NOT NULL DEFAULT '[]', + routes_json TEXT NOT NULL DEFAULT '[]', + data_entities_json TEXT NOT NULL DEFAULT '[]', + created_at INTEGER NOT NULL +); + +CREATE INDEX idx_project_knowledge_contexts_project + ON project_knowledge_contexts(project_id, created_at DESC); diff --git a/crates/aionui-db/migrations/040_development_requirements.sql b/crates/aionui-db/migrations/040_development_requirements.sql new file mode 100644 index 000000000..ab379dce2 --- /dev/null +++ b/crates/aionui-db/migrations/040_development_requirements.sql @@ -0,0 +1,82 @@ +CREATE TABLE development_requirement_versions ( + id TEXT PRIMARY KEY NOT NULL, + run_id TEXT NOT NULL, + version INTEGER NOT NULL CHECK (version > 0), + content TEXT NOT NULL, + change_summary TEXT, + created_by TEXT NOT NULL, + created_at INTEGER NOT NULL, + FOREIGN KEY(run_id) REFERENCES development_runs(id) ON DELETE CASCADE, + UNIQUE(run_id, version) +); + +CREATE TABLE development_acceptance_criteria ( + id TEXT PRIMARY KEY NOT NULL, + run_id TEXT NOT NULL, + requirement_version_id TEXT NOT NULL, + ordinal INTEGER NOT NULL CHECK (ordinal >= 0), + statement TEXT NOT NULL, + required INTEGER NOT NULL DEFAULT 1, + created_at INTEGER NOT NULL, + FOREIGN KEY(run_id) REFERENCES development_runs(id) ON DELETE CASCADE, + FOREIGN KEY(requirement_version_id) REFERENCES development_requirement_versions(id) ON DELETE CASCADE, + UNIQUE(requirement_version_id, ordinal) +); + +CREATE TABLE development_plan_revisions ( + id TEXT PRIMARY KEY NOT NULL, + run_id TEXT NOT NULL, + revision INTEGER NOT NULL CHECK (revision > 0), + summary TEXT NOT NULL, + content TEXT NOT NULL, + created_by TEXT NOT NULL, + created_at INTEGER NOT NULL, + FOREIGN KEY(run_id) REFERENCES development_runs(id) ON DELETE CASCADE, + UNIQUE(run_id, revision) +); + +CREATE TABLE development_task_criteria ( + run_id TEXT NOT NULL, + task_id TEXT NOT NULL, + criterion_id TEXT NOT NULL, + mapped_at INTEGER NOT NULL, + PRIMARY KEY(task_id, criterion_id), + FOREIGN KEY(run_id) REFERENCES development_runs(id) ON DELETE CASCADE, + FOREIGN KEY(task_id) REFERENCES team_tasks(id) ON DELETE CASCADE, + FOREIGN KEY(criterion_id) REFERENCES development_acceptance_criteria(id) ON DELETE CASCADE +); + +CREATE TABLE development_completion_evidence ( + id TEXT PRIMARY KEY NOT NULL, + run_id TEXT NOT NULL, + task_id TEXT NOT NULL, + criterion_id TEXT NOT NULL, + evidence_type TEXT NOT NULL CHECK (evidence_type IN ('code', 'test', 'no_change')), + artifact_id TEXT, + reference TEXT NOT NULL, + accepted INTEGER NOT NULL DEFAULT 0, + reviewer_id TEXT, + created_at INTEGER NOT NULL, + FOREIGN KEY(run_id) REFERENCES development_runs(id) ON DELETE CASCADE, + FOREIGN KEY(task_id) REFERENCES team_tasks(id) ON DELETE CASCADE, + FOREIGN KEY(criterion_id) REFERENCES development_acceptance_criteria(id) ON DELETE CASCADE, + FOREIGN KEY(artifact_id) REFERENCES task_artifacts(id) ON DELETE SET NULL +); + +CREATE INDEX idx_development_requirements_run ON development_requirement_versions(run_id, version); +CREATE INDEX idx_development_criteria_run ON development_acceptance_criteria(run_id, requirement_version_id, ordinal); +CREATE INDEX idx_development_plan_run ON development_plan_revisions(run_id, revision); +CREATE INDEX idx_development_evidence_criterion ON development_completion_evidence(run_id, criterion_id, accepted); + +CREATE TRIGGER development_requirement_versions_no_update +BEFORE UPDATE ON development_requirement_versions BEGIN SELECT RAISE(ABORT, 'requirement versions are append-only'); END; +CREATE TRIGGER development_requirement_versions_no_delete +BEFORE DELETE ON development_requirement_versions BEGIN SELECT RAISE(ABORT, 'requirement versions are append-only'); END; +CREATE TRIGGER development_plan_revisions_no_update +BEFORE UPDATE ON development_plan_revisions BEGIN SELECT RAISE(ABORT, 'plan revisions are append-only'); END; +CREATE TRIGGER development_plan_revisions_no_delete +BEFORE DELETE ON development_plan_revisions BEGIN SELECT RAISE(ABORT, 'plan revisions are append-only'); END; +CREATE TRIGGER development_completion_evidence_no_update +BEFORE UPDATE ON development_completion_evidence BEGIN SELECT RAISE(ABORT, 'completion evidence is append-only'); END; +CREATE TRIGGER development_completion_evidence_no_delete +BEFORE DELETE ON development_completion_evidence BEGIN SELECT RAISE(ABORT, 'completion evidence is append-only'); END; diff --git a/crates/aionui-db/migrations/041_single_run_workspace.sql b/crates/aionui-db/migrations/041_single_run_workspace.sql new file mode 100644 index 000000000..7d6542b53 --- /dev/null +++ b/crates/aionui-db/migrations/041_single_run_workspace.sql @@ -0,0 +1,22 @@ +CREATE TABLE development_single_run_workspaces ( + run_id TEXT PRIMARY KEY NOT NULL, + user_id TEXT NOT NULL, + project_id TEXT NOT NULL, + baseline_commit TEXT NOT NULL, + initial_diff_checksum TEXT NOT NULL, + initial_diff_path TEXT NOT NULL, + workspace_lease_id TEXT, + workspace_path TEXT, + branch TEXT, + candidate_commit TEXT, + safe_point TEXT NOT NULL, + cleanup_status TEXT NOT NULL DEFAULT 'active', + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + FOREIGN KEY(run_id) REFERENCES development_runs(id) ON DELETE CASCADE, + FOREIGN KEY(project_id) REFERENCES projects(id) ON DELETE CASCADE +); + +CREATE UNIQUE INDEX idx_single_run_workspace_lease +ON development_single_run_workspaces(workspace_lease_id) +WHERE workspace_lease_id IS NOT NULL; diff --git a/crates/aionui-db/migrations/042_execution_resource_leases.sql b/crates/aionui-db/migrations/042_execution_resource_leases.sql new file mode 100644 index 000000000..09e19665d --- /dev/null +++ b/crates/aionui-db/migrations/042_execution_resource_leases.sql @@ -0,0 +1,43 @@ +CREATE TABLE execution_resource_leases ( + id TEXT PRIMARY KEY NOT NULL, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + run_id TEXT NOT NULL REFERENCES development_runs(id) ON DELETE CASCADE, + task_id TEXT, + turn_id TEXT, + gate_id TEXT, + environment_id TEXT NOT NULL, + environment_kind TEXT NOT NULL CHECK (environment_kind IN ('host', 'docker', 'devcontainer')), + resource_kind TEXT NOT NULL CHECK (resource_kind IN ('process', 'container', 'service', 'port', 'lock', 'workspace')), + resource_identifier TEXT NOT NULL, + status TEXT NOT NULL CHECK (status IN ('active', 'stopping', 'released', 'cleanup_failed', 'orphaned')), + accepts_work INTEGER NOT NULL DEFAULT 1 CHECK (accepts_work IN (0, 1)), + owner_instance_id TEXT NOT NULL, + heartbeat_at INTEGER NOT NULL, + expires_at INTEGER NOT NULL, + cleanup_order INTEGER NOT NULL, + cleanup_status TEXT, + cleanup_result TEXT, + recovery_decision TEXT CHECK (recovery_decision IS NULL OR recovery_decision IN ('retry', 'rollback', 'takeover', 'terminate')), + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + terminal_at INTEGER +); + +CREATE INDEX idx_execution_resource_leases_run + ON execution_resource_leases(user_id, run_id, status, cleanup_order); + +CREATE INDEX idx_execution_resource_leases_heartbeat + ON execution_resource_leases(status, accepts_work, expires_at, heartbeat_at); + +CREATE TABLE execution_environment_bindings ( + entity_type TEXT NOT NULL CHECK (entity_type IN ('run', 'task', 'turn', 'gate')), + entity_id TEXT NOT NULL, + environment_id TEXT NOT NULL, + environment_kind TEXT NOT NULL CHECK (environment_kind IN ('host', 'docker', 'devcontainer')), + bound_at INTEGER NOT NULL, + PRIMARY KEY (entity_type, entity_id, environment_id) +); + +CREATE INDEX idx_execution_environment_bindings_environment + ON execution_environment_bindings(environment_id, entity_type, entity_id); diff --git a/crates/aionui-db/migrations/043_development_secrets_and_pricing.sql b/crates/aionui-db/migrations/043_development_secrets_and_pricing.sql new file mode 100644 index 000000000..4730ed1da --- /dev/null +++ b/crates/aionui-db/migrations/043_development_secrets_and_pricing.sql @@ -0,0 +1,129 @@ +ALTER TABLE development_policies RENAME TO _development_policies_phase7_legacy; + +CREATE TABLE development_policies ( + id TEXT PRIMARY KEY, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + isolation_mode TEXT NOT NULL DEFAULT 'host' CHECK (isolation_mode IN ('host', 'docker', 'devcontainer')), + container_image TEXT, + devcontainer_config_path TEXT, + container_cpu_millis INTEGER NOT NULL DEFAULT 1000 CHECK (container_cpu_millis BETWEEN 100 AND 64000), + container_memory_mb INTEGER NOT NULL DEFAULT 2048 CHECK (container_memory_mb BETWEEN 128 AND 262144), + container_pids_limit INTEGER NOT NULL DEFAULT 256 CHECK (container_pids_limit BETWEEN 16 AND 32768), + network_mode TEXT NOT NULL DEFAULT 'none' CHECK (network_mode IN ('none', 'bridge')), + allowed_secret_keys_json TEXT NOT NULL DEFAULT '[]' + CHECK (json_valid(allowed_secret_keys_json) AND json_type(allowed_secret_keys_json) = 'array'), + allowed_commands_json TEXT NOT NULL DEFAULT '[]' + CHECK (json_valid(allowed_commands_json) AND json_type(allowed_commands_json) = 'array'), + protected_paths_json TEXT NOT NULL DEFAULT '[]' + CHECK (json_valid(protected_paths_json) AND json_type(protected_paths_json) = 'array'), + allowed_network_hosts_json TEXT NOT NULL DEFAULT '[]' + CHECK (json_valid(allowed_network_hosts_json) AND json_type(allowed_network_hosts_json) = 'array'), + protected_branches_json TEXT NOT NULL DEFAULT '["main","master"]' + CHECK (json_valid(protected_branches_json) AND json_type(protected_branches_json) = 'array'), + dangerous_confirmation_count INTEGER NOT NULL DEFAULT 2 CHECK (dangerous_confirmation_count BETWEEN 1 AND 2), + max_duration_ms INTEGER NOT NULL DEFAULT 14400000 CHECK (max_duration_ms > 0), + max_parallel_agents INTEGER NOT NULL DEFAULT 4 CHECK (max_parallel_agents BETWEEN 1 AND 64), + max_retries INTEGER NOT NULL DEFAULT 3 CHECK (max_retries BETWEEN 0 AND 100), + max_cost_microunits INTEGER NOT NULL DEFAULT 0 CHECK (max_cost_microunits >= 0), + max_total_tokens INTEGER NOT NULL DEFAULT 0 CHECK (max_total_tokens >= 0), + fallback_model TEXT, + alert_percent INTEGER NOT NULL DEFAULT 80 CHECK (alert_percent BETWEEN 1 AND 100), + over_limit_action TEXT NOT NULL DEFAULT 'pause' + CHECK (over_limit_action IN ('notify', 'pause', 'downgrade_model', 'terminate')), + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + UNIQUE(user_id, project_id) +); + +INSERT INTO development_policies ( + id, user_id, project_id, isolation_mode, container_image, devcontainer_config_path, + container_cpu_millis, container_memory_mb, container_pids_limit, network_mode, + allowed_secret_keys_json, max_duration_ms, max_parallel_agents, max_retries, + max_cost_microunits, alert_percent, over_limit_action, created_at, updated_at +) +SELECT + id, user_id, project_id, isolation_mode, container_image, devcontainer_config_path, + container_cpu_millis, container_memory_mb, container_pids_limit, network_mode, + allowed_secret_keys_json, max_duration_ms, max_parallel_agents, max_retries, + max_cost_microunits, alert_percent, over_limit_action, created_at, updated_at +FROM _development_policies_phase7_legacy; + +DROP TABLE _development_policies_phase7_legacy; + +CREATE INDEX idx_development_policies_owner ON development_policies(user_id, updated_at DESC); + +CREATE TABLE development_secrets ( + id TEXT PRIMARY KEY NOT NULL, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + name TEXT NOT NULL, + encrypted_value TEXT NOT NULL, + key_version TEXT NOT NULL DEFAULT 'application-v1', + status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'revoked')), + expires_at INTEGER, + revoked_at INTEGER, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + UNIQUE(user_id, project_id, name) +); + +CREATE INDEX idx_development_secrets_owner + ON development_secrets(user_id, project_id, status, updated_at DESC); + +CREATE TABLE development_secret_grants ( + id TEXT PRIMARY KEY NOT NULL, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + secret_id TEXT NOT NULL REFERENCES development_secrets(id) ON DELETE CASCADE, + scope_type TEXT NOT NULL CHECK (scope_type IN ('project', 'run', 'agent')), + scope_id TEXT NOT NULL, + environment_key TEXT NOT NULL, + status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'revoked')), + expires_at INTEGER, + revoked_at INTEGER, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + UNIQUE(user_id, secret_id, scope_type, scope_id, environment_key) +); + +CREATE INDEX idx_development_secret_grants_lookup + ON development_secret_grants(user_id, project_id, secret_id, status, scope_type, scope_id); + +CREATE TABLE development_model_prices ( + id TEXT PRIMARY KEY NOT NULL, + provider TEXT NOT NULL, + model TEXT NOT NULL, + input_per_million_microunits INTEGER NOT NULL CHECK (input_per_million_microunits >= 0), + output_per_million_microunits INTEGER NOT NULL CHECK (output_per_million_microunits >= 0), + cache_read_per_million_microunits INTEGER NOT NULL CHECK (cache_read_per_million_microunits >= 0), + cache_write_per_million_microunits INTEGER NOT NULL CHECK (cache_write_per_million_microunits >= 0), + source_id TEXT NOT NULL, + version TEXT NOT NULL, + effective_at INTEGER NOT NULL, + created_at INTEGER NOT NULL, + UNIQUE(provider, model, source_id, version) +); + +CREATE INDEX idx_development_model_prices_lookup + ON development_model_prices(provider, model, effective_at DESC, created_at DESC); + +ALTER TABLE development_usage_events ADD COLUMN conversation_id TEXT; +ALTER TABLE development_usage_events ADD COLUMN agent_id TEXT; +ALTER TABLE development_usage_events ADD COLUMN team_id TEXT; +ALTER TABLE development_usage_events ADD COLUMN provider TEXT; +ALTER TABLE development_usage_events ADD COLUMN model TEXT; +ALTER TABLE development_usage_events ADD COLUMN cache_read_tokens INTEGER NOT NULL DEFAULT 0; +ALTER TABLE development_usage_events ADD COLUMN cache_write_tokens INTEGER NOT NULL DEFAULT 0; +ALTER TABLE development_usage_events ADD COLUMN cost_status TEXT NOT NULL DEFAULT 'unknown'; +ALTER TABLE development_usage_events ADD COLUMN cost_origin TEXT NOT NULL DEFAULT 'unknown'; +ALTER TABLE development_usage_events ADD COLUMN price_source_id TEXT; +ALTER TABLE development_usage_events ADD COLUMN price_version TEXT; +ALTER TABLE development_usage_events ADD COLUMN price_effective_at INTEGER; + +CREATE INDEX idx_development_usage_conversation + ON development_usage_events(user_id, conversation_id, created_at DESC); +CREATE INDEX idx_development_usage_agent + ON development_usage_events(user_id, agent_id, created_at DESC); +CREATE INDEX idx_development_usage_team + ON development_usage_events(user_id, team_id, created_at DESC); diff --git a/crates/aionui-db/migrations/044_development_deployments.sql b/crates/aionui-db/migrations/044_development_deployments.sql new file mode 100644 index 000000000..c282bdf98 --- /dev/null +++ b/crates/aionui-db/migrations/044_development_deployments.sql @@ -0,0 +1,54 @@ +CREATE TABLE development_delivery_tags ( + id TEXT PRIMARY KEY NOT NULL, + delivery_id TEXT NOT NULL REFERENCES development_deliveries(id) ON DELETE CASCADE, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + name TEXT NOT NULL, + commit_sha TEXT NOT NULL, + remote_url TEXT, + status TEXT NOT NULL DEFAULT 'succeeded' + CHECK (status IN ('pending', 'succeeded', 'failed', 'unknown_remote_state')), + last_error TEXT, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + UNIQUE(delivery_id, name) +); + +CREATE INDEX idx_development_delivery_tags_owner + ON development_delivery_tags(user_id, delivery_id, updated_at DESC); + +CREATE TABLE development_deployments ( + id TEXT PRIMARY KEY NOT NULL, + deployment_key TEXT NOT NULL, + run_id TEXT NOT NULL REFERENCES development_runs(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + environment TEXT NOT NULL, + commit_sha TEXT NOT NULL, + status TEXT NOT NULL DEFAULT 'pending_approval' + CHECK (status IN ( + 'pending_approval', 'approved', 'running', 'succeeded', 'failed', + 'cancelled', 'unknown_remote_state' + )), + requested_by TEXT NOT NULL, + approved_by TEXT, + approval_run_id TEXT NOT NULL, + approval_environment TEXT NOT NULL, + approval_commit_sha TEXT NOT NULL, + approval_requester TEXT NOT NULL, + approval_deployment_key TEXT NOT NULL, + approval_expires_at INTEGER NOT NULL, + approved_at INTEGER, + remote_id TEXT, + attempt_count INTEGER NOT NULL DEFAULT 0 CHECK (attempt_count >= 0), + last_error TEXT, + started_at INTEGER, + finished_at INTEGER, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + UNIQUE(user_id, deployment_key) +); + +CREATE INDEX idx_development_deployments_run + ON development_deployments(user_id, run_id, updated_at DESC); +CREATE INDEX idx_development_deployments_status + ON development_deployments(status, updated_at ASC); diff --git a/crates/aionui-db/migrations/045_platform_instance_and_evaluations.sql b/crates/aionui-db/migrations/045_platform_instance_and_evaluations.sql new file mode 100644 index 000000000..40d261aa9 --- /dev/null +++ b/crates/aionui-db/migrations/045_platform_instance_and_evaluations.sql @@ -0,0 +1,73 @@ +CREATE TABLE platform_instances ( + singleton INTEGER PRIMARY KEY NOT NULL DEFAULT 1 CHECK (singleton = 1), + instance_id TEXT NOT NULL UNIQUE, + schema_version INTEGER NOT NULL, + app_version TEXT NOT NULL, + first_started_at INTEGER NOT NULL, + last_started_at INTEGER NOT NULL +); + +INSERT INTO platform_instances ( + singleton, instance_id, schema_version, app_version, first_started_at, last_started_at +) VALUES ( + 1, lower(hex(randomblob(16))), 34, '0.1.39', + CAST(unixepoch('subsec') * 1000 AS INTEGER), + CAST(unixepoch('subsec') * 1000 AS INTEGER) +); + +CREATE TABLE development_evaluations ( + id TEXT PRIMARY KEY NOT NULL, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + release_id TEXT NOT NULL, + scenario_id TEXT NOT NULL, + result TEXT NOT NULL CHECK (result IN ('passed', 'failed', 'error', 'skipped')), + duration_ms INTEGER NOT NULL CHECK (duration_ms >= 0), + failure_category TEXT, + input_tokens INTEGER NOT NULL DEFAULT 0 CHECK (input_tokens >= 0), + output_tokens INTEGER NOT NULL DEFAULT 0 CHECK (output_tokens >= 0), + cost_microunits INTEGER NOT NULL DEFAULT 0 CHECK (cost_microunits >= 0), + cost_source TEXT NOT NULL, + accepted_baseline INTEGER NOT NULL DEFAULT 0 CHECK (accepted_baseline IN (0, 1)), + created_at INTEGER NOT NULL, + UNIQUE(user_id, project_id, release_id, scenario_id) +); + +CREATE INDEX idx_development_evaluations_release + ON development_evaluations(user_id, project_id, release_id, scenario_id); + +CREATE INDEX idx_development_evaluations_baseline + ON development_evaluations(user_id, project_id, scenario_id, accepted_baseline, created_at DESC); + +CREATE TABLE development_evaluation_baselines ( + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + release_id TEXT NOT NULL, + accepted_at INTEGER NOT NULL, + PRIMARY KEY (user_id, project_id) +); + +CREATE TABLE development_retention_policies ( + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + conversation_history_days INTEGER NOT NULL DEFAULT 365 CHECK (conversation_history_days BETWEEN 1 AND 3650), + artifact_days INTEGER NOT NULL DEFAULT 90 CHECK (artifact_days BETWEEN 1 AND 3650), + evaluation_days INTEGER NOT NULL DEFAULT 365 CHECK (evaluation_days BETWEEN 1 AND 3650), + immutable_audit_log INTEGER NOT NULL DEFAULT 1 CHECK (immutable_audit_log = 1), + updated_at INTEGER NOT NULL, + PRIMARY KEY (user_id, project_id) +); + +CREATE TABLE development_retention_executions ( + id TEXT PRIMARY KEY NOT NULL, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + message_count INTEGER NOT NULL CHECK (message_count >= 0), + artifact_count INTEGER NOT NULL CHECK (artifact_count >= 0), + evaluation_count INTEGER NOT NULL CHECK (evaluation_count >= 0), + audit_events_retained INTEGER NOT NULL CHECK (audit_events_retained >= 0), + created_at INTEGER NOT NULL +); + +CREATE INDEX idx_development_retention_executions_project + ON development_retention_executions(user_id, project_id, created_at DESC); diff --git a/crates/aionui-db/migrations/046_development_recovery_actions.sql b/crates/aionui-db/migrations/046_development_recovery_actions.sql new file mode 100644 index 000000000..a38b91488 --- /dev/null +++ b/crates/aionui-db/migrations/046_development_recovery_actions.sql @@ -0,0 +1,60 @@ +CREATE TABLE development_recovery_records_v2 ( + id TEXT PRIMARY KEY, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE, + run_id TEXT REFERENCES development_runs(id) ON DELETE CASCADE, + recovery_key TEXT NOT NULL, + finding TEXT NOT NULL, + decision TEXT NOT NULL CHECK ( + decision IN ( + 'healthy', + 'manual_required', + 'resume', + 'retry', + 'rollback', + 'takeover', + 'terminate', + 'interrupted' + ) + ), + status_before TEXT, + status_after TEXT, + details_json TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(details_json)), + created_at INTEGER NOT NULL, + UNIQUE(user_id, recovery_key) +); + +INSERT INTO development_recovery_records_v2 ( + id, + user_id, + project_id, + run_id, + recovery_key, + finding, + decision, + status_before, + status_after, + details_json, + created_at +) +SELECT + id, + user_id, + project_id, + run_id, + recovery_key, + finding, + decision, + status_before, + status_after, + details_json, + created_at +FROM development_recovery_records; + +DROP TABLE development_recovery_records; +ALTER TABLE development_recovery_records_v2 RENAME TO development_recovery_records; + +CREATE INDEX idx_development_recovery_owner_project + ON development_recovery_records(user_id, project_id, created_at DESC); +CREATE INDEX idx_development_recovery_run + ON development_recovery_records(run_id, created_at DESC); diff --git a/crates/aionui-db/src/database.rs b/crates/aionui-db/src/database.rs index 2f46f71e5..e06213b0c 100644 --- a/crates/aionui-db/src/database.rs +++ b/crates/aionui-db/src/database.rs @@ -1,3 +1,4 @@ +use std::fmt::Write as _; use std::fs::OpenOptions; use std::path::{Path, PathBuf}; use std::str::FromStr; @@ -29,6 +30,35 @@ static DB_MIGRATOR: Migrator = sqlx::migrate!(); // Historical special-case for the MCP schema reconciliation fallback. // Keep this pinned to migration version 7 even as newer migrations land. const MCP_SCHEMA_RECONCILIATION_MIGRATION_VERSION: i64 = 7; +#[derive(Clone, Copy)] +struct LegacyRoadmapMigrationLayout { + start: i64, + end: i64, + shift: i64, +} + +const LEGACY_ROADMAP_MIGRATION_LAYOUTS: [LegacyRoadmapMigrationLayout; 2] = [ + LegacyRoadmapMigrationLayout { + start: 17, + end: 34, + shift: 11, + }, + LegacyRoadmapMigrationLayout { + start: 26, + end: 43, + shift: 2, + }, +]; +const LEGACY_ROADMAP_CHECKSUM_ALIASES: &[(i64, &str)] = &[ + ( + 20, + "41297AC04B19B0C1361F6CA41064766AB2DA5784115F3FA7B936A8856B372458AEA5AA30754A7FEB13A649EB9E192C52", + ), + ( + 21, + "DCB189DEAC028EB386E2E6B3CEFD9B04F9D80F2CB21AE437C3B020D624065FF133C940F6AC34582D89AD439DAADD6DB5", + ), +]; const RECOVERABLE_DATABASE_CORRUPTION_STAGE: &str = "database.recoverable_corruption"; /// Wraps a SQLite connection pool with lifecycle management. @@ -346,6 +376,9 @@ async fn run_migrations_staged(pool: &SqlitePool) -> Result<(), DatabaseInitErro // `_sqlx_migrations` blows up with `UNIQUE constraint failed: // _sqlx_migrations.version`. The outer startup lock also covers // schema-repair and connection PRAGMAs before migration execution. + reconcile_legacy_roadmap_migration_versions(pool) + .await + .map_err(|e| DatabaseInitError::new("database.migration_compatibility", e))?; ensure_schema_columns(pool) .await .map_err(|e| DatabaseInitError::new("database.schema_repair", e))?; @@ -374,6 +407,130 @@ async fn run_migrations_staged(pool: &SqlitePool) -> Result<(), DatabaseInitErro result } +async fn reconcile_legacy_roadmap_migration_versions(pool: &SqlitePool) -> Result<(), DbError> { + let migrations_table_exists: bool = + sqlx::query_scalar("SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '_sqlx_migrations'") + .fetch_one(pool) + .await + .map_err(DbError::Query)?; + if !migrations_table_exists { + return Ok(()); + } + + for layout in LEGACY_ROADMAP_MIGRATION_LAYOUTS { + if reconcile_legacy_roadmap_migration_layout(pool, layout).await? { + break; + } + } + Ok(()) +} + +async fn reconcile_legacy_roadmap_migration_layout( + pool: &SqlitePool, + layout: LegacyRoadmapMigrationLayout, +) -> Result { + let rows: Vec<(i64, String, Vec, bool)> = sqlx::query_as( + "SELECT version, description, checksum, success FROM _sqlx_migrations \ + WHERE version BETWEEN ? AND ? ORDER BY version", + ) + .bind(layout.start) + .bind(layout.end) + .fetch_all(pool) + .await + .map_err(DbError::Query)?; + + let Some(first) = rows.first() else { + return Ok(false); + }; + let Some(first_target) = DB_MIGRATOR + .iter() + .find(|migration| migration.version == first.0 + layout.shift) + else { + return Ok(false); + }; + if first.0 != layout.start + || first.1 != first_target.description.as_ref() + || first.2.as_slice() != first_target.checksum.as_ref() + { + return Ok(false); + } + + let mut expected_version = layout.start; + for (version, description, checksum, success) in &rows { + if *version != expected_version { + return Err(DbError::Init(format!( + "Legacy roadmap migration history is not contiguous at version {expected_version}" + ))); + } + let target_version = version + layout.shift; + let Some(target) = DB_MIGRATOR.iter().find(|migration| migration.version == target_version) else { + return Err(DbError::Init(format!( + "Legacy roadmap migration {version} has no current target version {target_version}" + ))); + }; + if !*success + || description != target.description.as_ref() + || !legacy_roadmap_checksum_matches(*version, checksum, target.checksum.as_ref()) + { + return Err(DbError::Init(format!( + "Legacy roadmap migration {version} does not match the known immutable migration" + ))); + } + expected_version += 1; + } + + let last_legacy_version = expected_version - 1; + let mut transaction = pool.begin().await.map_err(DbError::Query)?; + sqlx::query("UPDATE _sqlx_migrations SET version = version + 1000 WHERE version BETWEEN ? AND ?") + .bind(layout.start) + .bind(last_legacy_version) + .execute(&mut *transaction) + .await + .map_err(DbError::Query)?; + + for version in layout.start..=last_legacy_version { + let target_version = version + layout.shift; + let target = DB_MIGRATOR + .iter() + .find(|migration| migration.version == target_version) + .expect("validated legacy roadmap migration target must exist"); + sqlx::query("UPDATE _sqlx_migrations SET version = ?, description = ?, checksum = ? WHERE version = ?") + .bind(target_version) + .bind(&*target.description) + .bind(&*target.checksum) + .bind(version + 1000) + .execute(&mut *transaction) + .await + .map_err(DbError::Query)?; + } + transaction.commit().await.map_err(DbError::Query)?; + info!( + "Reconciled legacy roadmap migration versions {}-{} to {}-{}", + layout.start, + last_legacy_version, + layout.start + layout.shift, + last_legacy_version + layout.shift + ); + Ok(true) +} + +fn legacy_roadmap_checksum_matches(version: i64, legacy_checksum: &[u8], current_checksum: &[u8]) -> bool { + if legacy_checksum == current_checksum { + return true; + } + let Some((_, accepted_hex)) = LEGACY_ROADMAP_CHECKSUM_ALIASES + .iter() + .find(|(legacy_version, _)| *legacy_version == version) + else { + return false; + }; + let mut actual_hex = String::with_capacity(legacy_checksum.len() * 2); + for byte in legacy_checksum { + write!(&mut actual_hex, "{byte:02X}").expect("writing to a String cannot fail"); + } + actual_hex == *accepted_hex +} + /// Run sqlx migrations with one retry on `_sqlx_migrations` UNIQUE conflict. /// /// The advisory file lock above already serialises well-behaved processes, diff --git a/crates/aionui-db/src/lib.rs b/crates/aionui-db/src/lib.rs index dae365284..a3b6ab1d3 100644 --- a/crates/aionui-db/src/lib.rs +++ b/crates/aionui-db/src/lib.rs @@ -23,11 +23,19 @@ pub use error::{ }; pub use instance_lock::{DataDirInstanceGuard, instance_lock_path}; pub use models::{ - AgentMetadataRow, AssistantDefinitionRow, AssistantOverlayRow, AssistantOverrideRow, AssistantPreferenceRow, - AssistantRow, ConversationArtifactRow, ConversationAssistantSnapshotRow, CreateAssistantParams, - SkillImportRecordRow, SkillRow, UpdateAgentAvailabilitySnapshotParams, UpdateAgentHandshakeParams, + AcceptanceCriterionRow, AgentMetadataRow, AgentWorkspaceLeaseRow, ApprovalRequestRow, AssistantDefinitionRow, + AssistantOverlayRow, AssistantOverrideRow, AssistantPreferenceRow, AssistantRow, CompletionEvidenceRow, + ConversationArtifactRow, ConversationAssistantSnapshotRow, CreateAssistantParams, DevelopmentAlertRow, + DevelopmentAuditEventRow, DevelopmentDeliveryRow, DevelopmentDeliveryTagRow, DevelopmentDeploymentRow, + DevelopmentModelPriceRow, DevelopmentPolicyRow, DevelopmentPricedUsageEventRow, DevelopmentRecoveryRecordRow, + DevelopmentRunRoleRow, DevelopmentRunRow, DevelopmentSecretGrantRow, DevelopmentSecretRow, DevelopmentTaskRow, + DevelopmentUsageDimensionSummary, DevelopmentUsageEventRow, DevelopmentUsageSummary, ExecutionResourceLeaseRow, + PlanRevisionRow, ProjectCommandProfileRow, ProjectKnowledgeContextRow, ProjectKnowledgeFactRow, + ProjectKnowledgeIndexRow, ProjectRepositoryFactsRow, ProjectResourceLinkRow, ProjectRow, ProjectRuntimeProfileRow, + QualityGateRunRow, RequirementVersionRow, ReviewFindingRow, SingleRunWorkspaceRow, SkillImportRecordRow, SkillRow, + TaskArtifactRow, TaskCriterionRow, UpdateAgentAvailabilitySnapshotParams, UpdateAgentHandshakeParams, UpdateAssistantParams, UpsertAgentMetadataParams, UpsertAssistantDefinitionParams, UpsertAssistantOverlayParams, - UpsertAssistantPreferenceParams, UpsertConversationAssistantSnapshotParams, UpsertOverrideParams, + UpsertAssistantPreferenceParams, UpsertConversationAssistantSnapshotParams, UpsertOverrideParams, UsageDimension, }; pub use repository::channel::UpdatePluginStatusParams; pub use repository::conversation::{ @@ -39,24 +47,28 @@ pub use repository::cron::{ }; pub use repository::mcp_server::{CreateMcpServerParams, UpdateMcpServerParams}; pub use repository::oauth_token::UpsertOAuthTokenParams; +pub use repository::project::UpdateProjectParams; pub use repository::provider::{CreateProviderParams, UpdateProviderParams}; pub use repository::remote_agent::{CreateRemoteAgentParams, UpdateRemoteAgentParams}; pub use repository::skill::{CreateSkillImportRecordParams, UpsertSkillParams}; pub use repository::team::{UpdateTaskParams, UpdateTeamParams}; pub use repository::{ - CreateAcpSessionParams, FeedbackDiagnosticsDbContext, FeedbackDiagnosticsProfile, FeedbackDiagnosticsProfileResult, - FeedbackDiagnosticsRequest, FeedbackDiagnosticsResult, IAcpSessionRepository, IAgentMetadataRepository, - IAssistantDefinitionRepository, IAssistantOverlayRepository, IAssistantOverrideRepository, - IAssistantPreferenceRepository, IAssistantRepository, IChannelRepository, IClientPreferenceRepository, - IConversationRepository, ICronRepository, IFeedbackDiagnosticsRepository, IMcpServerRepository, - IOAuthTokenRepository, IProviderRepository, IRemoteAgentRepository, ISettingsRepository, ISkillRepository, - ITeamRepository, IUserRepository, PersistedSessionState, SaveRuntimeStateParams, SqliteAcpSessionRepository, - SqliteAgentMetadataRepository, SqliteAssistantDefinitionRepository, SqliteAssistantOverlayRepository, + AgentWorkspaceLeaseUpdate, CreateAcpSessionParams, FeedbackDiagnosticsDbContext, FeedbackDiagnosticsProfile, + FeedbackDiagnosticsProfileResult, FeedbackDiagnosticsRequest, FeedbackDiagnosticsResult, IAcpSessionRepository, + IAgentMetadataRepository, IAgentWorkspaceLeaseRepository, IApprovalRepository, IAssistantDefinitionRepository, + IAssistantOverlayRepository, IAssistantOverrideRepository, IAssistantPreferenceRepository, IAssistantRepository, + IChannelRepository, IClientPreferenceRepository, IConversationRepository, ICronRepository, + IDevelopmentOperationsRepository, IDevelopmentRepository, IFeedbackDiagnosticsRepository, IMcpServerRepository, + IOAuthTokenRepository, IProjectRepository, IProviderRepository, IRemoteAgentRepository, ISettingsRepository, + ISkillRepository, ITeamRepository, IUserRepository, PersistedSessionState, SaveRuntimeStateParams, + SqliteAcpSessionRepository, SqliteAgentMetadataRepository, SqliteAgentWorkspaceLeaseRepository, + SqliteApprovalRepository, SqliteAssistantDefinitionRepository, SqliteAssistantOverlayRepository, SqliteAssistantOverrideRepository, SqliteAssistantPreferenceRepository, SqliteAssistantRepository, SqliteChannelRepository, SqliteClientPreferenceRepository, SqliteConversationRepository, SqliteCronRepository, - SqliteFeedbackDiagnosticsRepository, SqliteMcpServerRepository, SqliteOAuthTokenRepository, - SqliteProviderRepository, SqliteRemoteAgentRepository, SqliteSettingsRepository, SqliteSkillRepository, - SqliteTeamRepository, SqliteUserRepository, + SqliteDevelopmentOperationsRepository, SqliteDevelopmentRepository, SqliteFeedbackDiagnosticsRepository, + SqliteMcpServerRepository, SqliteOAuthTokenRepository, SqliteProjectRepository, SqliteProviderRepository, + SqliteRemoteAgentRepository, SqliteSettingsRepository, SqliteSkillRepository, SqliteTeamRepository, + SqliteUserRepository, }; // Re-export sqlx pool type for downstream crates diff --git a/crates/aionui-db/src/models/agent_metadata.rs b/crates/aionui-db/src/models/agent_metadata.rs index ec1b19653..81805f0a1 100644 --- a/crates/aionui-db/src/models/agent_metadata.rs +++ b/crates/aionui-db/src/models/agent_metadata.rs @@ -58,6 +58,10 @@ pub struct AgentMetadataRow { pub last_success_at: Option, pub last_failure_at: Option, + /// Last successful normalized six-stage dynamic probe, encoded as JSON. + /// The latest failed attempt remains in the availability error columns. + pub dynamic_probe_result: Option, + pub command_override: Option, pub env_override: Option, @@ -123,4 +127,5 @@ pub struct UpdateAgentAvailabilitySnapshotParams<'a> { pub last_check_at: Option, pub last_success_at: Option, pub last_failure_at: Option, + pub dynamic_probe_result: Option<&'a str>, } diff --git a/crates/aionui-db/src/models/approval.rs b/crates/aionui-db/src/models/approval.rs new file mode 100644 index 000000000..29e8e6aad --- /dev/null +++ b/crates/aionui-db/src/models/approval.rs @@ -0,0 +1,30 @@ +use aionui_common::TimestampMs; +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct ApprovalRequestRow { + pub id: String, + pub requester_user_id: String, + pub project_id: Option, + pub run_id: Option, + pub task_id: Option, + pub conversation_id: String, + pub agent_id: Option, + pub call_id: String, + pub action_type: String, + pub command: Option, + pub working_directory: Option, + pub risk_level: String, + /// JSON array of the immutable choices presented to the requester. + pub options: String, + pub status: String, + pub approver_user_id: Option, + pub source_channel: Option, + pub source_user_id: Option, + pub source_chat_id: Option, + pub source_thread_id: Option, + pub expires_at: TimestampMs, + pub consumed_at: Option, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} diff --git a/crates/aionui-db/src/models/channel.rs b/crates/aionui-db/src/models/channel.rs index 51ee8a320..026dbab65 100644 --- a/crates/aionui-db/src/models/channel.rs +++ b/crates/aionui-db/src/models/channel.rs @@ -49,10 +49,37 @@ pub struct AssistantSessionRow { pub conversation_id: Option, pub workspace: Option, pub chat_id: Option, + pub message_thread_id: Option, + pub bound_agent_id: Option, + pub bound_backend: Option, + pub bound_provider_id: Option, + pub bound_model: Option, pub created_at: TimestampMs, pub last_activity: TimestampMs, } +#[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)] +pub struct TelegramTopicBindingRow { + pub chat_id: String, + pub message_thread_id: i64, + pub agent_id: String, + pub bound_by_user_id: String, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)] +pub struct ChannelTopicModelOverrideRow { + pub platform: String, + pub internal_user_id: String, + pub chat_id: String, + pub message_thread_id: i64, + pub agent_id: String, + pub provider_id: String, + pub model: String, + pub updated_at: TimestampMs, +} + /// Row mapping for the `assistant_pairing_codes` table. /// /// 6-digit pairing code with 10-minute expiry. Status transitions: diff --git a/crates/aionui-db/src/models/conversation.rs b/crates/aionui-db/src/models/conversation.rs index 14e6cb675..c628a7324 100644 --- a/crates/aionui-db/src/models/conversation.rs +++ b/crates/aionui-db/src/models/conversation.rs @@ -27,6 +27,13 @@ pub struct ConversationRow { pub source: Option, /// Channel isolation ID (e.g. "user:xxx", "group:xxx"). pub channel_chat_id: Option, + /// Explicit product source channel (webui, desktop, telegram, discord, ...). + pub source_channel: Option, + pub source_channel_id: Option, + pub source_chat_id: Option, + pub source_user_id: Option, + pub source_label: Option, + pub created_from: Option, /// Whether this conversation is pinned (SQLite INTEGER 0/1). pub pinned: bool, pub pinned_at: Option, diff --git a/crates/aionui-db/src/models/development.rs b/crates/aionui-db/src/models/development.rs new file mode 100644 index 000000000..9726f9253 --- /dev/null +++ b/crates/aionui-db/src/models/development.rs @@ -0,0 +1,259 @@ +use aionui_common::TimestampMs; +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentRunRow { + pub id: String, + pub user_id: String, + pub project_id: String, + pub team_id: Option, + pub source_channel: Option, + pub source_user_id: Option, + pub execution_mode: String, + pub status: String, + pub request_summary: String, + pub acceptance_criteria: String, + pub baseline_commit: Option, + pub integration_branch: Option, + pub started_at: Option, + pub finished_at: Option, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentTaskRow { + pub id: String, + pub team_id: String, + pub run_id: Option, + pub subject: String, + pub description: Option, + pub status: String, + pub owner: Option, + pub blocked_by: String, + pub blocks: String, + pub metadata: Option, + pub acceptance_criteria: String, + pub task_type: String, + pub risk_level: String, + pub assigned_workspace_lease_id: Option, + pub review_status: String, + pub verification_status: String, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentRunRoleRow { + pub run_id: String, + pub slot_id: String, + pub role: String, + pub assigned_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct TaskArtifactRow { + pub id: String, + pub run_id: String, + pub task_id: Option, + pub artifact_type: String, + pub path_or_uri: String, + pub checksum: String, + pub producer_agent_id: Option, + pub metadata: Option, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct QualityGateRunRow { + pub id: String, + pub run_id: String, + pub task_id: Option, + pub gate_type: String, + pub command: String, + pub working_directory: String, + pub exit_code: Option, + pub status: String, + pub stdout_artifact_id: Option, + pub stderr_artifact_id: Option, + pub duration_ms: Option, + pub isolation_mode: String, + pub execution_id: Option, + pub required: bool, + pub started_at: Option, + pub finished_at: Option, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct ReviewFindingRow { + pub id: String, + pub run_id: String, + pub task_id: String, + pub reviewer_agent_id: String, + pub producer_agent_id: Option, + pub severity: String, + pub file_path: Option, + pub line_number: Option, + pub reason: String, + pub suggestion: Option, + pub status: String, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentDeliveryRow { + pub id: String, + pub run_id: String, + pub project_id: String, + pub user_id: String, + pub provider: String, + pub repository: Option, + pub branch: String, + pub base_branch: String, + pub commit_sha: Option, + pub status: String, + pub push_status: String, + pub pr_number: Option, + pub pr_url: Option, + pub pr_status: String, + pub ci_status: String, + pub review_status: String, + pub merge_status: String, + pub report_json: String, + pub last_error: Option, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentCiCheckRow { + pub id: String, + pub delivery_id: String, + pub provider_check_id: String, + pub name: String, + pub status: String, + pub details_url: Option, + pub summary: Option, + pub rework_task_id: Option, + pub started_at: Option, + pub completed_at: Option, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentDeliveryTagRow { + pub id: String, + pub delivery_id: String, + pub user_id: String, + pub name: String, + pub commit_sha: String, + pub remote_url: Option, + pub status: String, + pub last_error: Option, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentDeploymentRow { + pub id: String, + pub deployment_key: String, + pub run_id: String, + pub project_id: String, + pub user_id: String, + pub environment: String, + pub commit_sha: String, + pub status: String, + pub requested_by: String, + pub approved_by: Option, + pub approval_run_id: String, + pub approval_environment: String, + pub approval_commit_sha: String, + pub approval_requester: String, + pub approval_deployment_key: String, + pub approval_expires_at: TimestampMs, + pub approved_at: Option, + pub remote_id: Option, + pub attempt_count: i64, + pub last_error: Option, + pub started_at: Option, + pub finished_at: Option, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct RequirementVersionRow { + pub id: String, + pub run_id: String, + pub version: i64, + pub content: String, + pub change_summary: Option, + pub created_by: String, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct AcceptanceCriterionRow { + pub id: String, + pub run_id: String, + pub requirement_version_id: String, + pub ordinal: i64, + pub statement: String, + pub required: bool, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct PlanRevisionRow { + pub id: String, + pub run_id: String, + pub revision: i64, + pub summary: String, + pub content: String, + pub created_by: String, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct TaskCriterionRow { + pub run_id: String, + pub task_id: String, + pub criterion_id: String, + pub mapped_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct CompletionEvidenceRow { + pub id: String, + pub run_id: String, + pub task_id: String, + pub criterion_id: String, + pub evidence_type: String, + pub artifact_id: Option, + pub reference: String, + pub accepted: bool, + pub reviewer_id: Option, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct SingleRunWorkspaceRow { + pub run_id: String, + pub user_id: String, + pub project_id: String, + pub baseline_commit: String, + pub initial_diff_checksum: String, + pub initial_diff_path: String, + pub workspace_lease_id: Option, + pub workspace_path: Option, + pub branch: Option, + pub candidate_commit: Option, + pub safe_point: String, + pub cleanup_status: String, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} diff --git a/crates/aionui-db/src/models/development_operations.rs b/crates/aionui-db/src/models/development_operations.rs new file mode 100644 index 000000000..b7d491df1 --- /dev/null +++ b/crates/aionui-db/src/models/development_operations.rs @@ -0,0 +1,236 @@ +use aionui_common::TimestampMs; +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentPolicyRow { + pub id: String, + pub user_id: String, + pub project_id: String, + pub isolation_mode: String, + pub container_image: Option, + pub devcontainer_config_path: Option, + pub container_cpu_millis: i64, + pub container_memory_mb: i64, + pub container_pids_limit: i64, + pub network_mode: String, + pub allowed_secret_keys_json: String, + pub allowed_commands_json: String, + pub protected_paths_json: String, + pub allowed_network_hosts_json: String, + pub protected_branches_json: String, + pub dangerous_confirmation_count: i64, + pub max_duration_ms: i64, + pub max_parallel_agents: i64, + pub max_retries: i64, + pub max_cost_microunits: i64, + pub max_total_tokens: i64, + pub fallback_model: Option, + pub alert_percent: i64, + pub over_limit_action: String, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentUsageEventRow { + pub id: String, + pub user_id: String, + pub project_id: String, + pub run_id: Option, + pub task_id: Option, + pub usage_type: String, + pub source: String, + pub confidence: String, + pub input_tokens: i64, + pub output_tokens: i64, + pub cost_microunits: i64, + pub duration_ms: i64, + pub retry_count: i64, + pub metadata_json: String, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentUsageSummary { + pub event_count: i64, + pub input_tokens: i64, + pub output_tokens: i64, + pub cost_microunits: i64, + pub duration_ms: i64, + pub retry_count: i64, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentAuditEventRow { + pub id: String, + pub user_id: String, + pub actor_type: String, + pub actor_id: String, + pub action: String, + pub target_type: String, + pub target_id: String, + pub project_id: String, + pub run_id: Option, + pub task_id: Option, + pub result: String, + pub redacted_payload_json: String, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentAlertRow { + pub id: String, + pub user_id: String, + pub project_id: String, + pub run_id: Option, + pub alert_type: String, + pub severity: String, + pub status: String, + pub message: String, + pub dedupe_key: String, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, + pub resolved_at: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentRecoveryRecordRow { + pub id: String, + pub user_id: String, + pub project_id: String, + pub run_id: Option, + pub recovery_key: String, + pub finding: String, + pub decision: String, + pub status_before: Option, + pub status_after: Option, + pub details_json: String, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct ExecutionResourceLeaseRow { + pub id: String, + pub user_id: String, + pub project_id: String, + pub run_id: String, + pub task_id: Option, + pub turn_id: Option, + pub gate_id: Option, + pub environment_id: String, + pub environment_kind: String, + pub resource_kind: String, + pub resource_identifier: String, + pub status: String, + pub accepts_work: i64, + pub owner_instance_id: String, + pub heartbeat_at: TimestampMs, + pub expires_at: TimestampMs, + pub cleanup_order: i64, + pub cleanup_status: Option, + pub cleanup_result: Option, + pub recovery_decision: Option, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, + pub terminal_at: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentSecretRow { + pub id: String, + pub user_id: String, + pub project_id: String, + pub name: String, + pub encrypted_value: String, + pub key_version: String, + pub status: String, + pub expires_at: Option, + pub revoked_at: Option, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentSecretGrantRow { + pub id: String, + pub user_id: String, + pub project_id: String, + pub secret_id: String, + pub scope_type: String, + pub scope_id: String, + pub environment_key: String, + pub status: String, + pub expires_at: Option, + pub revoked_at: Option, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentModelPriceRow { + pub id: String, + pub provider: String, + pub model: String, + pub input_per_million_microunits: i64, + pub output_per_million_microunits: i64, + pub cache_read_per_million_microunits: i64, + pub cache_write_per_million_microunits: i64, + pub source_id: String, + pub version: String, + pub effective_at: TimestampMs, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentPricedUsageEventRow { + pub id: String, + pub user_id: String, + pub project_id: String, + pub run_id: Option, + pub task_id: Option, + pub conversation_id: Option, + pub agent_id: Option, + pub team_id: Option, + pub usage_type: String, + pub source: String, + pub confidence: String, + pub provider: String, + pub model: String, + pub input_tokens: i64, + pub output_tokens: i64, + pub cache_read_tokens: i64, + pub cache_write_tokens: i64, + pub cost_microunits: i64, + pub cost_status: String, + pub cost_origin: String, + pub price_source_id: Option, + pub price_version: Option, + pub price_effective_at: Option, + pub duration_ms: i64, + pub retry_count: i64, + pub metadata_json: String, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum UsageDimension { + Project(String), + Run(String), + Task(String), + Conversation(String), + Agent(String), + Team(String), +} + +#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct DevelopmentUsageDimensionSummary { + pub event_count: i64, + pub input_tokens: i64, + pub output_tokens: i64, + pub cache_read_tokens: i64, + pub cache_write_tokens: i64, + pub known_cost_microunits: i64, + pub unknown_cost_events: i64, + pub duration_ms: i64, + pub retry_count: i64, +} diff --git a/crates/aionui-db/src/models/mod.rs b/crates/aionui-db/src/models/mod.rs index 076836557..9e6e996f6 100644 --- a/crates/aionui-db/src/models/mod.rs +++ b/crates/aionui-db/src/models/mod.rs @@ -1,41 +1,67 @@ mod acp_session; mod agent_metadata; +mod approval; mod assistant; mod channel; mod client_preference; mod conversation; mod conversation_artifact; mod cron_job; +mod development; +mod development_operations; mod mcp_server; mod message; mod oauth_token; +mod project; mod provider; mod remote_agent; mod skill; mod system_settings; mod team; mod user; +mod workspace_lease; pub use acp_session::AcpSessionRow; pub use agent_metadata::{ AgentMetadataRow, UpdateAgentAvailabilitySnapshotParams, UpdateAgentHandshakeParams, UpsertAgentMetadataParams, }; +pub use approval::ApprovalRequestRow; pub use assistant::{ AssistantDefinitionRow, AssistantOverlayRow, AssistantOverrideRow, AssistantPreferenceRow, AssistantRow, CreateAssistantParams, UpdateAssistantParams, UpsertAssistantDefinitionParams, UpsertAssistantOverlayParams, UpsertAssistantPreferenceParams, UpsertOverrideParams, }; -pub use channel::{AssistantSessionRow, AssistantUserRow, ChannelPluginRow, PairingCodeRow}; +pub use channel::{ + AssistantSessionRow, AssistantUserRow, ChannelPluginRow, ChannelTopicModelOverrideRow, PairingCodeRow, + TelegramTopicBindingRow, +}; pub use client_preference::ClientPreference; pub use conversation::{ConversationAssistantSnapshotRow, ConversationRow, UpsertConversationAssistantSnapshotParams}; pub use conversation_artifact::ConversationArtifactRow; pub use cron_job::CronJobRow; +pub use development::{ + AcceptanceCriterionRow, CompletionEvidenceRow, DevelopmentCiCheckRow, DevelopmentDeliveryRow, + DevelopmentDeliveryTagRow, DevelopmentDeploymentRow, DevelopmentRunRoleRow, DevelopmentRunRow, DevelopmentTaskRow, + PlanRevisionRow, QualityGateRunRow, RequirementVersionRow, ReviewFindingRow, SingleRunWorkspaceRow, + TaskArtifactRow, TaskCriterionRow, +}; +pub use development_operations::{ + DevelopmentAlertRow, DevelopmentAuditEventRow, DevelopmentModelPriceRow, DevelopmentPolicyRow, + DevelopmentPricedUsageEventRow, DevelopmentRecoveryRecordRow, DevelopmentSecretGrantRow, DevelopmentSecretRow, + DevelopmentUsageDimensionSummary, DevelopmentUsageEventRow, DevelopmentUsageSummary, ExecutionResourceLeaseRow, + UsageDimension, +}; pub use mcp_server::McpServerRow; pub use message::MessageRow; pub use oauth_token::OAuthTokenRow; +pub use project::{ + ProjectCommandProfileRow, ProjectKnowledgeContextRow, ProjectKnowledgeFactRow, ProjectKnowledgeIndexRow, + ProjectRepositoryFactsRow, ProjectResourceLinkRow, ProjectRow, ProjectRuntimeProfileRow, +}; pub use provider::Provider; pub use remote_agent::RemoteAgentRow; pub use skill::{SkillImportRecordRow, SkillRow}; pub use system_settings::SystemSettings; pub use team::{MailboxMessageRow, TeamRow, TeamTaskRow}; pub use user::User; +pub use workspace_lease::AgentWorkspaceLeaseRow; diff --git a/crates/aionui-db/src/models/project.rs b/crates/aionui-db/src/models/project.rs new file mode 100644 index 000000000..146f12849 --- /dev/null +++ b/crates/aionui-db/src/models/project.rs @@ -0,0 +1,114 @@ +use aionui_common::TimestampMs; +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct ProjectRow { + pub id: String, + pub user_id: String, + pub name: String, + pub local_path: String, + pub repository_url: Option, + pub default_branch: Option, + pub project_type: String, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct ProjectCommandProfileRow { + pub project_id: String, + pub install_command: Option, + pub format_command: Option, + pub lint_command: Option, + pub typecheck_command: Option, + pub unit_test_command: Option, + pub integration_test_command: Option, + pub e2e_command: Option, + pub build_command: Option, + pub security_scan_command: Option, + pub command_timeout_seconds: i64, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct ProjectRuntimeProfileRow { + pub project_id: String, + pub environment_kind: String, + pub language: Option, + pub package_manager: Option, + pub runtime_version: Option, + pub env_keys: String, + pub metadata: String, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct ProjectResourceLinkRow { + pub project_id: String, + pub user_id: String, + pub resource_type: String, + pub resource_id: String, + pub created_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct ProjectRepositoryFactsRow { + pub project_id: String, + pub repository_url: Option, + pub default_branch: Option, + pub baseline_commit: Option, + pub repository_dirty: bool, + pub dirty_worktree_choice: String, + pub dirty_snapshot_ref: Option, + pub credential_reference: Option, + pub detected_languages_json: String, + pub detected_package_managers_json: String, + pub detected_rules_files_json: String, + pub monorepo_packages_json: String, + pub submodules_json: String, + pub lfs_detected: bool, + pub detected_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct ProjectKnowledgeIndexRow { + pub project_id: String, + pub provider: String, + pub provider_project_name: String, + pub provider_version: Option, + pub status: String, + pub generation: i64, + pub source_commit: Option, + pub indexed_at: Option, + pub changed_paths_json: String, + pub error_category: Option, + pub updated_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct ProjectKnowledgeFactRow { + pub id: String, + pub project_id: String, + pub generation: i64, + pub kind: String, + pub name: String, + pub qualified_name: Option, + pub source_path: String, + pub source_line: Option, + pub indexed_at: TimestampMs, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)] +pub struct ProjectKnowledgeContextRow { + pub id: String, + pub project_id: String, + pub provider_project_name: String, + pub generation: i64, + pub query: String, + pub symbols_json: String, + pub callers_json: String, + pub tests_json: String, + pub routes_json: String, + pub data_entities_json: String, + pub created_at: TimestampMs, +} diff --git a/crates/aionui-db/src/models/team.rs b/crates/aionui-db/src/models/team.rs index 4412f30d6..a246850b4 100644 --- a/crates/aionui-db/src/models/team.rs +++ b/crates/aionui-db/src/models/team.rs @@ -16,6 +16,12 @@ pub struct TeamRow { pub lead_agent_id: Option, pub session_mode: Option, pub agents_version: String, + pub source_channel: Option, + pub source_channel_id: Option, + pub source_chat_id: Option, + pub source_user_id: Option, + pub source_label: Option, + pub created_from: Option, pub created_at: TimestampMs, pub updated_at: TimestampMs, } @@ -80,6 +86,12 @@ mod tests { lead_agent_id: None, session_mode: None, agents_version: "1.0.1".into(), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, created_at: 0, updated_at: 0, }; diff --git a/crates/aionui-db/src/models/workspace_lease.rs b/crates/aionui-db/src/models/workspace_lease.rs new file mode 100644 index 000000000..4314b7306 --- /dev/null +++ b/crates/aionui-db/src/models/workspace_lease.rs @@ -0,0 +1,23 @@ +use aionui_common::TimestampMs; +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow, PartialEq, Eq)] +pub struct AgentWorkspaceLeaseRow { + pub id: String, + pub team_id: String, + pub user_id: String, + pub slot_id: String, + pub workspace_mode: String, + pub repository_path: String, + pub worktree_path: String, + pub branch_name: String, + pub base_commit: String, + pub allowed_paths: String, + pub lease_status: String, + pub cleanup_status: String, + pub conflict_files: String, + pub last_error: Option, + pub created_at: TimestampMs, + pub updated_at: TimestampMs, + pub released_at: Option, +} diff --git a/crates/aionui-db/src/repository/approval.rs b/crates/aionui-db/src/repository/approval.rs new file mode 100644 index 000000000..60d8f078f --- /dev/null +++ b/crates/aionui-db/src/repository/approval.rs @@ -0,0 +1,23 @@ +use aionui_common::TimestampMs; + +use crate::error::DbError; +use crate::models::ApprovalRequestRow; + +#[async_trait::async_trait] +pub trait IApprovalRepository: Send + Sync { + async fn create(&self, row: &ApprovalRequestRow) -> Result<(), DbError>; + async fn get(&self, id: &str) -> Result, DbError>; + async fn get_by_conversation_call( + &self, + conversation_id: &str, + call_id: &str, + ) -> Result, DbError>; + async fn list_for_user( + &self, + requester_user_id: &str, + run_id: Option<&str>, + ) -> Result, DbError>; + async fn consume(&self, id: &str, approver_user_id: &str, status: &str, now: TimestampMs) -> Result; + async fn cancel_consumed(&self, id: &str, approver_user_id: &str, now: TimestampMs) -> Result; + async fn mark_expired(&self, now: TimestampMs) -> Result; +} diff --git a/crates/aionui-db/src/repository/channel.rs b/crates/aionui-db/src/repository/channel.rs index 8edb8d19f..185c6bc53 100644 --- a/crates/aionui-db/src/repository/channel.rs +++ b/crates/aionui-db/src/repository/channel.rs @@ -1,7 +1,10 @@ use aionui_common::TimestampMs; use crate::error::DbError; -use crate::models::{AssistantSessionRow, AssistantUserRow, ChannelPluginRow, PairingCodeRow}; +use crate::models::{ + AssistantSessionRow, AssistantUserRow, ChannelPluginRow, ChannelTopicModelOverrideRow, PairingCodeRow, + TelegramTopicBindingRow, +}; /// Data access abstraction for channel integration tables. /// @@ -11,6 +14,34 @@ use crate::models::{AssistantSessionRow, AssistantUserRow, ChannelPluginRow, Pai /// Object-safe via `async_trait` to support `Arc`. #[async_trait::async_trait] pub trait IChannelRepository: Send + Sync { + async fn get_telegram_topic_binding( + &self, + _chat_id: &str, + _message_thread_id: i64, + ) -> Result, DbError> { + Ok(None) + } + async fn upsert_telegram_topic_binding(&self, _row: &TelegramTopicBindingRow) -> Result<(), DbError> { + Err(DbError::NotFound("topic bindings unsupported".into())) + } + async fn delete_telegram_topic_binding(&self, _chat_id: &str, _message_thread_id: i64) -> Result<(), DbError> { + Ok(()) + } + async fn get_topic_model_override( + &self, + _platform: &str, + _internal_user_id: &str, + _chat_id: &str, + _message_thread_id: i64, + ) -> Result, DbError> { + Ok(None) + } + async fn upsert_topic_model_override(&self, _row: &ChannelTopicModelOverrideRow) -> Result<(), DbError> { + Err(DbError::NotFound("topic model overrides unsupported".into())) + } + async fn delete_topic_model_overrides(&self, _chat_id: &str, _message_thread_id: i64) -> Result<(), DbError> { + Ok(()) + } // ── Plugin CRUD ────────────────────────────────────────────────── /// Returns all registered plugins. @@ -67,6 +98,16 @@ pub trait IChannelRepository: Send + Sync { chat_id: &str, new_row: &AssistantSessionRow, ) -> Result; + async fn get_or_create_topic_session( + &self, + user_id: &str, + chat_id: &str, + message_thread_id: i64, + new_row: &AssistantSessionRow, + ) -> Result { + let _ = message_thread_id; + self.get_or_create_session(user_id, chat_id, new_row).await + } /// Updates `last_activity` timestamp for a session. async fn update_session_activity(&self, id: &str, last_activity: TimestampMs) -> Result<(), DbError>; @@ -82,6 +123,13 @@ pub trait IChannelRepository: Send + Sync { /// Deletes the session for a specific user + chat pair. async fn delete_session_by_user_chat(&self, user_id: &str, chat_id: &str) -> Result<(), DbError>; + async fn delete_topic_session(&self, user_id: &str, chat_id: &str, message_thread_id: i64) -> Result<(), DbError> { + let _ = message_thread_id; + self.delete_session_by_user_chat(user_id, chat_id).await + } + async fn delete_sessions_by_topic(&self, _chat_id: &str, _message_thread_id: i64) -> Result<(), DbError> { + Ok(()) + } // ── Pairing Codes ──────────────────────────────────────────────── diff --git a/crates/aionui-db/src/repository/development.rs b/crates/aionui-db/src/repository/development.rs new file mode 100644 index 000000000..5043ddda3 --- /dev/null +++ b/crates/aionui-db/src/repository/development.rs @@ -0,0 +1,136 @@ +use aionui_common::TimestampMs; + +use crate::error::DbError; +use crate::models::{ + AcceptanceCriterionRow, CompletionEvidenceRow, DevelopmentCiCheckRow, DevelopmentDeliveryRow, + DevelopmentDeliveryTagRow, DevelopmentDeploymentRow, DevelopmentRunRoleRow, DevelopmentRunRow, DevelopmentTaskRow, + PlanRevisionRow, QualityGateRunRow, RequirementVersionRow, ReviewFindingRow, SingleRunWorkspaceRow, + TaskArtifactRow, TaskCriterionRow, +}; + +#[async_trait::async_trait] +pub trait IDevelopmentRepository: Send + Sync { + async fn create_run(&self, row: &DevelopmentRunRow) -> Result<(), DbError>; + async fn get_run(&self, run_id: &str, user_id: &str) -> Result, DbError>; + async fn list_runs(&self, user_id: &str, project_id: Option<&str>) -> Result, DbError>; + async fn update_run_status( + &self, + run_id: &str, + user_id: &str, + status: &str, + finished_at: Option, + ) -> Result; + async fn update_run_status_if_current( + &self, + run_id: &str, + user_id: &str, + expected_status: &str, + expected_updated_at: TimestampMs, + status: &str, + finished_at: Option, + ) -> Result; + + async fn assign_role(&self, row: &DevelopmentRunRoleRow) -> Result<(), DbError>; + async fn list_roles(&self, run_id: &str) -> Result, DbError>; + + async fn create_task(&self, row: &DevelopmentTaskRow) -> Result<(), DbError>; + async fn get_task(&self, run_id: &str, task_id: &str) -> Result, DbError>; + async fn list_tasks(&self, run_id: &str) -> Result, DbError>; + async fn update_task_state( + &self, + run_id: &str, + task_id: &str, + status: &str, + review_status: &str, + verification_status: &str, + ) -> Result; + async fn update_task_owner(&self, run_id: &str, task_id: &str, owner: Option<&str>) -> Result; + + async fn create_artifact(&self, row: &TaskArtifactRow) -> Result<(), DbError>; + async fn list_artifacts(&self, run_id: &str, task_id: Option<&str>) -> Result, DbError>; + + async fn create_gate(&self, row: &QualityGateRunRow) -> Result<(), DbError>; + async fn update_gate(&self, row: &QualityGateRunRow) -> Result; + async fn list_gates(&self, run_id: &str, task_id: Option<&str>) -> Result, DbError>; + + async fn create_finding(&self, row: &ReviewFindingRow) -> Result<(), DbError>; + async fn list_findings(&self, run_id: &str, task_id: &str) -> Result, DbError>; + async fn update_finding_status(&self, run_id: &str, finding_id: &str, status: &str) -> Result; + + async fn upsert_delivery(&self, row: &DevelopmentDeliveryRow) -> Result<(), DbError>; + async fn get_delivery(&self, user_id: &str, run_id: &str) -> Result, DbError>; + async fn upsert_ci_check(&self, row: &DevelopmentCiCheckRow) -> Result<(), DbError>; + async fn list_ci_checks(&self, delivery_id: &str) -> Result, DbError>; + async fn create_delivery_tag(&self, row: &DevelopmentDeliveryTagRow) -> Result; + async fn get_delivery_tag( + &self, + user_id: &str, + delivery_id: &str, + name: &str, + ) -> Result, DbError>; + async fn list_delivery_tags( + &self, + user_id: &str, + delivery_id: &str, + ) -> Result, DbError>; + async fn update_delivery_tag_result( + &self, + user_id: &str, + tag_id: &str, + status: &str, + remote_url: Option<&str>, + last_error: Option<&str>, + now: TimestampMs, + ) -> Result; + + async fn create_deployment(&self, row: &DevelopmentDeploymentRow) -> Result; + async fn get_deployment( + &self, + user_id: &str, + deployment_id: &str, + ) -> Result, DbError>; + async fn get_deployment_by_key( + &self, + user_id: &str, + deployment_key: &str, + ) -> Result, DbError>; + async fn list_deployments(&self, user_id: &str, run_id: &str) -> Result, DbError>; + async fn approve_deployment(&self, user_id: &str, deployment_id: &str, now: TimestampMs) -> Result; + async fn claim_deployment(&self, user_id: &str, deployment_id: &str, now: TimestampMs) -> Result; + async fn update_deployment_result( + &self, + user_id: &str, + deployment_id: &str, + status: &str, + remote_id: Option<&str>, + last_error: Option<&str>, + now: TimestampMs, + ) -> Result; + + async fn append_requirement_version( + &self, + row: &RequirementVersionRow, + criteria: &[AcceptanceCriterionRow], + ) -> Result<(), DbError>; + async fn list_requirement_versions(&self, run_id: &str) -> Result, DbError>; + async fn list_active_criteria(&self, run_id: &str) -> Result, DbError>; + async fn append_plan_revision(&self, row: &PlanRevisionRow) -> Result<(), DbError>; + async fn list_plan_revisions(&self, run_id: &str) -> Result, DbError>; + async fn map_task_criteria(&self, rows: &[TaskCriterionRow]) -> Result<(), DbError>; + async fn list_task_criteria(&self, run_id: &str) -> Result, DbError>; + async fn create_completion_evidence(&self, row: &CompletionEvidenceRow) -> Result<(), DbError>; + async fn list_completion_evidence(&self, run_id: &str) -> Result, DbError>; + async fn create_single_run_workspace(&self, row: &SingleRunWorkspaceRow) -> Result<(), DbError>; + async fn get_single_run_workspace( + &self, + run_id: &str, + user_id: &str, + ) -> Result, DbError>; + async fn update_single_run_workspace( + &self, + run_id: &str, + user_id: &str, + candidate_commit: Option<&str>, + cleanup_status: &str, + ) -> Result; +} diff --git a/crates/aionui-db/src/repository/development_operations.rs b/crates/aionui-db/src/repository/development_operations.rs new file mode 100644 index 000000000..f993624dd --- /dev/null +++ b/crates/aionui-db/src/repository/development_operations.rs @@ -0,0 +1,177 @@ +use aionui_common::TimestampMs; + +use crate::error::DbError; +use crate::models::{ + DevelopmentAlertRow, DevelopmentAuditEventRow, DevelopmentModelPriceRow, DevelopmentPolicyRow, + DevelopmentPricedUsageEventRow, DevelopmentRecoveryRecordRow, DevelopmentRunRow, DevelopmentSecretGrantRow, + DevelopmentSecretRow, DevelopmentUsageDimensionSummary, DevelopmentUsageEventRow, DevelopmentUsageSummary, + ExecutionResourceLeaseRow, UsageDimension, +}; + +#[async_trait::async_trait] +pub trait IDevelopmentOperationsRepository: Send + Sync { + async fn get_policy(&self, user_id: &str, project_id: &str) -> Result, DbError>; + async fn upsert_policy(&self, row: &DevelopmentPolicyRow) -> Result<(), DbError>; + + async fn append_usage(&self, row: &DevelopmentUsageEventRow) -> Result<(), DbError>; + async fn list_usage( + &self, + user_id: &str, + project_id: &str, + run_id: Option<&str>, + limit: i64, + ) -> Result, DbError>; + async fn summarize_usage( + &self, + user_id: &str, + project_id: &str, + run_id: Option<&str>, + ) -> Result; + + async fn append_audit(&self, row: &DevelopmentAuditEventRow) -> Result<(), DbError>; + async fn list_audit( + &self, + user_id: &str, + project_id: &str, + run_id: Option<&str>, + limit: i64, + ) -> Result, DbError>; + + async fn upsert_alert(&self, row: &DevelopmentAlertRow) -> Result<(), DbError>; + async fn list_alerts( + &self, + user_id: &str, + project_id: &str, + run_id: Option<&str>, + active_only: bool, + ) -> Result, DbError>; + async fn update_alert_status( + &self, + user_id: &str, + alert_id: &str, + status: &str, + resolved_at: Option, + ) -> Result; + + async fn append_recovery(&self, row: &DevelopmentRecoveryRecordRow) -> Result<(), DbError>; + async fn claim_recovery_and_update_run( + &self, + row: &DevelopmentRecoveryRecordRow, + expected_status: &str, + expected_updated_at: TimestampMs, + target_status: &str, + finished_at: Option, + updated_at: TimestampMs, + ) -> Result; + async fn list_recovery( + &self, + user_id: &str, + project_id: &str, + run_id: Option<&str>, + limit: i64, + ) -> Result, DbError>; + async fn list_recovery_candidates(&self, updated_before: TimestampMs) -> Result, DbError>; + + async fn upsert_resource_lease(&self, row: &ExecutionResourceLeaseRow) -> Result<(), DbError>; + async fn claim_resource_cleanup( + &self, + lease_id: &str, + expected_owner_instance_id: &str, + expected_status: &str, + expected_updated_at: TimestampMs, + cleanup_owner_instance_id: &str, + claimed_at: TimestampMs, + ) -> Result, DbError>; + async fn finish_resource_cleanup( + &self, + lease_id: &str, + cleanup_owner_instance_id: &str, + expected_updated_at: TimestampMs, + succeeded: bool, + cleanup_result: &str, + completed_at: TimestampMs, + ) -> Result; + async fn claim_resource_recovery_decision( + &self, + lease_id: &str, + decision: &str, + takeover_owner_instance_id: Option<&str>, + updated_at: TimestampMs, + ) -> Result, DbError>; + async fn heartbeat_resource_lease( + &self, + lease_id: &str, + owner_instance_id: &str, + expected_updated_at: TimestampMs, + heartbeat_at: TimestampMs, + expires_at: TimestampMs, + ) -> Result, DbError>; + async fn complete_resource_lease( + &self, + lease_id: &str, + owner_instance_id: &str, + expected_updated_at: TimestampMs, + cleanup_result: &str, + completed_at: TimestampMs, + ) -> Result; + async fn orphan_resource_lease( + &self, + lease_id: &str, + owner_instance_id: &str, + expected_expires_at: TimestampMs, + orphaned_at: TimestampMs, + ) -> Result, DbError>; + async fn get_resource_lease(&self, lease_id: &str) -> Result, DbError>; + async fn list_resource_leases( + &self, + user_id: &str, + run_id: &str, + active_only: bool, + ) -> Result, DbError>; + async fn list_stale_resource_leases(&self, now: TimestampMs) -> Result, DbError>; + async fn bind_execution_environment( + &self, + entity_type: &str, + entity_id: &str, + environment_id: &str, + environment_kind: &str, + bound_at: TimestampMs, + ) -> Result<(), DbError>; + + async fn insert_secret(&self, row: &DevelopmentSecretRow) -> Result<(), DbError>; + async fn get_secret(&self, user_id: &str, secret_id: &str) -> Result, DbError>; + async fn list_secrets(&self, user_id: &str, project_id: &str) -> Result, DbError>; + async fn revoke_secret(&self, user_id: &str, secret_id: &str, revoked_at: TimestampMs) -> Result; + async fn upsert_secret_grant(&self, row: &DevelopmentSecretGrantRow) -> Result<(), DbError>; + async fn list_secret_grants( + &self, + user_id: &str, + secret_id: &str, + ) -> Result, DbError>; + + async fn upsert_model_price(&self, row: &DevelopmentModelPriceRow) -> Result<(), DbError>; + async fn resolve_model_price( + &self, + provider: &str, + model: &str, + occurred_at: TimestampMs, + ) -> Result, DbError>; + async fn append_priced_usage(&self, row: &DevelopmentPricedUsageEventRow) -> Result<(), DbError>; + async fn append_priced_usage_once(&self, row: &DevelopmentPricedUsageEventRow) -> Result { + self.append_priced_usage(row).await?; + Ok(true) + } + async fn latest_priced_usage_for_conversation( + &self, + user_id: &str, + conversation_id: &str, + ) -> Result, DbError> { + let _ = (user_id, conversation_id); + Ok(None) + } + async fn summarize_usage_dimension( + &self, + user_id: &str, + dimension: &UsageDimension, + ) -> Result; +} diff --git a/crates/aionui-db/src/repository/mod.rs b/crates/aionui-db/src/repository/mod.rs index 5f77d0c61..0e76c09cb 100644 --- a/crates/aionui-db/src/repository/mod.rs +++ b/crates/aionui-db/src/repository/mod.rs @@ -1,39 +1,50 @@ pub mod acp_session; pub mod agent_metadata; +pub mod approval; pub mod assistant; pub mod channel; mod client_preference; pub mod conversation; pub mod cron; +pub mod development; +pub mod development_operations; pub mod diagnostics; mod diagnostics_sanitizer; pub mod mcp_server; pub mod oauth_token; +pub mod project; pub mod provider; pub mod remote_agent; mod settings; pub mod skill; mod sqlite_acp_session; mod sqlite_agent_metadata; +mod sqlite_approval; mod sqlite_assistant; mod sqlite_channel; mod sqlite_client_preference; mod sqlite_conversation; mod sqlite_cron; +mod sqlite_development; +mod sqlite_development_operations; mod sqlite_diagnostics; mod sqlite_mcp_server; mod sqlite_oauth_token; +mod sqlite_project; mod sqlite_provider; mod sqlite_remote_agent; mod sqlite_settings; mod sqlite_skill; mod sqlite_team; mod sqlite_user; +mod sqlite_workspace_lease; pub mod team; mod user; +pub mod workspace_lease; pub use acp_session::{CreateAcpSessionParams, IAcpSessionRepository, PersistedSessionState, SaveRuntimeStateParams}; pub use agent_metadata::IAgentMetadataRepository; +pub use approval::IApprovalRepository; pub use assistant::{ IAssistantDefinitionRepository, IAssistantOverlayRepository, IAssistantOverrideRepository, IAssistantPreferenceRepository, IAssistantRepository, @@ -42,18 +53,22 @@ pub use channel::IChannelRepository; pub use client_preference::IClientPreferenceRepository; pub use conversation::IConversationRepository; pub use cron::ICronRepository; +pub use development::IDevelopmentRepository; +pub use development_operations::IDevelopmentOperationsRepository; pub use diagnostics::{ FeedbackDiagnosticsDbContext, FeedbackDiagnosticsProfile, FeedbackDiagnosticsProfileResult, FeedbackDiagnosticsRequest, FeedbackDiagnosticsResult, IFeedbackDiagnosticsRepository, }; pub use mcp_server::IMcpServerRepository; pub use oauth_token::IOAuthTokenRepository; +pub use project::IProjectRepository; pub use provider::IProviderRepository; pub use remote_agent::IRemoteAgentRepository; pub use settings::ISettingsRepository; pub use skill::ISkillRepository; pub use sqlite_acp_session::SqliteAcpSessionRepository; pub use sqlite_agent_metadata::SqliteAgentMetadataRepository; +pub use sqlite_approval::SqliteApprovalRepository; pub use sqlite_assistant::{ SqliteAssistantDefinitionRepository, SqliteAssistantOverlayRepository, SqliteAssistantOverrideRepository, SqliteAssistantPreferenceRepository, SqliteAssistantRepository, @@ -62,14 +77,19 @@ pub use sqlite_channel::SqliteChannelRepository; pub use sqlite_client_preference::SqliteClientPreferenceRepository; pub use sqlite_conversation::SqliteConversationRepository; pub use sqlite_cron::SqliteCronRepository; +pub use sqlite_development::SqliteDevelopmentRepository; +pub use sqlite_development_operations::SqliteDevelopmentOperationsRepository; pub use sqlite_diagnostics::SqliteFeedbackDiagnosticsRepository; pub use sqlite_mcp_server::SqliteMcpServerRepository; pub use sqlite_oauth_token::SqliteOAuthTokenRepository; +pub use sqlite_project::SqliteProjectRepository; pub use sqlite_provider::SqliteProviderRepository; pub use sqlite_remote_agent::SqliteRemoteAgentRepository; pub use sqlite_settings::SqliteSettingsRepository; pub use sqlite_skill::SqliteSkillRepository; pub use sqlite_team::SqliteTeamRepository; pub use sqlite_user::SqliteUserRepository; +pub use sqlite_workspace_lease::SqliteAgentWorkspaceLeaseRepository; pub use team::ITeamRepository; pub use user::IUserRepository; +pub use workspace_lease::{AgentWorkspaceLeaseUpdate, IAgentWorkspaceLeaseRepository}; diff --git a/crates/aionui-db/src/repository/project.rs b/crates/aionui-db/src/repository/project.rs new file mode 100644 index 000000000..6d0bc81ea --- /dev/null +++ b/crates/aionui-db/src/repository/project.rs @@ -0,0 +1,89 @@ +use crate::error::DbError; +use crate::models::{ + ProjectCommandProfileRow, ProjectKnowledgeContextRow, ProjectKnowledgeFactRow, ProjectKnowledgeIndexRow, + ProjectRepositoryFactsRow, ProjectResourceLinkRow, ProjectRow, ProjectRuntimeProfileRow, +}; + +#[derive(Debug, Clone, Default)] +pub struct UpdateProjectParams { + pub name: Option, + pub local_path: Option, + pub repository_url: Option>, + pub default_branch: Option>, + pub project_type: Option, +} + +#[async_trait::async_trait] +pub trait IProjectRepository: Send + Sync { + async fn create(&self, row: &ProjectRow) -> Result<(), DbError>; + async fn list_for_user(&self, user_id: &str) -> Result, DbError>; + async fn get_for_user(&self, project_id: &str, user_id: &str) -> Result, DbError>; + async fn update_for_user( + &self, + project_id: &str, + user_id: &str, + params: &UpdateProjectParams, + ) -> Result; + async fn delete_for_user(&self, project_id: &str, user_id: &str) -> Result; + + async fn upsert_command_profile(&self, row: &ProjectCommandProfileRow) -> Result<(), DbError>; + async fn get_command_profile( + &self, + project_id: &str, + user_id: &str, + ) -> Result, DbError>; + async fn upsert_runtime_profile(&self, row: &ProjectRuntimeProfileRow) -> Result<(), DbError>; + async fn get_runtime_profile( + &self, + project_id: &str, + user_id: &str, + ) -> Result, DbError>; + async fn upsert_repository_facts(&self, row: &ProjectRepositoryFactsRow) -> Result<(), DbError>; + async fn get_repository_facts( + &self, + project_id: &str, + user_id: &str, + ) -> Result, DbError>; + async fn upsert_knowledge_index(&self, row: &ProjectKnowledgeIndexRow) -> Result<(), DbError>; + async fn commit_knowledge_generation( + &self, + index: &ProjectKnowledgeIndexRow, + facts: &[ProjectKnowledgeFactRow], + ) -> Result<(), DbError>; + async fn get_knowledge_index( + &self, + project_id: &str, + user_id: &str, + ) -> Result, DbError>; + async fn list_knowledge_facts( + &self, + project_id: &str, + user_id: &str, + ) -> Result, DbError>; + async fn insert_knowledge_context(&self, row: &ProjectKnowledgeContextRow) -> Result<(), DbError>; + async fn get_knowledge_context( + &self, + context_id: &str, + user_id: &str, + ) -> Result, DbError>; + + async fn bind_resource( + &self, + project_id: &str, + user_id: &str, + resource_type: &str, + resource_id: &str, + ) -> Result; + async fn resource_is_owned(&self, user_id: &str, resource_type: &str, resource_id: &str) -> Result; + async fn get_for_resource( + &self, + user_id: &str, + resource_type: &str, + resource_id: &str, + ) -> Result, DbError>; + async fn list_resource_links( + &self, + project_id: &str, + user_id: &str, + ) -> Result, DbError>; +} diff --git a/crates/aionui-db/src/repository/sqlite_agent_metadata.rs b/crates/aionui-db/src/repository/sqlite_agent_metadata.rs index e3eb7bf03..ace971baa 100644 --- a/crates/aionui-db/src/repository/sqlite_agent_metadata.rs +++ b/crates/aionui-db/src/repository/sqlite_agent_metadata.rs @@ -29,6 +29,7 @@ const AGENT_METADATA_SAFE_COLUMNS: &str = "\ sort_order, \ last_check_status, last_check_kind, last_check_error_code, last_check_error_message, \ last_check_guidance, last_check_latency_ms, last_check_at, last_success_at, last_failure_at, \ + dynamic_probe_result, \ command_override, env_override, created_at, updated_at"; #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -89,6 +90,7 @@ struct AgentMetadataSafeRow { last_check_at: Option, last_success_at: Option, last_failure_at: Option, + dynamic_probe_result: Option, command_override: Option, env_override: Option, created_at: aionui_common::TimestampMs, @@ -131,6 +133,7 @@ impl AgentMetadataSafeRow { last_check_at: row.try_get("last_check_at")?, last_success_at: row.try_get("last_success_at")?, last_failure_at: row.try_get("last_failure_at")?, + dynamic_probe_result: row.try_get("dynamic_probe_result")?, command_override: row.try_get("command_override")?, env_override: row.try_get("env_override")?, created_at: row.try_get("created_at")?, @@ -206,6 +209,7 @@ impl AgentMetadataSafeRow { last_check_at: self.last_check_at, last_success_at: self.last_success_at, last_failure_at: self.last_failure_at, + dynamic_probe_result: self.dynamic_probe_result, command_override: self.command_override, env_override: self.env_override, created_at: self.created_at, @@ -498,6 +502,7 @@ impl IAgentMetadataRepository for SqliteAgentMetadataRepository { last_check_at = ?, \ last_success_at = ?, \ last_failure_at = ?, \ + dynamic_probe_result = ?, \ updated_at = ? \ WHERE id = ?", ) @@ -510,6 +515,7 @@ impl IAgentMetadataRepository for SqliteAgentMetadataRepository { .bind(params.last_check_at) .bind(params.last_success_at) .bind(params.last_failure_at) + .bind(params.dynamic_probe_result) .bind(now) .bind(id) .execute(&self.pool) @@ -978,6 +984,9 @@ mod tests { last_check_at: Some(1_750_000_000_000), last_success_at: Some(1_750_000_000_000), last_failure_at: None, + dynamic_probe_result: Some( + r#"{"agent_id":"agent-claude","checked_at":1750000000000,"steps":[],"available_models":["sonnet"]}"#, + ), }, ) .await @@ -988,6 +997,10 @@ mod tests { assert_eq!(refreshed.last_check_kind.as_deref(), Some("manual")); assert_eq!(refreshed.last_check_latency_ms, Some(180)); assert_eq!(refreshed.last_success_at, Some(1_750_000_000_000)); + assert_eq!( + refreshed.dynamic_probe_result.as_deref(), + Some(r#"{"agent_id":"agent-claude","checked_at":1750000000000,"steps":[],"available_models":["sonnet"]}"#) + ); } #[tokio::test] diff --git a/crates/aionui-db/src/repository/sqlite_approval.rs b/crates/aionui-db/src/repository/sqlite_approval.rs new file mode 100644 index 000000000..6e89a8caf --- /dev/null +++ b/crates/aionui-db/src/repository/sqlite_approval.rs @@ -0,0 +1,146 @@ +use aionui_common::TimestampMs; +use sqlx::SqlitePool; + +use crate::error::DbError; +use crate::models::ApprovalRequestRow; +use crate::repository::approval::IApprovalRepository; + +#[derive(Clone, Debug)] +pub struct SqliteApprovalRepository { + pool: SqlitePool, +} + +impl SqliteApprovalRepository { + pub fn new(pool: SqlitePool) -> Self { + Self { pool } + } +} + +#[async_trait::async_trait] +impl IApprovalRepository for SqliteApprovalRepository { + async fn create(&self, row: &ApprovalRequestRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO approval_requests (id, requester_user_id, project_id, run_id, task_id, conversation_id, \ + agent_id, call_id, action_type, command, working_directory, risk_level, options, status, \ + approver_user_id, source_channel, source_user_id, source_chat_id, source_thread_id, expires_at, consumed_at, \ + created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.requester_user_id) + .bind(&row.project_id) + .bind(&row.run_id) + .bind(&row.task_id) + .bind(&row.conversation_id) + .bind(&row.agent_id) + .bind(&row.call_id) + .bind(&row.action_type) + .bind(&row.command) + .bind(&row.working_directory) + .bind(&row.risk_level) + .bind(&row.options) + .bind(&row.status) + .bind(&row.approver_user_id) + .bind(&row.source_channel) + .bind(&row.source_user_id) + .bind(&row.source_chat_id) + .bind(row.source_thread_id) + .bind(row.expires_at) + .bind(row.consumed_at) + .bind(row.created_at) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn get(&self, id: &str) -> Result, DbError> { + Ok(sqlx::query_as("SELECT * FROM approval_requests WHERE id = ?") + .bind(id) + .fetch_optional(&self.pool) + .await?) + } + + async fn get_by_conversation_call( + &self, + conversation_id: &str, + call_id: &str, + ) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM approval_requests WHERE conversation_id = ? AND call_id = ?") + .bind(conversation_id) + .bind(call_id) + .fetch_optional(&self.pool) + .await?, + ) + } + + async fn list_for_user( + &self, + requester_user_id: &str, + run_id: Option<&str>, + ) -> Result, DbError> { + let rows = match run_id { + Some(run_id) => { + sqlx::query_as( + "SELECT * FROM approval_requests WHERE requester_user_id = ? AND run_id = ? \ + ORDER BY created_at DESC, id ASC", + ) + .bind(requester_user_id) + .bind(run_id) + .fetch_all(&self.pool) + .await? + } + None => { + sqlx::query_as( + "SELECT * FROM approval_requests WHERE requester_user_id = ? ORDER BY created_at DESC, id ASC", + ) + .bind(requester_user_id) + .fetch_all(&self.pool) + .await? + } + }; + Ok(rows) + } + + async fn consume(&self, id: &str, approver_user_id: &str, status: &str, now: TimestampMs) -> Result { + let result = sqlx::query( + "UPDATE approval_requests SET status = ?, approver_user_id = ?, consumed_at = ?, updated_at = ? \ + WHERE id = ? AND requester_user_id = ? AND status = 'pending' AND expires_at > ?", + ) + .bind(status) + .bind(approver_user_id) + .bind(now) + .bind(now) + .bind(id) + .bind(approver_user_id) + .bind(now) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() == 1) + } + + async fn cancel_consumed(&self, id: &str, approver_user_id: &str, now: TimestampMs) -> Result { + let result = sqlx::query( + "UPDATE approval_requests SET status = 'cancelled', updated_at = ? \ + WHERE id = ? AND approver_user_id = ? AND status IN ('approved', 'rejected')", + ) + .bind(now) + .bind(id) + .bind(approver_user_id) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() == 1) + } + + async fn mark_expired(&self, now: TimestampMs) -> Result { + Ok(sqlx::query( + "UPDATE approval_requests SET status = 'expired', updated_at = ? \ + WHERE status = 'pending' AND expires_at <= ?", + ) + .bind(now) + .bind(now) + .execute(&self.pool) + .await? + .rows_affected()) + } +} diff --git a/crates/aionui-db/src/repository/sqlite_channel.rs b/crates/aionui-db/src/repository/sqlite_channel.rs index 1052df95e..cdbc3468d 100644 --- a/crates/aionui-db/src/repository/sqlite_channel.rs +++ b/crates/aionui-db/src/repository/sqlite_channel.rs @@ -1,7 +1,10 @@ use sqlx::SqlitePool; use crate::error::DbError; -use crate::models::{AssistantSessionRow, AssistantUserRow, ChannelPluginRow, PairingCodeRow}; +use crate::models::{ + AssistantSessionRow, AssistantUserRow, ChannelPluginRow, ChannelTopicModelOverrideRow, PairingCodeRow, + TelegramTopicBindingRow, +}; use crate::repository::channel::{IChannelRepository, UpdatePluginStatusParams}; /// SQLite-backed implementation of [`IChannelRepository`]. @@ -18,6 +21,54 @@ impl SqliteChannelRepository { #[async_trait::async_trait] impl IChannelRepository for SqliteChannelRepository { + async fn get_telegram_topic_binding( + &self, + chat_id: &str, + message_thread_id: i64, + ) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM telegram_topic_bindings WHERE chat_id = ? AND message_thread_id = ?") + .bind(chat_id) + .bind(message_thread_id) + .fetch_optional(&self.pool) + .await?, + ) + } + async fn upsert_telegram_topic_binding(&self, row: &TelegramTopicBindingRow) -> Result<(), DbError> { + sqlx::query("INSERT INTO telegram_topic_bindings (chat_id,message_thread_id,agent_id,bound_by_user_id,created_at,updated_at) VALUES (?,?,?,?,?,?) ON CONFLICT(chat_id,message_thread_id) DO UPDATE SET agent_id=excluded.agent_id,bound_by_user_id=excluded.bound_by_user_id,updated_at=excluded.updated_at") + .bind(&row.chat_id).bind(row.message_thread_id).bind(&row.agent_id).bind(&row.bound_by_user_id).bind(row.created_at).bind(row.updated_at).execute(&self.pool).await?; + Ok(()) + } + async fn delete_telegram_topic_binding(&self, chat_id: &str, message_thread_id: i64) -> Result<(), DbError> { + sqlx::query("DELETE FROM telegram_topic_bindings WHERE chat_id = ? AND message_thread_id = ?") + .bind(chat_id) + .bind(message_thread_id) + .execute(&self.pool) + .await?; + Ok(()) + } + async fn get_topic_model_override( + &self, + platform: &str, + internal_user_id: &str, + chat_id: &str, + message_thread_id: i64, + ) -> Result, DbError> { + Ok(sqlx::query_as("SELECT * FROM channel_topic_model_overrides WHERE platform=? AND internal_user_id=? AND chat_id=? AND message_thread_id=?").bind(platform).bind(internal_user_id).bind(chat_id).bind(message_thread_id).fetch_optional(&self.pool).await?) + } + async fn upsert_topic_model_override(&self, row: &ChannelTopicModelOverrideRow) -> Result<(), DbError> { + sqlx::query("INSERT INTO channel_topic_model_overrides (platform,internal_user_id,chat_id,message_thread_id,agent_id,provider_id,model,updated_at) VALUES (?,?,?,?,?,?,?,?) ON CONFLICT(platform,internal_user_id,chat_id,message_thread_id) DO UPDATE SET agent_id=excluded.agent_id,provider_id=excluded.provider_id,model=excluded.model,updated_at=excluded.updated_at") + .bind(&row.platform).bind(&row.internal_user_id).bind(&row.chat_id).bind(row.message_thread_id).bind(&row.agent_id).bind(&row.provider_id).bind(&row.model).bind(row.updated_at).execute(&self.pool).await?; + Ok(()) + } + async fn delete_topic_model_overrides(&self, chat_id: &str, message_thread_id: i64) -> Result<(), DbError> { + sqlx::query("DELETE FROM channel_topic_model_overrides WHERE chat_id=? AND message_thread_id=?") + .bind(chat_id) + .bind(message_thread_id) + .execute(&self.pool) + .await?; + Ok(()) + } // ── Plugin CRUD ────────────────────────────────────────────────── async fn get_all_plugins(&self) -> Result, DbError> { @@ -262,6 +313,31 @@ impl IChannelRepository for SqliteChannelRepository { Ok(new_row.clone()) } + async fn get_or_create_topic_session( + &self, + user_id: &str, + chat_id: &str, + message_thread_id: i64, + new_row: &AssistantSessionRow, + ) -> Result { + if let Some(row) = sqlx::query_as::<_, AssistantSessionRow>( + "SELECT * FROM assistant_sessions WHERE user_id=? AND chat_id=? AND message_thread_id=?", + ) + .bind(user_id) + .bind(chat_id) + .bind(message_thread_id) + .fetch_optional(&self.pool) + .await? + { + return Ok(row); + } + sqlx::query("INSERT INTO assistant_sessions (id,user_id,agent_type,conversation_id,workspace,chat_id,message_thread_id,bound_agent_id,bound_backend,bound_provider_id,bound_model,created_at,last_activity) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)") + .bind(&new_row.id).bind(&new_row.user_id).bind(&new_row.agent_type).bind(&new_row.conversation_id) + .bind(&new_row.workspace).bind(&new_row.chat_id).bind(message_thread_id).bind(&new_row.bound_agent_id).bind(&new_row.bound_backend).bind(&new_row.bound_provider_id).bind(&new_row.bound_model).bind(new_row.created_at).bind(new_row.last_activity) + .execute(&self.pool).await?; + Ok(new_row.clone()) + } + async fn update_session_activity( &self, id: &str, @@ -334,6 +410,25 @@ impl IChannelRepository for SqliteChannelRepository { Ok(()) } + async fn delete_topic_session(&self, user_id: &str, chat_id: &str, message_thread_id: i64) -> Result<(), DbError> { + sqlx::query("DELETE FROM assistant_sessions WHERE user_id=? AND chat_id=? AND message_thread_id=?") + .bind(user_id) + .bind(chat_id) + .bind(message_thread_id) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn delete_sessions_by_topic(&self, chat_id: &str, message_thread_id: i64) -> Result<(), DbError> { + sqlx::query("DELETE FROM assistant_sessions WHERE chat_id=? AND message_thread_id=?") + .bind(chat_id) + .bind(message_thread_id) + .execute(&self.pool) + .await?; + Ok(()) + } + // ── Pairing Codes ──────────────────────────────────────────────── async fn create_pairing(&self, row: &PairingCodeRow) -> Result<(), DbError> { @@ -462,6 +557,11 @@ mod tests { conversation_id: None, workspace: None, chat_id: Some("chat-abc".into()), + message_thread_id: None, + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, created_at: now, last_activity: now, } diff --git a/crates/aionui-db/src/repository/sqlite_conversation.rs b/crates/aionui-db/src/repository/sqlite_conversation.rs index c27aae2a0..da11f361d 100644 --- a/crates/aionui-db/src/repository/sqlite_conversation.rs +++ b/crates/aionui-db/src/repository/sqlite_conversation.rs @@ -170,8 +170,9 @@ impl IConversationRepository for SqliteConversationRepository { sqlx::query( "INSERT INTO conversations \ (id, user_id, name, type, extra, model, status, source, \ - channel_chat_id, pinned, pinned_at, created_at, updated_at) \ - VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + channel_chat_id, source_channel, source_channel_id, source_chat_id, \ + source_user_id, source_label, created_from, pinned, pinned_at, created_at, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", ) .bind(&row.id) .bind(&row.user_id) @@ -182,6 +183,12 @@ impl IConversationRepository for SqliteConversationRepository { .bind(&row.status) .bind(&row.source) .bind(&row.channel_chat_id) + .bind(&row.source_channel) + .bind(&row.source_channel_id) + .bind(&row.source_chat_id) + .bind(&row.source_user_id) + .bind(&row.source_label) + .bind(&row.created_from) .bind(row.pinned) .bind(row.pinned_at) .bind(row.created_at) @@ -1046,6 +1053,12 @@ mod tests { status: Some("pending".to_string()), source: Some("aionui".to_string()), channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: now, diff --git a/crates/aionui-db/src/repository/sqlite_development.rs b/crates/aionui-db/src/repository/sqlite_development.rs new file mode 100644 index 000000000..9af613866 --- /dev/null +++ b/crates/aionui-db/src/repository/sqlite_development.rs @@ -0,0 +1,875 @@ +use aionui_common::{TimestampMs, now_ms}; +use sqlx::SqlitePool; + +use crate::error::DbError; +use crate::models::{ + AcceptanceCriterionRow, CompletionEvidenceRow, DevelopmentCiCheckRow, DevelopmentDeliveryRow, + DevelopmentDeliveryTagRow, DevelopmentDeploymentRow, DevelopmentRunRoleRow, DevelopmentRunRow, DevelopmentTaskRow, + PlanRevisionRow, QualityGateRunRow, RequirementVersionRow, ReviewFindingRow, SingleRunWorkspaceRow, + TaskArtifactRow, TaskCriterionRow, +}; +use crate::repository::development::IDevelopmentRepository; + +#[derive(Clone, Debug)] +pub struct SqliteDevelopmentRepository { + pool: SqlitePool, +} + +impl SqliteDevelopmentRepository { + pub fn new(pool: SqlitePool) -> Self { + Self { pool } + } +} + +#[async_trait::async_trait] +impl IDevelopmentRepository for SqliteDevelopmentRepository { + async fn create_run(&self, row: &DevelopmentRunRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_runs (id, user_id, project_id, team_id, source_channel, source_user_id, \ + execution_mode, status, request_summary, acceptance_criteria, baseline_commit, integration_branch, \ + started_at, finished_at, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.team_id) + .bind(&row.source_channel) + .bind(&row.source_user_id) + .bind(&row.execution_mode) + .bind(&row.status) + .bind(&row.request_summary) + .bind(&row.acceptance_criteria) + .bind(&row.baseline_commit) + .bind(&row.integration_branch) + .bind(row.started_at) + .bind(row.finished_at) + .bind(row.created_at) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn get_run(&self, run_id: &str, user_id: &str) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM development_runs WHERE id = ? AND user_id = ?") + .bind(run_id) + .bind(user_id) + .fetch_optional(&self.pool) + .await?, + ) + } + + async fn list_runs(&self, user_id: &str, project_id: Option<&str>) -> Result, DbError> { + let rows = match project_id { + Some(project_id) => sqlx::query_as( + "SELECT * FROM development_runs WHERE user_id = ? AND project_id = ? ORDER BY updated_at DESC, id ASC", + ) + .bind(user_id) + .bind(project_id) + .fetch_all(&self.pool) + .await?, + None => { + sqlx::query_as("SELECT * FROM development_runs WHERE user_id = ? ORDER BY updated_at DESC, id ASC") + .bind(user_id) + .fetch_all(&self.pool) + .await? + } + }; + Ok(rows) + } + + async fn update_run_status( + &self, + run_id: &str, + user_id: &str, + status: &str, + finished_at: Option, + ) -> Result { + let result = sqlx::query( + "UPDATE development_runs SET status = ?, finished_at = ?, updated_at = ? WHERE id = ? AND user_id = ?", + ) + .bind(status) + .bind(finished_at) + .bind(now_ms()) + .bind(run_id) + .bind(user_id) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() > 0) + } + + async fn update_run_status_if_current( + &self, + run_id: &str, + user_id: &str, + expected_status: &str, + expected_updated_at: TimestampMs, + status: &str, + finished_at: Option, + ) -> Result { + let result = sqlx::query( + "UPDATE development_runs SET status = ?, finished_at = ?, updated_at = MAX(?, updated_at + 1) \ + WHERE id = ? AND user_id = ? AND status = ? AND updated_at = ?", + ) + .bind(status) + .bind(finished_at) + .bind(now_ms()) + .bind(run_id) + .bind(user_id) + .bind(expected_status) + .bind(expected_updated_at) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() == 1) + } + + async fn assign_role(&self, row: &DevelopmentRunRoleRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_run_roles (run_id, slot_id, role, assigned_at) VALUES (?, ?, ?, ?) \ + ON CONFLICT(run_id, slot_id, role) DO NOTHING", + ) + .bind(&row.run_id) + .bind(&row.slot_id) + .bind(&row.role) + .bind(row.assigned_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn list_roles(&self, run_id: &str) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM development_run_roles WHERE run_id = ? ORDER BY role ASC, slot_id ASC") + .bind(run_id) + .fetch_all(&self.pool) + .await?, + ) + } + + async fn create_task(&self, row: &DevelopmentTaskRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO team_tasks (id, team_id, run_id, subject, description, status, owner, blocked_by, blocks, \ + metadata, acceptance_criteria, task_type, risk_level, assigned_workspace_lease_id, review_status, \ + verification_status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.team_id) + .bind(&row.run_id) + .bind(&row.subject) + .bind(&row.description) + .bind(&row.status) + .bind(&row.owner) + .bind(&row.blocked_by) + .bind(&row.blocks) + .bind(&row.metadata) + .bind(&row.acceptance_criteria) + .bind(&row.task_type) + .bind(&row.risk_level) + .bind(&row.assigned_workspace_lease_id) + .bind(&row.review_status) + .bind(&row.verification_status) + .bind(row.created_at) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn get_task(&self, run_id: &str, task_id: &str) -> Result, DbError> { + Ok(sqlx::query_as("SELECT * FROM team_tasks WHERE run_id = ? AND id = ?") + .bind(run_id) + .bind(task_id) + .fetch_optional(&self.pool) + .await?) + } + + async fn list_tasks(&self, run_id: &str) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM team_tasks WHERE run_id = ? ORDER BY created_at ASC, id ASC") + .bind(run_id) + .fetch_all(&self.pool) + .await?, + ) + } + + async fn update_task_state( + &self, + run_id: &str, + task_id: &str, + status: &str, + review_status: &str, + verification_status: &str, + ) -> Result { + let result = sqlx::query( + "UPDATE team_tasks SET status = ?, review_status = ?, verification_status = ?, updated_at = ? \ + WHERE run_id = ? AND id = ?", + ) + .bind(status) + .bind(review_status) + .bind(verification_status) + .bind(now_ms()) + .bind(run_id) + .bind(task_id) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() > 0) + } + + async fn update_task_owner(&self, run_id: &str, task_id: &str, owner: Option<&str>) -> Result { + let result = sqlx::query("UPDATE team_tasks SET owner = ?, updated_at = ? WHERE run_id = ? AND id = ?") + .bind(owner) + .bind(now_ms()) + .bind(run_id) + .bind(task_id) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() > 0) + } + + async fn create_artifact(&self, row: &TaskArtifactRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO task_artifacts (id, run_id, task_id, artifact_type, path_or_uri, checksum, \ + producer_agent_id, metadata, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.run_id) + .bind(&row.task_id) + .bind(&row.artifact_type) + .bind(&row.path_or_uri) + .bind(&row.checksum) + .bind(&row.producer_agent_id) + .bind(&row.metadata) + .bind(row.created_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn list_artifacts(&self, run_id: &str, task_id: Option<&str>) -> Result, DbError> { + let rows = match task_id { + Some(task_id) => { + sqlx::query_as( + "SELECT * FROM task_artifacts WHERE run_id = ? AND task_id = ? ORDER BY created_at ASC, id ASC", + ) + .bind(run_id) + .bind(task_id) + .fetch_all(&self.pool) + .await? + } + None => { + sqlx::query_as("SELECT * FROM task_artifacts WHERE run_id = ? ORDER BY created_at ASC, id ASC") + .bind(run_id) + .fetch_all(&self.pool) + .await? + } + }; + Ok(rows) + } + + async fn create_gate(&self, row: &QualityGateRunRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO quality_gate_runs (id, run_id, task_id, gate_type, command, working_directory, exit_code, \ + status, stdout_artifact_id, stderr_artifact_id, duration_ms, isolation_mode, execution_id, required, \ + started_at, finished_at, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.run_id) + .bind(&row.task_id) + .bind(&row.gate_type) + .bind(&row.command) + .bind(&row.working_directory) + .bind(row.exit_code) + .bind(&row.status) + .bind(&row.stdout_artifact_id) + .bind(&row.stderr_artifact_id) + .bind(row.duration_ms) + .bind(&row.isolation_mode) + .bind(&row.execution_id) + .bind(row.required) + .bind(row.started_at) + .bind(row.finished_at) + .bind(row.created_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn update_gate(&self, row: &QualityGateRunRow) -> Result { + let result = sqlx::query( + "UPDATE quality_gate_runs SET exit_code = ?, status = ?, stdout_artifact_id = ?, stderr_artifact_id = ?, \ + duration_ms = ?, isolation_mode = ?, execution_id = ?, required = ?, started_at = ?, finished_at = ? \ + WHERE id = ? AND run_id = ?", + ) + .bind(row.exit_code) + .bind(&row.status) + .bind(&row.stdout_artifact_id) + .bind(&row.stderr_artifact_id) + .bind(row.duration_ms) + .bind(&row.isolation_mode) + .bind(&row.execution_id) + .bind(row.required) + .bind(row.started_at) + .bind(row.finished_at) + .bind(&row.id) + .bind(&row.run_id) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() > 0) + } + + async fn list_gates(&self, run_id: &str, task_id: Option<&str>) -> Result, DbError> { + let rows = + match task_id { + Some(task_id) => sqlx::query_as( + "SELECT * FROM quality_gate_runs WHERE run_id = ? AND task_id = ? ORDER BY created_at ASC, id ASC", + ) + .bind(run_id) + .bind(task_id) + .fetch_all(&self.pool) + .await?, + None => { + sqlx::query_as("SELECT * FROM quality_gate_runs WHERE run_id = ? ORDER BY created_at ASC, id ASC") + .bind(run_id) + .fetch_all(&self.pool) + .await? + } + }; + Ok(rows) + } + + async fn create_finding(&self, row: &ReviewFindingRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO review_findings (id, run_id, task_id, reviewer_agent_id, producer_agent_id, severity, \ + file_path, line_number, reason, suggestion, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ).bind(&row.id).bind(&row.run_id).bind(&row.task_id).bind(&row.reviewer_agent_id) + .bind(&row.producer_agent_id).bind(&row.severity).bind(&row.file_path).bind(row.line_number) + .bind(&row.reason).bind(&row.suggestion).bind(&row.status).bind(row.created_at) + .bind(row.updated_at).execute(&self.pool).await?; + Ok(()) + } + + async fn list_findings(&self, run_id: &str, task_id: &str) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT * FROM review_findings WHERE run_id = ? AND task_id = ? ORDER BY created_at ASC, id ASC", + ) + .bind(run_id) + .bind(task_id) + .fetch_all(&self.pool) + .await?) + } + + async fn update_finding_status(&self, run_id: &str, finding_id: &str, status: &str) -> Result { + let result = sqlx::query("UPDATE review_findings SET status = ?, updated_at = ? WHERE id = ? AND run_id = ?") + .bind(status) + .bind(now_ms()) + .bind(finding_id) + .bind(run_id) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() > 0) + } + + async fn upsert_delivery(&self, row: &DevelopmentDeliveryRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_deliveries (id, run_id, project_id, user_id, provider, repository, branch, \ + base_branch, commit_sha, status, push_status, pr_number, pr_url, pr_status, ci_status, review_status, \ + merge_status, report_json, last_error, created_at, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(run_id) DO UPDATE SET provider=excluded.provider, repository=excluded.repository, \ + branch=excluded.branch, base_branch=excluded.base_branch, commit_sha=excluded.commit_sha, \ + status=excluded.status, push_status=excluded.push_status, pr_number=excluded.pr_number, \ + pr_url=excluded.pr_url, pr_status=excluded.pr_status, ci_status=excluded.ci_status, \ + review_status=excluded.review_status, merge_status=excluded.merge_status, \ + report_json=excluded.report_json, last_error=excluded.last_error, updated_at=excluded.updated_at", + ) + .bind(&row.id) + .bind(&row.run_id) + .bind(&row.project_id) + .bind(&row.user_id) + .bind(&row.provider) + .bind(&row.repository) + .bind(&row.branch) + .bind(&row.base_branch) + .bind(&row.commit_sha) + .bind(&row.status) + .bind(&row.push_status) + .bind(row.pr_number) + .bind(&row.pr_url) + .bind(&row.pr_status) + .bind(&row.ci_status) + .bind(&row.review_status) + .bind(&row.merge_status) + .bind(&row.report_json) + .bind(&row.last_error) + .bind(row.created_at) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn get_delivery(&self, user_id: &str, run_id: &str) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM development_deliveries WHERE user_id = ? AND run_id = ?") + .bind(user_id) + .bind(run_id) + .fetch_optional(&self.pool) + .await?, + ) + } + + async fn upsert_ci_check(&self, row: &DevelopmentCiCheckRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_ci_checks (id, delivery_id, provider_check_id, name, status, details_url, \ + summary, rework_task_id, started_at, completed_at, created_at, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(delivery_id, provider_check_id) DO UPDATE SET name=excluded.name, status=excluded.status, \ + details_url=excluded.details_url, summary=excluded.summary, \ + rework_task_id=COALESCE(excluded.rework_task_id, development_ci_checks.rework_task_id), \ + started_at=excluded.started_at, completed_at=excluded.completed_at, updated_at=excluded.updated_at", + ) + .bind(&row.id) + .bind(&row.delivery_id) + .bind(&row.provider_check_id) + .bind(&row.name) + .bind(&row.status) + .bind(&row.details_url) + .bind(&row.summary) + .bind(&row.rework_task_id) + .bind(row.started_at) + .bind(row.completed_at) + .bind(row.created_at) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn list_ci_checks(&self, delivery_id: &str) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT * FROM development_ci_checks WHERE delivery_id = ? ORDER BY name ASC, provider_check_id ASC", + ) + .bind(delivery_id) + .fetch_all(&self.pool) + .await?) + } + + async fn create_delivery_tag(&self, row: &DevelopmentDeliveryTagRow) -> Result { + let result = sqlx::query( + "INSERT INTO development_delivery_tags \ + (id, delivery_id, user_id, name, commit_sha, remote_url, status, last_error, created_at, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(delivery_id, name) DO NOTHING", + ) + .bind(&row.id) + .bind(&row.delivery_id) + .bind(&row.user_id) + .bind(&row.name) + .bind(&row.commit_sha) + .bind(&row.remote_url) + .bind(&row.status) + .bind(&row.last_error) + .bind(row.created_at) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() == 1) + } + + async fn get_delivery_tag( + &self, + user_id: &str, + delivery_id: &str, + name: &str, + ) -> Result, DbError> { + Ok( + sqlx::query_as( + "SELECT * FROM development_delivery_tags WHERE user_id = ? AND delivery_id = ? AND name = ?", + ) + .bind(user_id) + .bind(delivery_id) + .bind(name) + .fetch_optional(&self.pool) + .await?, + ) + } + + async fn list_delivery_tags( + &self, + user_id: &str, + delivery_id: &str, + ) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT * FROM development_delivery_tags WHERE user_id = ? AND delivery_id = ? ORDER BY created_at DESC", + ) + .bind(user_id) + .bind(delivery_id) + .fetch_all(&self.pool) + .await?) + } + + async fn update_delivery_tag_result( + &self, + user_id: &str, + tag_id: &str, + status: &str, + remote_url: Option<&str>, + last_error: Option<&str>, + now: TimestampMs, + ) -> Result { + let result = sqlx::query( + "UPDATE development_delivery_tags SET status = ?, remote_url = COALESCE(?, remote_url), \ + last_error = ?, updated_at = ? WHERE id = ? AND user_id = ?", + ) + .bind(status) + .bind(remote_url) + .bind(last_error) + .bind(now) + .bind(tag_id) + .bind(user_id) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() == 1) + } + + async fn create_deployment(&self, row: &DevelopmentDeploymentRow) -> Result { + let result = sqlx::query( + "INSERT INTO development_deployments \ + (id, deployment_key, run_id, project_id, user_id, environment, commit_sha, status, requested_by, \ + approved_by, approval_run_id, approval_environment, approval_commit_sha, approval_requester, \ + approval_deployment_key, approval_expires_at, approved_at, remote_id, attempt_count, last_error, \ + started_at, finished_at, created_at, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(user_id, deployment_key) DO NOTHING", + ) + .bind(&row.id) + .bind(&row.deployment_key) + .bind(&row.run_id) + .bind(&row.project_id) + .bind(&row.user_id) + .bind(&row.environment) + .bind(&row.commit_sha) + .bind(&row.status) + .bind(&row.requested_by) + .bind(&row.approved_by) + .bind(&row.approval_run_id) + .bind(&row.approval_environment) + .bind(&row.approval_commit_sha) + .bind(&row.approval_requester) + .bind(&row.approval_deployment_key) + .bind(row.approval_expires_at) + .bind(row.approved_at) + .bind(&row.remote_id) + .bind(row.attempt_count) + .bind(&row.last_error) + .bind(row.started_at) + .bind(row.finished_at) + .bind(row.created_at) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() == 1) + } + + async fn get_deployment( + &self, + user_id: &str, + deployment_id: &str, + ) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM development_deployments WHERE user_id = ? AND id = ?") + .bind(user_id) + .bind(deployment_id) + .fetch_optional(&self.pool) + .await?, + ) + } + + async fn get_deployment_by_key( + &self, + user_id: &str, + deployment_key: &str, + ) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM development_deployments WHERE user_id = ? AND deployment_key = ?") + .bind(user_id) + .bind(deployment_key) + .fetch_optional(&self.pool) + .await?, + ) + } + + async fn list_deployments(&self, user_id: &str, run_id: &str) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT * FROM development_deployments WHERE user_id = ? AND run_id = ? ORDER BY created_at DESC", + ) + .bind(user_id) + .bind(run_id) + .fetch_all(&self.pool) + .await?) + } + + async fn approve_deployment(&self, user_id: &str, deployment_id: &str, now: TimestampMs) -> Result { + let result = sqlx::query( + "UPDATE development_deployments SET status = 'approved', approved_by = ?, approved_at = ?, updated_at = ? \ + WHERE id = ? AND user_id = ? AND status = 'pending_approval' AND approval_expires_at > ?", + ) + .bind(user_id) + .bind(now) + .bind(now) + .bind(deployment_id) + .bind(user_id) + .bind(now) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() == 1) + } + + async fn claim_deployment(&self, user_id: &str, deployment_id: &str, now: TimestampMs) -> Result { + let result = sqlx::query( + "UPDATE development_deployments SET status = 'running', attempt_count = attempt_count + 1, \ + started_at = COALESCE(started_at, ?), updated_at = ? \ + WHERE id = ? AND user_id = ? AND status = 'approved' AND approval_expires_at > ?", + ) + .bind(now) + .bind(now) + .bind(deployment_id) + .bind(user_id) + .bind(now) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() == 1) + } + + async fn update_deployment_result( + &self, + user_id: &str, + deployment_id: &str, + status: &str, + remote_id: Option<&str>, + last_error: Option<&str>, + now: TimestampMs, + ) -> Result { + let result = sqlx::query( + "UPDATE development_deployments SET status = ?, remote_id = COALESCE(?, remote_id), last_error = ?, \ + finished_at = CASE WHEN ? IN ('succeeded', 'failed', 'cancelled') THEN ? ELSE finished_at END, updated_at = ? \ + WHERE id = ? AND user_id = ?", + ) + .bind(status) + .bind(remote_id) + .bind(last_error) + .bind(status) + .bind(now) + .bind(now) + .bind(deployment_id) + .bind(user_id) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() == 1) + } + + async fn append_requirement_version( + &self, + row: &RequirementVersionRow, + criteria: &[AcceptanceCriterionRow], + ) -> Result<(), DbError> { + let mut tx = self.pool.begin().await?; + sqlx::query( + "INSERT INTO development_requirement_versions \ + (id, run_id, version, content, change_summary, created_by, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.run_id) + .bind(row.version) + .bind(&row.content) + .bind(&row.change_summary) + .bind(&row.created_by) + .bind(row.created_at) + .execute(&mut *tx) + .await?; + for criterion in criteria { + sqlx::query( + "INSERT INTO development_acceptance_criteria \ + (id, run_id, requirement_version_id, ordinal, statement, required, created_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&criterion.id) + .bind(&criterion.run_id) + .bind(&criterion.requirement_version_id) + .bind(criterion.ordinal) + .bind(&criterion.statement) + .bind(criterion.required) + .bind(criterion.created_at) + .execute(&mut *tx) + .await?; + } + tx.commit().await?; + Ok(()) + } + + async fn list_requirement_versions(&self, run_id: &str) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM development_requirement_versions WHERE run_id = ? ORDER BY version ASC") + .bind(run_id) + .fetch_all(&self.pool) + .await?, + ) + } + + async fn list_active_criteria(&self, run_id: &str) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT c.* FROM development_acceptance_criteria c \ + JOIN development_requirement_versions v ON v.id = c.requirement_version_id \ + WHERE c.run_id = ? AND v.version = (SELECT MAX(version) FROM development_requirement_versions WHERE run_id = ?) \ + ORDER BY c.ordinal ASC", + ) + .bind(run_id) + .bind(run_id) + .fetch_all(&self.pool) + .await?) + } + + async fn append_plan_revision(&self, row: &PlanRevisionRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_plan_revisions \ + (id, run_id, revision, summary, content, created_by, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.run_id) + .bind(row.revision) + .bind(&row.summary) + .bind(&row.content) + .bind(&row.created_by) + .bind(row.created_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn list_plan_revisions(&self, run_id: &str) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM development_plan_revisions WHERE run_id = ? ORDER BY revision ASC") + .bind(run_id) + .fetch_all(&self.pool) + .await?, + ) + } + + async fn map_task_criteria(&self, rows: &[TaskCriterionRow]) -> Result<(), DbError> { + let mut tx = self.pool.begin().await?; + for row in rows { + sqlx::query( + "INSERT INTO development_task_criteria (run_id, task_id, criterion_id, mapped_at) VALUES (?, ?, ?, ?)", + ) + .bind(&row.run_id) + .bind(&row.task_id) + .bind(&row.criterion_id) + .bind(row.mapped_at) + .execute(&mut *tx) + .await?; + } + tx.commit().await?; + Ok(()) + } + + async fn list_task_criteria(&self, run_id: &str) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT run_id, task_id, criterion_id, mapped_at FROM development_task_criteria \ + WHERE run_id = ? ORDER BY mapped_at ASC, task_id ASC, criterion_id ASC", + ) + .bind(run_id) + .fetch_all(&self.pool) + .await?) + } + + async fn create_completion_evidence(&self, row: &CompletionEvidenceRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_completion_evidence \ + (id, run_id, task_id, criterion_id, evidence_type, artifact_id, reference, accepted, reviewer_id, created_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.run_id) + .bind(&row.task_id) + .bind(&row.criterion_id) + .bind(&row.evidence_type) + .bind(&row.artifact_id) + .bind(&row.reference) + .bind(row.accepted) + .bind(&row.reviewer_id) + .bind(row.created_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn list_completion_evidence(&self, run_id: &str) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT * FROM development_completion_evidence WHERE run_id = ? ORDER BY created_at ASC, id ASC", + ) + .bind(run_id) + .fetch_all(&self.pool) + .await?) + } + + async fn create_single_run_workspace(&self, row: &SingleRunWorkspaceRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_single_run_workspaces \ + (run_id, user_id, project_id, baseline_commit, initial_diff_checksum, initial_diff_path, \ + workspace_lease_id, workspace_path, branch, candidate_commit, safe_point, cleanup_status, created_at, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.run_id) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.baseline_commit) + .bind(&row.initial_diff_checksum) + .bind(&row.initial_diff_path) + .bind(&row.workspace_lease_id) + .bind(&row.workspace_path) + .bind(&row.branch) + .bind(&row.candidate_commit) + .bind(&row.safe_point) + .bind(&row.cleanup_status) + .bind(row.created_at) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn get_single_run_workspace( + &self, + run_id: &str, + user_id: &str, + ) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM development_single_run_workspaces WHERE run_id = ? AND user_id = ?") + .bind(run_id) + .bind(user_id) + .fetch_optional(&self.pool) + .await?, + ) + } + + async fn update_single_run_workspace( + &self, + run_id: &str, + user_id: &str, + candidate_commit: Option<&str>, + cleanup_status: &str, + ) -> Result { + let result = sqlx::query( + "UPDATE development_single_run_workspaces SET candidate_commit = COALESCE(?, candidate_commit), \ + cleanup_status = ?, updated_at = ? WHERE run_id = ? AND user_id = ?", + ) + .bind(candidate_commit) + .bind(cleanup_status) + .bind(now_ms()) + .bind(run_id) + .bind(user_id) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() > 0) + } +} diff --git a/crates/aionui-db/src/repository/sqlite_development_operations.rs b/crates/aionui-db/src/repository/sqlite_development_operations.rs new file mode 100644 index 000000000..fe4c1eff3 --- /dev/null +++ b/crates/aionui-db/src/repository/sqlite_development_operations.rs @@ -0,0 +1,997 @@ +use aionui_common::{TimestampMs, now_ms}; +use sqlx::SqlitePool; + +use crate::error::DbError; +use crate::models::{ + DevelopmentAlertRow, DevelopmentAuditEventRow, DevelopmentModelPriceRow, DevelopmentPolicyRow, + DevelopmentPricedUsageEventRow, DevelopmentRecoveryRecordRow, DevelopmentRunRow, DevelopmentSecretGrantRow, + DevelopmentSecretRow, DevelopmentUsageDimensionSummary, DevelopmentUsageEventRow, DevelopmentUsageSummary, + ExecutionResourceLeaseRow, UsageDimension, +}; +use crate::repository::development_operations::IDevelopmentOperationsRepository; + +#[derive(Clone, Debug)] +pub struct SqliteDevelopmentOperationsRepository { + pool: SqlitePool, +} + +impl SqliteDevelopmentOperationsRepository { + pub fn new(pool: SqlitePool) -> Self { + Self { pool } + } +} + +#[async_trait::async_trait] +impl IDevelopmentOperationsRepository for SqliteDevelopmentOperationsRepository { + async fn get_policy(&self, user_id: &str, project_id: &str) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM development_policies WHERE user_id = ? AND project_id = ?") + .bind(user_id) + .bind(project_id) + .fetch_optional(&self.pool) + .await?, + ) + } + + async fn upsert_policy(&self, row: &DevelopmentPolicyRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_policies (id, user_id, project_id, isolation_mode, container_image, \ + devcontainer_config_path, container_cpu_millis, container_memory_mb, container_pids_limit, network_mode, \ + allowed_secret_keys_json, allowed_commands_json, protected_paths_json, allowed_network_hosts_json, \ + protected_branches_json, dangerous_confirmation_count, max_duration_ms, max_parallel_agents, \ + max_retries, max_cost_microunits, max_total_tokens, fallback_model, alert_percent, over_limit_action, \ + created_at, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(user_id, project_id) DO UPDATE SET isolation_mode=excluded.isolation_mode, \ + container_image=excluded.container_image, devcontainer_config_path=excluded.devcontainer_config_path, \ + container_cpu_millis=excluded.container_cpu_millis, container_memory_mb=excluded.container_memory_mb, \ + container_pids_limit=excluded.container_pids_limit, network_mode=excluded.network_mode, \ + allowed_secret_keys_json=excluded.allowed_secret_keys_json, \ + allowed_commands_json=excluded.allowed_commands_json, protected_paths_json=excluded.protected_paths_json, \ + allowed_network_hosts_json=excluded.allowed_network_hosts_json, \ + protected_branches_json=excluded.protected_branches_json, \ + dangerous_confirmation_count=excluded.dangerous_confirmation_count, max_duration_ms=excluded.max_duration_ms, \ + max_parallel_agents=excluded.max_parallel_agents, max_retries=excluded.max_retries, \ + max_cost_microunits=excluded.max_cost_microunits, max_total_tokens=excluded.max_total_tokens, \ + fallback_model=excluded.fallback_model, alert_percent=excluded.alert_percent, \ + over_limit_action=excluded.over_limit_action, updated_at=excluded.updated_at", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.isolation_mode) + .bind(&row.container_image) + .bind(&row.devcontainer_config_path) + .bind(row.container_cpu_millis) + .bind(row.container_memory_mb) + .bind(row.container_pids_limit) + .bind(&row.network_mode) + .bind(&row.allowed_secret_keys_json) + .bind(&row.allowed_commands_json) + .bind(&row.protected_paths_json) + .bind(&row.allowed_network_hosts_json) + .bind(&row.protected_branches_json) + .bind(row.dangerous_confirmation_count) + .bind(row.max_duration_ms) + .bind(row.max_parallel_agents) + .bind(row.max_retries) + .bind(row.max_cost_microunits) + .bind(row.max_total_tokens) + .bind(&row.fallback_model) + .bind(row.alert_percent) + .bind(&row.over_limit_action) + .bind(row.created_at) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn append_usage(&self, row: &DevelopmentUsageEventRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_usage_events (id, user_id, project_id, run_id, task_id, usage_type, source, \ + confidence, input_tokens, output_tokens, cost_microunits, duration_ms, retry_count, metadata_json, created_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.run_id) + .bind(&row.task_id) + .bind(&row.usage_type) + .bind(&row.source) + .bind(&row.confidence) + .bind(row.input_tokens) + .bind(row.output_tokens) + .bind(row.cost_microunits) + .bind(row.duration_ms) + .bind(row.retry_count) + .bind(&row.metadata_json) + .bind(row.created_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn list_usage( + &self, + user_id: &str, + project_id: &str, + run_id: Option<&str>, + limit: i64, + ) -> Result, DbError> { + let limit = limit.clamp(1, 500); + Ok(match run_id { + Some(run_id) => { + sqlx::query_as( + "SELECT * FROM development_usage_events WHERE user_id = ? AND project_id = ? AND run_id = ? \ + ORDER BY created_at DESC, id DESC LIMIT ?", + ) + .bind(user_id) + .bind(project_id) + .bind(run_id) + .bind(limit) + .fetch_all(&self.pool) + .await? + } + None => { + sqlx::query_as( + "SELECT * FROM development_usage_events WHERE user_id = ? AND project_id = ? \ + ORDER BY created_at DESC, id DESC LIMIT ?", + ) + .bind(user_id) + .bind(project_id) + .bind(limit) + .fetch_all(&self.pool) + .await? + } + }) + } + + async fn summarize_usage( + &self, + user_id: &str, + project_id: &str, + run_id: Option<&str>, + ) -> Result { + let base = "SELECT COUNT(*) AS event_count, COALESCE(SUM(input_tokens), 0) AS input_tokens, \ + COALESCE(SUM(output_tokens), 0) AS output_tokens, \ + COALESCE(SUM(cost_microunits), 0) AS cost_microunits, \ + COALESCE(SUM(duration_ms), 0) AS duration_ms, COALESCE(SUM(retry_count), 0) AS retry_count \ + FROM development_usage_events WHERE user_id = ? AND project_id = ?"; + let row = match run_id { + Some(run_id) => { + sqlx::query_as::<_, DevelopmentUsageSummary>(&format!("{base} AND run_id = ?")) + .bind(user_id) + .bind(project_id) + .bind(run_id) + .fetch_one(&self.pool) + .await? + } + None => { + sqlx::query_as::<_, DevelopmentUsageSummary>(base) + .bind(user_id) + .bind(project_id) + .fetch_one(&self.pool) + .await? + } + }; + Ok(row) + } + + async fn append_audit(&self, row: &DevelopmentAuditEventRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_audit_events (id, user_id, actor_type, actor_id, action, target_type, \ + target_id, project_id, run_id, task_id, result, redacted_payload_json, created_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.actor_type) + .bind(&row.actor_id) + .bind(&row.action) + .bind(&row.target_type) + .bind(&row.target_id) + .bind(&row.project_id) + .bind(&row.run_id) + .bind(&row.task_id) + .bind(&row.result) + .bind(&row.redacted_payload_json) + .bind(row.created_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn list_audit( + &self, + user_id: &str, + project_id: &str, + run_id: Option<&str>, + limit: i64, + ) -> Result, DbError> { + let limit = limit.clamp(1, 200); + Ok(match run_id { + Some(run_id) => { + sqlx::query_as( + "SELECT * FROM development_audit_events WHERE user_id = ? AND project_id = ? AND run_id = ? \ + ORDER BY created_at DESC, id DESC LIMIT ?", + ) + .bind(user_id) + .bind(project_id) + .bind(run_id) + .bind(limit) + .fetch_all(&self.pool) + .await? + } + None => { + sqlx::query_as( + "SELECT * FROM development_audit_events WHERE user_id = ? AND project_id = ? \ + ORDER BY created_at DESC, id DESC LIMIT ?", + ) + .bind(user_id) + .bind(project_id) + .bind(limit) + .fetch_all(&self.pool) + .await? + } + }) + } + + async fn upsert_alert(&self, row: &DevelopmentAlertRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_alerts (id, user_id, project_id, run_id, alert_type, severity, status, message, \ + dedupe_key, created_at, updated_at, resolved_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(user_id, dedupe_key) DO UPDATE SET run_id=excluded.run_id, alert_type=excluded.alert_type, \ + severity=excluded.severity, status=excluded.status, message=excluded.message, \ + updated_at=excluded.updated_at, resolved_at=excluded.resolved_at", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.run_id) + .bind(&row.alert_type) + .bind(&row.severity) + .bind(&row.status) + .bind(&row.message) + .bind(&row.dedupe_key) + .bind(row.created_at) + .bind(row.updated_at) + .bind(row.resolved_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn list_alerts( + &self, + user_id: &str, + project_id: &str, + run_id: Option<&str>, + active_only: bool, + ) -> Result, DbError> { + let status_clause = if active_only { " AND status != 'resolved'" } else { "" }; + Ok(match run_id { + Some(run_id) => sqlx::query_as(&format!( + "SELECT * FROM development_alerts WHERE user_id = ? AND project_id = ? AND run_id = ?{status_clause} \ + ORDER BY updated_at DESC, id ASC" + )) + .bind(user_id) + .bind(project_id) + .bind(run_id) + .fetch_all(&self.pool) + .await?, + None => { + sqlx::query_as(&format!( + "SELECT * FROM development_alerts WHERE user_id = ? AND project_id = ?{status_clause} \ + ORDER BY updated_at DESC, id ASC" + )) + .bind(user_id) + .bind(project_id) + .fetch_all(&self.pool) + .await? + } + }) + } + + async fn update_alert_status( + &self, + user_id: &str, + alert_id: &str, + status: &str, + resolved_at: Option, + ) -> Result { + let result = sqlx::query( + "UPDATE development_alerts SET status = ?, resolved_at = ?, updated_at = ? WHERE id = ? AND user_id = ?", + ) + .bind(status) + .bind(resolved_at) + .bind(now_ms()) + .bind(alert_id) + .bind(user_id) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() > 0) + } + + async fn append_recovery(&self, row: &DevelopmentRecoveryRecordRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_recovery_records (id, user_id, project_id, run_id, recovery_key, finding, \ + decision, status_before, status_after, details_json, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(user_id, recovery_key) DO UPDATE SET finding=excluded.finding, decision=excluded.decision, \ + status_before=excluded.status_before, status_after=excluded.status_after, \ + details_json=excluded.details_json", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.run_id) + .bind(&row.recovery_key) + .bind(&row.finding) + .bind(&row.decision) + .bind(&row.status_before) + .bind(&row.status_after) + .bind(&row.details_json) + .bind(row.created_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn claim_recovery_and_update_run( + &self, + row: &DevelopmentRecoveryRecordRow, + expected_status: &str, + expected_updated_at: TimestampMs, + target_status: &str, + finished_at: Option, + updated_at: TimestampMs, + ) -> Result { + let mut transaction = self.pool.begin().await?; + let claim = sqlx::query( + "INSERT INTO development_recovery_records (id, user_id, project_id, run_id, recovery_key, finding, \ + decision, status_before, status_after, details_json, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(user_id, recovery_key) DO UPDATE SET finding=excluded.finding, \ + decision=excluded.decision, status_before=excluded.status_before, status_after=excluded.status_after, \ + details_json=excluded.details_json \ + WHERE development_recovery_records.decision IN ('manual_required', 'interrupted') \ + OR development_recovery_records.decision = excluded.decision", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.run_id) + .bind(&row.recovery_key) + .bind(&row.finding) + .bind(&row.decision) + .bind(&row.status_before) + .bind(&row.status_after) + .bind(&row.details_json) + .bind(row.created_at) + .execute(&mut *transaction) + .await?; + if claim.rows_affected() != 1 { + transaction.rollback().await?; + return Ok(false); + } + let run_update = sqlx::query( + "UPDATE development_runs SET status = ?, finished_at = ?, updated_at = MAX(?, updated_at + 1) \ + WHERE id = ? AND user_id = ? AND status = ? AND updated_at = ?", + ) + .bind(target_status) + .bind(finished_at) + .bind(updated_at) + .bind(row.run_id.as_deref()) + .bind(&row.user_id) + .bind(expected_status) + .bind(expected_updated_at) + .execute(&mut *transaction) + .await?; + if run_update.rows_affected() != 1 { + transaction.rollback().await?; + return Ok(false); + } + transaction.commit().await?; + Ok(true) + } + + async fn list_recovery( + &self, + user_id: &str, + project_id: &str, + run_id: Option<&str>, + limit: i64, + ) -> Result, DbError> { + let limit = limit.clamp(1, 200); + Ok(match run_id { + Some(run_id) => { + sqlx::query_as( + "SELECT * FROM development_recovery_records WHERE user_id = ? AND project_id = ? AND run_id = ? \ + ORDER BY created_at DESC, id DESC LIMIT ?", + ) + .bind(user_id) + .bind(project_id) + .bind(run_id) + .bind(limit) + .fetch_all(&self.pool) + .await? + } + None => { + sqlx::query_as( + "SELECT * FROM development_recovery_records WHERE user_id = ? AND project_id = ? \ + ORDER BY created_at DESC, id DESC LIMIT ?", + ) + .bind(user_id) + .bind(project_id) + .bind(limit) + .fetch_all(&self.pool) + .await? + } + }) + } + + async fn list_recovery_candidates(&self, updated_before: TimestampMs) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT * FROM development_runs WHERE status IN ('running', 'verifying', 'reviewing', 'integrating') \ + AND updated_at <= ? ORDER BY updated_at ASC, id ASC", + ) + .bind(updated_before) + .fetch_all(&self.pool) + .await?) + } + + async fn upsert_resource_lease(&self, row: &ExecutionResourceLeaseRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO execution_resource_leases (id, user_id, project_id, run_id, task_id, turn_id, gate_id, \ + environment_id, environment_kind, resource_kind, resource_identifier, status, accepts_work, \ + owner_instance_id, heartbeat_at, expires_at, cleanup_order, cleanup_status, cleanup_result, \ + recovery_decision, created_at, updated_at, terminal_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(id) DO UPDATE SET status=excluded.status, accepts_work=excluded.accepts_work, \ + owner_instance_id=CASE WHEN execution_resource_leases.recovery_decision IS NULL \ + THEN excluded.owner_instance_id ELSE execution_resource_leases.owner_instance_id END, \ + heartbeat_at=excluded.heartbeat_at, \ + expires_at=excluded.expires_at, cleanup_status=excluded.cleanup_status, \ + cleanup_result=excluded.cleanup_result, \ + recovery_decision=COALESCE(execution_resource_leases.recovery_decision, excluded.recovery_decision), \ + updated_at=excluded.updated_at, terminal_at=excluded.terminal_at", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.run_id) + .bind(&row.task_id) + .bind(&row.turn_id) + .bind(&row.gate_id) + .bind(&row.environment_id) + .bind(&row.environment_kind) + .bind(&row.resource_kind) + .bind(&row.resource_identifier) + .bind(&row.status) + .bind(row.accepts_work) + .bind(&row.owner_instance_id) + .bind(row.heartbeat_at) + .bind(row.expires_at) + .bind(row.cleanup_order) + .bind(&row.cleanup_status) + .bind(&row.cleanup_result) + .bind(&row.recovery_decision) + .bind(row.created_at) + .bind(row.updated_at) + .bind(row.terminal_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn claim_resource_cleanup( + &self, + lease_id: &str, + expected_owner_instance_id: &str, + expected_status: &str, + expected_updated_at: TimestampMs, + cleanup_owner_instance_id: &str, + claimed_at: TimestampMs, + ) -> Result, DbError> { + Ok(sqlx::query_as( + "UPDATE execution_resource_leases \ + SET owner_instance_id = ?, status = 'stopping', accepts_work = 0, \ + heartbeat_at = ?, expires_at = ? + MAX(expires_at - heartbeat_at, 1), \ + cleanup_status = 'stopping', cleanup_result = NULL, terminal_at = NULL, \ + updated_at = MAX(?, updated_at + 1) \ + WHERE id = ? AND owner_instance_id = ? AND status = ? AND updated_at = ? \ + AND status IN ('active', 'orphaned', 'cleanup_failed') \ + AND (terminal_at IS NULL OR status = 'cleanup_failed') \ + RETURNING *", + ) + .bind(cleanup_owner_instance_id) + .bind(claimed_at) + .bind(claimed_at) + .bind(claimed_at) + .bind(lease_id) + .bind(expected_owner_instance_id) + .bind(expected_status) + .bind(expected_updated_at) + .fetch_optional(&self.pool) + .await?) + } + + async fn finish_resource_cleanup( + &self, + lease_id: &str, + cleanup_owner_instance_id: &str, + expected_updated_at: TimestampMs, + succeeded: bool, + cleanup_result: &str, + completed_at: TimestampMs, + ) -> Result { + let (status, cleanup_status) = if succeeded { + ("released", "released") + } else { + ("cleanup_failed", "failed") + }; + let result = sqlx::query( + "UPDATE execution_resource_leases \ + SET status = ?, accepts_work = 0, cleanup_status = ?, cleanup_result = ?, \ + updated_at = MAX(?, updated_at + 1), terminal_at = ? \ + WHERE id = ? AND owner_instance_id = ? AND status = 'stopping' \ + AND updated_at = ? AND terminal_at IS NULL", + ) + .bind(status) + .bind(cleanup_status) + .bind(cleanup_result) + .bind(completed_at) + .bind(completed_at) + .bind(lease_id) + .bind(cleanup_owner_instance_id) + .bind(expected_updated_at) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() == 1) + } + + async fn claim_resource_recovery_decision( + &self, + lease_id: &str, + decision: &str, + takeover_owner_instance_id: Option<&str>, + updated_at: TimestampMs, + ) -> Result, DbError> { + let result = if decision == "takeover" { + sqlx::query_as( + "UPDATE execution_resource_leases \ + SET recovery_decision = ?, owner_instance_id = ?, status = 'active', accepts_work = 1, \ + heartbeat_at = ?, expires_at = ? + MAX(expires_at - heartbeat_at, 1), \ + cleanup_status = NULL, cleanup_result = NULL, terminal_at = NULL, \ + updated_at = MAX(?, updated_at + 1) \ + WHERE id = ? AND status = 'orphaned' AND terminal_at IS NULL \ + AND (recovery_decision IS NULL \ + OR (recovery_decision = 'takeover' AND status = 'orphaned')) \ + RETURNING *", + ) + .bind(decision) + .bind(takeover_owner_instance_id) + .bind(updated_at) + .bind(updated_at) + .bind(updated_at) + .bind(lease_id) + .fetch_optional(&self.pool) + .await? + } else { + sqlx::query_as( + "UPDATE execution_resource_leases SET recovery_decision = ?, \ + updated_at = MAX(?, updated_at + 1) \ + WHERE id = ? AND recovery_decision IS NULL \ + RETURNING *", + ) + .bind(decision) + .bind(updated_at) + .bind(lease_id) + .fetch_optional(&self.pool) + .await? + }; + Ok(result) + } + + async fn heartbeat_resource_lease( + &self, + lease_id: &str, + owner_instance_id: &str, + expected_updated_at: TimestampMs, + heartbeat_at: TimestampMs, + expires_at: TimestampMs, + ) -> Result, DbError> { + Ok(sqlx::query_as( + "UPDATE execution_resource_leases SET heartbeat_at = ?, expires_at = ?, \ + updated_at = MAX(?, updated_at + 1) \ + WHERE id = ? AND owner_instance_id = ? AND updated_at = ? \ + AND status = 'active' AND accepts_work = 1 AND terminal_at IS NULL \ + RETURNING *", + ) + .bind(heartbeat_at) + .bind(expires_at) + .bind(heartbeat_at) + .bind(lease_id) + .bind(owner_instance_id) + .bind(expected_updated_at) + .fetch_optional(&self.pool) + .await?) + } + + async fn complete_resource_lease( + &self, + lease_id: &str, + owner_instance_id: &str, + expected_updated_at: TimestampMs, + cleanup_result: &str, + completed_at: TimestampMs, + ) -> Result { + let result = sqlx::query( + "UPDATE execution_resource_leases SET accepts_work = 0, status = 'released', \ + cleanup_status = 'released', cleanup_result = ?, \ + updated_at = MAX(?, updated_at + 1), terminal_at = ? \ + WHERE id = ? AND owner_instance_id = ? AND status = 'active' AND accepts_work = 1 \ + AND updated_at = ? AND terminal_at IS NULL", + ) + .bind(cleanup_result) + .bind(completed_at) + .bind(completed_at) + .bind(lease_id) + .bind(owner_instance_id) + .bind(expected_updated_at) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() == 1) + } + + async fn orphan_resource_lease( + &self, + lease_id: &str, + owner_instance_id: &str, + expected_expires_at: TimestampMs, + orphaned_at: TimestampMs, + ) -> Result, DbError> { + Ok(sqlx::query_as( + "UPDATE execution_resource_leases SET status = 'orphaned', accepts_work = 0, \ + recovery_decision = NULL, updated_at = MAX(?, updated_at + 1) \ + WHERE id = ? AND owner_instance_id = ? AND expires_at = ? \ + AND status IN ('active', 'stopping') AND terminal_at IS NULL \ + RETURNING *", + ) + .bind(orphaned_at) + .bind(lease_id) + .bind(owner_instance_id) + .bind(expected_expires_at) + .fetch_optional(&self.pool) + .await?) + } + + async fn get_resource_lease(&self, lease_id: &str) -> Result, DbError> { + Ok(sqlx::query_as("SELECT * FROM execution_resource_leases WHERE id = ?") + .bind(lease_id) + .fetch_optional(&self.pool) + .await?) + } + + async fn list_resource_leases( + &self, + user_id: &str, + run_id: &str, + active_only: bool, + ) -> Result, DbError> { + let status = if active_only { + " AND status IN ('active', 'stopping', 'orphaned', 'cleanup_failed')" + } else { + "" + }; + Ok(sqlx::query_as(&format!( + "SELECT * FROM execution_resource_leases WHERE user_id = ? AND run_id = ?{status} \ + ORDER BY cleanup_order ASC, created_at ASC, id ASC" + )) + .bind(user_id) + .bind(run_id) + .fetch_all(&self.pool) + .await?) + } + + async fn list_stale_resource_leases(&self, now: TimestampMs) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT * FROM execution_resource_leases WHERE status IN ('active', 'stopping') \ + AND expires_at <= ? ORDER BY expires_at ASC, id ASC", + ) + .bind(now) + .fetch_all(&self.pool) + .await?) + } + + async fn bind_execution_environment( + &self, + entity_type: &str, + entity_id: &str, + environment_id: &str, + environment_kind: &str, + bound_at: TimestampMs, + ) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO execution_environment_bindings \ + (entity_type, entity_id, environment_id, environment_kind, bound_at) VALUES (?, ?, ?, ?, ?) \ + ON CONFLICT(entity_type, entity_id, environment_id) DO UPDATE SET \ + environment_kind=excluded.environment_kind, bound_at=excluded.bound_at", + ) + .bind(entity_type) + .bind(entity_id) + .bind(environment_id) + .bind(environment_kind) + .bind(bound_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn insert_secret(&self, row: &DevelopmentSecretRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_secrets (id, user_id, project_id, name, encrypted_value, key_version, status, \ + expires_at, revoked_at, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.name) + .bind(&row.encrypted_value) + .bind(&row.key_version) + .bind(&row.status) + .bind(row.expires_at) + .bind(row.revoked_at) + .bind(row.created_at) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn get_secret(&self, user_id: &str, secret_id: &str) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM development_secrets WHERE user_id = ? AND id = ?") + .bind(user_id) + .bind(secret_id) + .fetch_optional(&self.pool) + .await?, + ) + } + + async fn list_secrets(&self, user_id: &str, project_id: &str) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT * FROM development_secrets WHERE user_id = ? AND project_id = ? ORDER BY created_at DESC, id DESC", + ) + .bind(user_id) + .bind(project_id) + .fetch_all(&self.pool) + .await?) + } + + async fn revoke_secret(&self, user_id: &str, secret_id: &str, revoked_at: TimestampMs) -> Result { + let result = sqlx::query( + "UPDATE development_secrets SET status = 'revoked', revoked_at = ?, updated_at = ? \ + WHERE user_id = ? AND id = ? AND status = 'active'", + ) + .bind(revoked_at) + .bind(revoked_at) + .bind(user_id) + .bind(secret_id) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() > 0) + } + + async fn upsert_secret_grant(&self, row: &DevelopmentSecretGrantRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_secret_grants (id, user_id, project_id, secret_id, scope_type, scope_id, \ + environment_key, status, expires_at, revoked_at, created_at, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(user_id, secret_id, scope_type, scope_id, environment_key) DO UPDATE SET \ + status=excluded.status, expires_at=excluded.expires_at, revoked_at=excluded.revoked_at, \ + updated_at=excluded.updated_at", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.secret_id) + .bind(&row.scope_type) + .bind(&row.scope_id) + .bind(&row.environment_key) + .bind(&row.status) + .bind(row.expires_at) + .bind(row.revoked_at) + .bind(row.created_at) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn list_secret_grants( + &self, + user_id: &str, + secret_id: &str, + ) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT * FROM development_secret_grants WHERE user_id = ? AND secret_id = ? \ + ORDER BY created_at ASC, id ASC", + ) + .bind(user_id) + .bind(secret_id) + .fetch_all(&self.pool) + .await?) + } + + async fn upsert_model_price(&self, row: &DevelopmentModelPriceRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_model_prices (id, provider, model, input_per_million_microunits, \ + output_per_million_microunits, cache_read_per_million_microunits, \ + cache_write_per_million_microunits, source_id, version, effective_at, created_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(provider, model, source_id, version) DO UPDATE SET \ + input_per_million_microunits=excluded.input_per_million_microunits, \ + output_per_million_microunits=excluded.output_per_million_microunits, \ + cache_read_per_million_microunits=excluded.cache_read_per_million_microunits, \ + cache_write_per_million_microunits=excluded.cache_write_per_million_microunits, \ + effective_at=excluded.effective_at", + ) + .bind(&row.id) + .bind(&row.provider) + .bind(&row.model) + .bind(row.input_per_million_microunits) + .bind(row.output_per_million_microunits) + .bind(row.cache_read_per_million_microunits) + .bind(row.cache_write_per_million_microunits) + .bind(&row.source_id) + .bind(&row.version) + .bind(row.effective_at) + .bind(row.created_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn resolve_model_price( + &self, + provider: &str, + model: &str, + occurred_at: TimestampMs, + ) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT * FROM development_model_prices WHERE provider = ? AND model = ? AND effective_at <= ? \ + ORDER BY effective_at DESC, created_at DESC, id DESC LIMIT 1", + ) + .bind(provider) + .bind(model) + .bind(occurred_at) + .fetch_optional(&self.pool) + .await?) + } + + async fn append_priced_usage(&self, row: &DevelopmentPricedUsageEventRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO development_usage_events (id, user_id, project_id, run_id, task_id, conversation_id, \ + agent_id, team_id, usage_type, source, confidence, provider, model, input_tokens, output_tokens, \ + cache_read_tokens, cache_write_tokens, cost_microunits, cost_status, cost_origin, price_source_id, \ + price_version, price_effective_at, duration_ms, retry_count, metadata_json, created_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.run_id) + .bind(&row.task_id) + .bind(&row.conversation_id) + .bind(&row.agent_id) + .bind(&row.team_id) + .bind(&row.usage_type) + .bind(&row.source) + .bind(&row.confidence) + .bind(&row.provider) + .bind(&row.model) + .bind(row.input_tokens) + .bind(row.output_tokens) + .bind(row.cache_read_tokens) + .bind(row.cache_write_tokens) + .bind(row.cost_microunits) + .bind(&row.cost_status) + .bind(&row.cost_origin) + .bind(&row.price_source_id) + .bind(&row.price_version) + .bind(row.price_effective_at) + .bind(row.duration_ms) + .bind(row.retry_count) + .bind(&row.metadata_json) + .bind(row.created_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn append_priced_usage_once(&self, row: &DevelopmentPricedUsageEventRow) -> Result { + let result = sqlx::query( + "INSERT OR IGNORE INTO development_usage_events (id, user_id, project_id, run_id, task_id, conversation_id, \ + agent_id, team_id, usage_type, source, confidence, provider, model, input_tokens, output_tokens, \ + cache_read_tokens, cache_write_tokens, cost_microunits, cost_status, cost_origin, price_source_id, \ + price_version, price_effective_at, duration_ms, retry_count, metadata_json, created_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.run_id) + .bind(&row.task_id) + .bind(&row.conversation_id) + .bind(&row.agent_id) + .bind(&row.team_id) + .bind(&row.usage_type) + .bind(&row.source) + .bind(&row.confidence) + .bind(&row.provider) + .bind(&row.model) + .bind(row.input_tokens) + .bind(row.output_tokens) + .bind(row.cache_read_tokens) + .bind(row.cache_write_tokens) + .bind(row.cost_microunits) + .bind(&row.cost_status) + .bind(&row.cost_origin) + .bind(&row.price_source_id) + .bind(&row.price_version) + .bind(row.price_effective_at) + .bind(row.duration_ms) + .bind(row.retry_count) + .bind(&row.metadata_json) + .bind(row.created_at) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() == 1) + } + + async fn latest_priced_usage_for_conversation( + &self, + user_id: &str, + conversation_id: &str, + ) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT * FROM development_usage_events WHERE user_id = ? AND conversation_id = ? \ + ORDER BY created_at DESC, id DESC LIMIT 1", + ) + .bind(user_id) + .bind(conversation_id) + .fetch_optional(&self.pool) + .await?) + } + + async fn summarize_usage_dimension( + &self, + user_id: &str, + dimension: &UsageDimension, + ) -> Result { + let (column, value) = match dimension { + UsageDimension::Project(value) => ("project_id", value), + UsageDimension::Run(value) => ("run_id", value), + UsageDimension::Task(value) => ("task_id", value), + UsageDimension::Conversation(value) => ("conversation_id", value), + UsageDimension::Agent(value) => ("agent_id", value), + UsageDimension::Team(value) => ("team_id", value), + }; + let sql = format!( + "SELECT COUNT(*) AS event_count, COALESCE(SUM(input_tokens), 0) AS input_tokens, \ + COALESCE(SUM(output_tokens), 0) AS output_tokens, \ + COALESCE(SUM(cache_read_tokens), 0) AS cache_read_tokens, \ + COALESCE(SUM(cache_write_tokens), 0) AS cache_write_tokens, \ + COALESCE(SUM(CASE WHEN cost_status = 'known' THEN cost_microunits ELSE 0 END), 0) AS known_cost_microunits, \ + COALESCE(SUM(CASE WHEN cost_status = 'unknown' THEN 1 ELSE 0 END), 0) AS unknown_cost_events, \ + COALESCE(SUM(duration_ms), 0) AS duration_ms, COALESCE(SUM(retry_count), 0) AS retry_count \ + FROM development_usage_events WHERE user_id = ? AND {column} = ?" + ); + Ok(sqlx::query_as(&sql) + .bind(user_id) + .bind(value) + .fetch_one(&self.pool) + .await?) + } +} diff --git a/crates/aionui-db/src/repository/sqlite_project.rs b/crates/aionui-db/src/repository/sqlite_project.rs new file mode 100644 index 000000000..9bfe4116b --- /dev/null +++ b/crates/aionui-db/src/repository/sqlite_project.rs @@ -0,0 +1,521 @@ +use aionui_common::now_ms; +use sqlx::SqlitePool; + +use crate::error::DbError; +use crate::models::{ + ProjectCommandProfileRow, ProjectKnowledgeContextRow, ProjectKnowledgeFactRow, ProjectKnowledgeIndexRow, + ProjectRepositoryFactsRow, ProjectResourceLinkRow, ProjectRow, ProjectRuntimeProfileRow, +}; +use crate::repository::project::{IProjectRepository, UpdateProjectParams}; + +#[derive(Clone, Debug)] +pub struct SqliteProjectRepository { + pool: SqlitePool, +} + +impl SqliteProjectRepository { + pub fn new(pool: SqlitePool) -> Self { + Self { pool } + } +} + +fn map_project_write_error(error: sqlx::Error, local_path: &str) -> DbError { + if error + .as_database_error() + .and_then(|db| db.code()) + .is_some_and(|code| code == "2067") + { + DbError::Conflict(format!("project path already registered: {local_path}")) + } else { + DbError::Query(error) + } +} + +#[async_trait::async_trait] +impl IProjectRepository for SqliteProjectRepository { + async fn create(&self, row: &ProjectRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO projects \ + (id, user_id, name, local_path, repository_url, default_branch, project_type, created_at, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.name) + .bind(&row.local_path) + .bind(&row.repository_url) + .bind(&row.default_branch) + .bind(&row.project_type) + .bind(row.created_at) + .bind(row.updated_at) + .execute(&self.pool) + .await + .map_err(|error| map_project_write_error(error, &row.local_path))?; + Ok(()) + } + + async fn list_for_user(&self, user_id: &str) -> Result, DbError> { + Ok( + sqlx::query_as::<_, ProjectRow>( + "SELECT * FROM projects WHERE user_id = ? ORDER BY updated_at DESC, id ASC", + ) + .bind(user_id) + .fetch_all(&self.pool) + .await?, + ) + } + + async fn get_for_user(&self, project_id: &str, user_id: &str) -> Result, DbError> { + Ok( + sqlx::query_as::<_, ProjectRow>("SELECT * FROM projects WHERE id = ? AND user_id = ?") + .bind(project_id) + .bind(user_id) + .fetch_optional(&self.pool) + .await?, + ) + } + + async fn update_for_user( + &self, + project_id: &str, + user_id: &str, + params: &UpdateProjectParams, + ) -> Result { + let existing = self + .get_for_user(project_id, user_id) + .await? + .ok_or_else(|| DbError::NotFound(format!("project {project_id}")))?; + let updated = ProjectRow { + id: existing.id, + user_id: existing.user_id, + name: params.name.clone().unwrap_or(existing.name), + local_path: params.local_path.clone().unwrap_or(existing.local_path), + repository_url: params.repository_url.clone().unwrap_or(existing.repository_url), + default_branch: params.default_branch.clone().unwrap_or(existing.default_branch), + project_type: params.project_type.clone().unwrap_or(existing.project_type), + created_at: existing.created_at, + updated_at: now_ms(), + }; + + sqlx::query( + "UPDATE projects SET name = ?, local_path = ?, repository_url = ?, default_branch = ?, \ + project_type = ?, updated_at = ? WHERE id = ? AND user_id = ?", + ) + .bind(&updated.name) + .bind(&updated.local_path) + .bind(&updated.repository_url) + .bind(&updated.default_branch) + .bind(&updated.project_type) + .bind(updated.updated_at) + .bind(project_id) + .bind(user_id) + .execute(&self.pool) + .await + .map_err(|error| map_project_write_error(error, &updated.local_path))?; + Ok(updated) + } + + async fn delete_for_user(&self, project_id: &str, user_id: &str) -> Result { + let result = sqlx::query("DELETE FROM projects WHERE id = ? AND user_id = ?") + .bind(project_id) + .bind(user_id) + .execute(&self.pool) + .await?; + Ok(result.rows_affected() > 0) + } + + async fn upsert_command_profile(&self, row: &ProjectCommandProfileRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO project_command_profiles \ + (project_id, install_command, format_command, lint_command, typecheck_command, unit_test_command, \ + integration_test_command, e2e_command, build_command, security_scan_command, command_timeout_seconds, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(project_id) DO UPDATE SET \ + install_command = excluded.install_command, format_command = excluded.format_command, \ + lint_command = excluded.lint_command, typecheck_command = excluded.typecheck_command, \ + unit_test_command = excluded.unit_test_command, integration_test_command = excluded.integration_test_command, \ + e2e_command = excluded.e2e_command, build_command = excluded.build_command, \ + security_scan_command = excluded.security_scan_command, \ + command_timeout_seconds = excluded.command_timeout_seconds, updated_at = excluded.updated_at", + ) + .bind(&row.project_id) + .bind(&row.install_command) + .bind(&row.format_command) + .bind(&row.lint_command) + .bind(&row.typecheck_command) + .bind(&row.unit_test_command) + .bind(&row.integration_test_command) + .bind(&row.e2e_command) + .bind(&row.build_command) + .bind(&row.security_scan_command) + .bind(row.command_timeout_seconds) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn get_command_profile( + &self, + project_id: &str, + user_id: &str, + ) -> Result, DbError> { + Ok(sqlx::query_as::<_, ProjectCommandProfileRow>( + "SELECT profile.* FROM project_command_profiles profile \ + JOIN projects project ON project.id = profile.project_id \ + WHERE profile.project_id = ? AND project.user_id = ?", + ) + .bind(project_id) + .bind(user_id) + .fetch_optional(&self.pool) + .await?) + } + + async fn upsert_runtime_profile(&self, row: &ProjectRuntimeProfileRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO project_runtime_profiles \ + (project_id, environment_kind, language, package_manager, runtime_version, env_keys, metadata, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(project_id) DO UPDATE SET \ + environment_kind = excluded.environment_kind, language = excluded.language, \ + package_manager = excluded.package_manager, runtime_version = excluded.runtime_version, \ + env_keys = excluded.env_keys, metadata = excluded.metadata, updated_at = excluded.updated_at", + ) + .bind(&row.project_id) + .bind(&row.environment_kind) + .bind(&row.language) + .bind(&row.package_manager) + .bind(&row.runtime_version) + .bind(&row.env_keys) + .bind(&row.metadata) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn get_runtime_profile( + &self, + project_id: &str, + user_id: &str, + ) -> Result, DbError> { + Ok(sqlx::query_as::<_, ProjectRuntimeProfileRow>( + "SELECT profile.* FROM project_runtime_profiles profile \ + JOIN projects project ON project.id = profile.project_id \ + WHERE profile.project_id = ? AND project.user_id = ?", + ) + .bind(project_id) + .bind(user_id) + .fetch_optional(&self.pool) + .await?) + } + + async fn upsert_repository_facts(&self, row: &ProjectRepositoryFactsRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO project_repository_facts \ + (project_id, repository_url, default_branch, baseline_commit, repository_dirty, \ + dirty_worktree_choice, dirty_snapshot_ref, credential_reference, detected_languages_json, \ + detected_package_managers_json, detected_rules_files_json, monorepo_packages_json, \ + submodules_json, lfs_detected, detected_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(project_id) DO UPDATE SET \ + repository_url = excluded.repository_url, default_branch = excluded.default_branch, \ + baseline_commit = excluded.baseline_commit, repository_dirty = excluded.repository_dirty, \ + dirty_worktree_choice = excluded.dirty_worktree_choice, dirty_snapshot_ref = excluded.dirty_snapshot_ref, \ + credential_reference = excluded.credential_reference, detected_languages_json = excluded.detected_languages_json, \ + detected_package_managers_json = excluded.detected_package_managers_json, \ + detected_rules_files_json = excluded.detected_rules_files_json, \ + monorepo_packages_json = excluded.monorepo_packages_json, submodules_json = excluded.submodules_json, \ + lfs_detected = excluded.lfs_detected, detected_at = excluded.detected_at", + ) + .bind(&row.project_id) + .bind(&row.repository_url) + .bind(&row.default_branch) + .bind(&row.baseline_commit) + .bind(row.repository_dirty) + .bind(&row.dirty_worktree_choice) + .bind(&row.dirty_snapshot_ref) + .bind(&row.credential_reference) + .bind(&row.detected_languages_json) + .bind(&row.detected_package_managers_json) + .bind(&row.detected_rules_files_json) + .bind(&row.monorepo_packages_json) + .bind(&row.submodules_json) + .bind(row.lfs_detected) + .bind(row.detected_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn get_repository_facts( + &self, + project_id: &str, + user_id: &str, + ) -> Result, DbError> { + Ok(sqlx::query_as::<_, ProjectRepositoryFactsRow>( + "SELECT facts.* FROM project_repository_facts facts \ + JOIN projects project ON project.id = facts.project_id \ + WHERE facts.project_id = ? AND project.user_id = ?", + ) + .bind(project_id) + .bind(user_id) + .fetch_optional(&self.pool) + .await?) + } + + async fn upsert_knowledge_index(&self, row: &ProjectKnowledgeIndexRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO project_knowledge_indexes \ + (project_id, provider, provider_project_name, provider_version, status, generation, source_commit, \ + indexed_at, changed_paths_json, error_category, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(project_id) DO UPDATE SET \ + provider = excluded.provider, provider_project_name = excluded.provider_project_name, \ + provider_version = excluded.provider_version, status = excluded.status, generation = excluded.generation, \ + source_commit = excluded.source_commit, indexed_at = excluded.indexed_at, \ + changed_paths_json = excluded.changed_paths_json, error_category = excluded.error_category, \ + updated_at = excluded.updated_at", + ) + .bind(&row.project_id) + .bind(&row.provider) + .bind(&row.provider_project_name) + .bind(&row.provider_version) + .bind(&row.status) + .bind(row.generation) + .bind(&row.source_commit) + .bind(row.indexed_at) + .bind(&row.changed_paths_json) + .bind(&row.error_category) + .bind(row.updated_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn commit_knowledge_generation( + &self, + index: &ProjectKnowledgeIndexRow, + facts: &[ProjectKnowledgeFactRow], + ) -> Result<(), DbError> { + let mut transaction = self.pool.begin().await?; + sqlx::query( + "INSERT INTO project_knowledge_indexes \ + (project_id, provider, provider_project_name, provider_version, status, generation, source_commit, \ + indexed_at, changed_paths_json, error_category, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \ + ON CONFLICT(project_id) DO UPDATE SET \ + provider = excluded.provider, provider_project_name = excluded.provider_project_name, \ + provider_version = excluded.provider_version, status = excluded.status, generation = excluded.generation, \ + source_commit = excluded.source_commit, indexed_at = excluded.indexed_at, \ + changed_paths_json = excluded.changed_paths_json, error_category = excluded.error_category, \ + updated_at = excluded.updated_at", + ) + .bind(&index.project_id) + .bind(&index.provider) + .bind(&index.provider_project_name) + .bind(&index.provider_version) + .bind(&index.status) + .bind(index.generation) + .bind(&index.source_commit) + .bind(index.indexed_at) + .bind(&index.changed_paths_json) + .bind(&index.error_category) + .bind(index.updated_at) + .execute(&mut *transaction) + .await?; + sqlx::query("DELETE FROM project_knowledge_facts WHERE project_id = ?") + .bind(&index.project_id) + .execute(&mut *transaction) + .await?; + for fact in facts { + sqlx::query( + "INSERT INTO project_knowledge_facts \ + (id, project_id, generation, kind, name, qualified_name, source_path, source_line, indexed_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&fact.id) + .bind(&fact.project_id) + .bind(fact.generation) + .bind(&fact.kind) + .bind(&fact.name) + .bind(&fact.qualified_name) + .bind(&fact.source_path) + .bind(fact.source_line) + .bind(fact.indexed_at) + .execute(&mut *transaction) + .await?; + } + transaction.commit().await?; + Ok(()) + } + + async fn get_knowledge_index( + &self, + project_id: &str, + user_id: &str, + ) -> Result, DbError> { + Ok(sqlx::query_as::<_, ProjectKnowledgeIndexRow>( + "SELECT knowledge.* FROM project_knowledge_indexes knowledge \ + JOIN projects project ON project.id = knowledge.project_id \ + WHERE knowledge.project_id = ? AND project.user_id = ?", + ) + .bind(project_id) + .bind(user_id) + .fetch_optional(&self.pool) + .await?) + } + + async fn list_knowledge_facts( + &self, + project_id: &str, + user_id: &str, + ) -> Result, DbError> { + Ok(sqlx::query_as::<_, ProjectKnowledgeFactRow>( + "SELECT fact.* FROM project_knowledge_facts fact \ + JOIN projects project ON project.id = fact.project_id \ + JOIN project_knowledge_indexes knowledge ON knowledge.project_id = fact.project_id \ + AND knowledge.generation = fact.generation \ + WHERE fact.project_id = ? AND project.user_id = ? \ + ORDER BY fact.kind ASC, fact.name ASC, fact.source_path ASC, fact.source_line ASC", + ) + .bind(project_id) + .bind(user_id) + .fetch_all(&self.pool) + .await?) + } + + async fn insert_knowledge_context(&self, row: &ProjectKnowledgeContextRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO project_knowledge_contexts \ + (id, project_id, provider_project_name, generation, query, symbols_json, callers_json, tests_json, \ + routes_json, data_entities_json, created_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.project_id) + .bind(&row.provider_project_name) + .bind(row.generation) + .bind(&row.query) + .bind(&row.symbols_json) + .bind(&row.callers_json) + .bind(&row.tests_json) + .bind(&row.routes_json) + .bind(&row.data_entities_json) + .bind(row.created_at) + .execute(&self.pool) + .await?; + Ok(()) + } + + async fn get_knowledge_context( + &self, + context_id: &str, + user_id: &str, + ) -> Result, DbError> { + Ok(sqlx::query_as::<_, ProjectKnowledgeContextRow>( + "SELECT context.* FROM project_knowledge_contexts context \ + JOIN projects project ON project.id = context.project_id \ + WHERE context.id = ? AND project.user_id = ?", + ) + .bind(context_id) + .bind(user_id) + .fetch_optional(&self.pool) + .await?) + } + + async fn bind_resource( + &self, + project_id: &str, + user_id: &str, + resource_type: &str, + resource_id: &str, + ) -> Result { + if self.get_for_user(project_id, user_id).await?.is_none() { + return Err(DbError::NotFound(format!("project {project_id}"))); + } + let row = ProjectResourceLinkRow { + project_id: project_id.to_owned(), + user_id: user_id.to_owned(), + resource_type: resource_type.to_owned(), + resource_id: resource_id.to_owned(), + created_at: now_ms(), + }; + sqlx::query( + "INSERT INTO project_resource_links (project_id, user_id, resource_type, resource_id, created_at) \ + VALUES (?, ?, ?, ?, ?) \ + ON CONFLICT(user_id, resource_type, resource_id) DO UPDATE SET \ + project_id = excluded.project_id, created_at = excluded.created_at", + ) + .bind(&row.project_id) + .bind(&row.user_id) + .bind(&row.resource_type) + .bind(&row.resource_id) + .bind(row.created_at) + .execute(&self.pool) + .await?; + Ok(row) + } + + async fn resource_is_owned(&self, user_id: &str, resource_type: &str, resource_id: &str) -> Result { + let query = match resource_type { + "conversation" => "SELECT EXISTS(SELECT 1 FROM conversations WHERE id = ? AND user_id = ?)", + "team" => "SELECT EXISTS(SELECT 1 FROM teams WHERE id = ? AND user_id = ?)", + "cron" => { + "SELECT EXISTS(\ + SELECT 1 FROM cron_jobs cron \ + JOIN conversations conversation ON conversation.id = cron.conversation_id \ + WHERE cron.id = ? AND conversation.user_id = ?\ + )" + } + "channel" => { + "SELECT EXISTS(\ + SELECT 1 FROM assistant_sessions channel \ + JOIN conversations conversation ON conversation.id = channel.conversation_id \ + WHERE channel.id = ? AND conversation.user_id = ?\ + )" + } + _ => return Ok(false), + }; + let owned: i64 = sqlx::query_scalar(query) + .bind(resource_id) + .bind(user_id) + .fetch_one(&self.pool) + .await?; + Ok(owned != 0) + } + + async fn get_for_resource( + &self, + user_id: &str, + resource_type: &str, + resource_id: &str, + ) -> Result, DbError> { + Ok(sqlx::query_as::<_, ProjectRow>( + "SELECT project.* FROM projects project \ + JOIN project_resource_links link ON link.project_id = project.id AND link.user_id = project.user_id \ + WHERE link.user_id = ? AND link.resource_type = ? AND link.resource_id = ?", + ) + .bind(user_id) + .bind(resource_type) + .bind(resource_id) + .fetch_optional(&self.pool) + .await?) + } + + async fn list_resource_links( + &self, + project_id: &str, + user_id: &str, + ) -> Result, DbError> { + Ok(sqlx::query_as::<_, ProjectResourceLinkRow>( + "SELECT link.* FROM project_resource_links link \ + JOIN projects project ON project.id = link.project_id AND project.user_id = link.user_id \ + WHERE link.project_id = ? AND link.user_id = ? ORDER BY link.created_at DESC, link.resource_id ASC", + ) + .bind(project_id) + .bind(user_id) + .fetch_all(&self.pool) + .await?) + } +} diff --git a/crates/aionui-db/src/repository/sqlite_team.rs b/crates/aionui-db/src/repository/sqlite_team.rs index 63990280c..7294fcdcf 100644 --- a/crates/aionui-db/src/repository/sqlite_team.rs +++ b/crates/aionui-db/src/repository/sqlite_team.rs @@ -23,8 +23,9 @@ impl ITeamRepository for SqliteTeamRepository { async fn create_team(&self, row: &TeamRow) -> Result<(), DbError> { sqlx::query( - "INSERT INTO teams (id, user_id, name, workspace, workspace_mode, agents, lead_agent_id, session_mode, agents_version, created_at, updated_at) \ - VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + "INSERT INTO teams (id, user_id, name, workspace, workspace_mode, agents, lead_agent_id, session_mode, agents_version, \ + source_channel, source_channel_id, source_chat_id, source_user_id, source_label, created_from, created_at, updated_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", ) .bind(&row.id) .bind(&row.user_id) @@ -35,6 +36,12 @@ impl ITeamRepository for SqliteTeamRepository { .bind(&row.lead_agent_id) .bind(&row.session_mode) .bind(&row.agents_version) + .bind(&row.source_channel) + .bind(&row.source_channel_id) + .bind(&row.source_chat_id) + .bind(&row.source_user_id) + .bind(&row.source_label) + .bind(&row.created_from) .bind(row.created_at) .bind(row.updated_at) .execute(&self.pool) diff --git a/crates/aionui-db/src/repository/sqlite_workspace_lease.rs b/crates/aionui-db/src/repository/sqlite_workspace_lease.rs new file mode 100644 index 000000000..6a9c6396a --- /dev/null +++ b/crates/aionui-db/src/repository/sqlite_workspace_lease.rs @@ -0,0 +1,125 @@ +use aionui_common::now_ms; +use sqlx::SqlitePool; + +use crate::error::DbError; +use crate::models::AgentWorkspaceLeaseRow; +use crate::repository::workspace_lease::{AgentWorkspaceLeaseUpdate, IAgentWorkspaceLeaseRepository}; + +#[derive(Clone, Debug)] +pub struct SqliteAgentWorkspaceLeaseRepository { + pool: SqlitePool, +} + +impl SqliteAgentWorkspaceLeaseRepository { + pub fn new(pool: SqlitePool) -> Self { + Self { pool } + } +} + +fn map_write_error(error: sqlx::Error) -> DbError { + if error + .as_database_error() + .and_then(|db| db.code()) + .is_some_and(|code| code == "2067") + { + DbError::Conflict("workspace lease already exists for this slot, path, or branch".into()) + } else { + DbError::Query(error) + } +} + +#[async_trait::async_trait] +impl IAgentWorkspaceLeaseRepository for SqliteAgentWorkspaceLeaseRepository { + async fn create(&self, row: &AgentWorkspaceLeaseRow) -> Result<(), DbError> { + sqlx::query( + "INSERT INTO agent_workspace_leases \ + (id, team_id, user_id, slot_id, workspace_mode, repository_path, worktree_path, branch_name, \ + base_commit, allowed_paths, lease_status, cleanup_status, conflict_files, last_error, \ + created_at, updated_at, released_at) \ + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + ) + .bind(&row.id) + .bind(&row.team_id) + .bind(&row.user_id) + .bind(&row.slot_id) + .bind(&row.workspace_mode) + .bind(&row.repository_path) + .bind(&row.worktree_path) + .bind(&row.branch_name) + .bind(&row.base_commit) + .bind(&row.allowed_paths) + .bind(&row.lease_status) + .bind(&row.cleanup_status) + .bind(&row.conflict_files) + .bind(&row.last_error) + .bind(row.created_at) + .bind(row.updated_at) + .bind(row.released_at) + .execute(&self.pool) + .await + .map_err(map_write_error)?; + Ok(()) + } + + async fn get(&self, lease_id: &str) -> Result, DbError> { + Ok(sqlx::query_as("SELECT * FROM agent_workspace_leases WHERE id = ?") + .bind(lease_id) + .fetch_optional(&self.pool) + .await?) + } + + async fn get_for_team_slot(&self, team_id: &str, slot_id: &str) -> Result, DbError> { + Ok( + sqlx::query_as("SELECT * FROM agent_workspace_leases WHERE team_id = ? AND slot_id = ?") + .bind(team_id) + .bind(slot_id) + .fetch_optional(&self.pool) + .await?, + ) + } + + async fn list_for_team(&self, team_id: &str) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT * FROM agent_workspace_leases WHERE team_id = ? ORDER BY slot_id ASC, created_at ASC", + ) + .bind(team_id) + .fetch_all(&self.pool) + .await?) + } + + async fn list_reconcile_candidates(&self) -> Result, DbError> { + Ok(sqlx::query_as( + "SELECT * FROM agent_workspace_leases \ + WHERE lease_status IN ('provisioning', 'active', 'cleanup_pending', 'conflict') \ + ORDER BY team_id ASC, slot_id ASC", + ) + .fetch_all(&self.pool) + .await?) + } + + async fn update(&self, lease_id: &str, update: &AgentWorkspaceLeaseUpdate) -> Result<(), DbError> { + let existing = self + .get(lease_id) + .await? + .ok_or_else(|| DbError::NotFound(format!("workspace lease {lease_id}")))?; + let lease_status = update.lease_status.as_ref().unwrap_or(&existing.lease_status); + let cleanup_status = update.cleanup_status.as_ref().unwrap_or(&existing.cleanup_status); + let conflict_files = update.conflict_files.as_ref().unwrap_or(&existing.conflict_files); + let last_error = update.last_error.clone().unwrap_or(existing.last_error); + let released_at = update.released_at.unwrap_or(existing.released_at); + sqlx::query( + "UPDATE agent_workspace_leases SET lease_status = ?, cleanup_status = ?, conflict_files = ?, \ + last_error = ?, released_at = ?, updated_at = ? WHERE id = ?", + ) + .bind(lease_status) + .bind(cleanup_status) + .bind(conflict_files) + .bind(last_error) + .bind(released_at) + .bind(now_ms()) + .bind(lease_id) + .execute(&self.pool) + .await?; + Ok(()) + } +} diff --git a/crates/aionui-db/src/repository/workspace_lease.rs b/crates/aionui-db/src/repository/workspace_lease.rs new file mode 100644 index 000000000..5940839a5 --- /dev/null +++ b/crates/aionui-db/src/repository/workspace_lease.rs @@ -0,0 +1,23 @@ +use aionui_common::TimestampMs; + +use crate::error::DbError; +use crate::models::AgentWorkspaceLeaseRow; + +#[derive(Debug, Clone, Default)] +pub struct AgentWorkspaceLeaseUpdate { + pub lease_status: Option, + pub cleanup_status: Option, + pub conflict_files: Option, + pub last_error: Option>, + pub released_at: Option>, +} + +#[async_trait::async_trait] +pub trait IAgentWorkspaceLeaseRepository: Send + Sync { + async fn create(&self, row: &AgentWorkspaceLeaseRow) -> Result<(), DbError>; + async fn get(&self, lease_id: &str) -> Result, DbError>; + async fn get_for_team_slot(&self, team_id: &str, slot_id: &str) -> Result, DbError>; + async fn list_for_team(&self, team_id: &str) -> Result, DbError>; + async fn list_reconcile_candidates(&self) -> Result, DbError>; + async fn update(&self, lease_id: &str, update: &AgentWorkspaceLeaseUpdate) -> Result<(), DbError>; +} diff --git a/crates/aionui-db/tests/approval_repository.rs b/crates/aionui-db/tests/approval_repository.rs new file mode 100644 index 000000000..c1c2008bf --- /dev/null +++ b/crates/aionui-db/tests/approval_repository.rs @@ -0,0 +1,116 @@ +use std::sync::Arc; + +use aionui_db::models::ApprovalRequestRow; +use aionui_db::{IApprovalRepository, SqliteApprovalRepository, init_database_memory}; + +async fn setup() -> (Arc, aionui_db::Database) { + let db = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO users (id, username, password_hash, created_at, updated_at) \ + VALUES ('user-1', 'developer', '', 1, 1), ('user-2', 'reviewer', '', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO conversations \ + (id, user_id, name, type, extra, pinned, created_at, updated_at) \ + VALUES ('conversation-1', 'user-1', 'Approval test', 'acp', '{}', 0, 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + (Arc::new(SqliteApprovalRepository::new(db.pool().clone())), db) +} + +fn approval(id: &str, expires_at: i64) -> ApprovalRequestRow { + ApprovalRequestRow { + id: id.into(), + requester_user_id: "user-1".into(), + project_id: None, + run_id: None, + task_id: None, + conversation_id: "conversation-1".into(), + agent_id: Some("claude-code".into()), + call_id: format!("call-{id}"), + action_type: "tool_call".into(), + command: Some("cargo test".into()), + working_directory: Some("/tmp/project".into()), + risk_level: "medium".into(), + options: r#"[{"label":"Allow","value":"allow"},{"label":"Reject","value":"reject"}]"#.into(), + status: "pending".into(), + approver_user_id: None, + source_channel: Some("telegram".into()), + source_user_id: Some("telegram-user-1".into()), + source_chat_id: Some("-1003977604085".into()), + source_thread_id: Some(5), + expires_at, + consumed_at: None, + created_at: 10, + updated_at: 10, + } +} + +#[tokio::test] +async fn approval_roundtrips_and_is_scoped_to_requester() { + let (repo, _db) = setup().await; + let row = approval("approval-1", 1_000); + repo.create(&row).await.unwrap(); + + assert_eq!(repo.get("approval-1").await.unwrap().unwrap().call_id, row.call_id); + assert!(repo.list_for_user("user-2", None).await.unwrap().is_empty()); + assert_eq!(repo.list_for_user("user-1", None).await.unwrap(), vec![row]); +} + +#[tokio::test] +async fn approval_consumption_is_atomic_and_single_use() { + let (repo, _db) = setup().await; + repo.create(&approval("approval-2", 1_000)).await.unwrap(); + + let left = Arc::clone(&repo); + let right = Arc::clone(&repo); + let (left, right) = tokio::join!( + left.consume("approval-2", "user-1", "approved", 100), + right.consume("approval-2", "user-1", "rejected", 100), + ); + let successes = [left.unwrap(), right.unwrap()] + .into_iter() + .filter(|updated| *updated) + .count(); + assert_eq!(successes, 1); + assert!(!repo.consume("approval-2", "user-1", "approved", 101).await.unwrap()); + + let stored = repo.get("approval-2").await.unwrap().unwrap(); + assert!(matches!(stored.status.as_str(), "approved" | "rejected")); + assert_eq!(stored.approver_user_id.as_deref(), Some("user-1")); + assert_eq!(stored.consumed_at, Some(100)); +} + +#[tokio::test] +async fn expired_approvals_cannot_be_consumed() { + let (repo, _db) = setup().await; + repo.create(&approval("approval-3", 99)).await.unwrap(); + + assert!(!repo.consume("approval-3", "user-1", "approved", 100).await.unwrap()); + assert_eq!(repo.mark_expired(100).await.unwrap(), 1); + assert_eq!(repo.get("approval-3").await.unwrap().unwrap().status, "expired"); +} + +#[tokio::test] +async fn conversation_and_call_are_idempotency_key() { + let (repo, _db) = setup().await; + let first = approval("approval-4", 1_000); + repo.create(&first).await.unwrap(); + let mut duplicate = approval("approval-5", 1_000); + duplicate.call_id = first.call_id.clone(); + + assert!(repo.create(&duplicate).await.is_err()); + assert_eq!( + repo.get_by_conversation_call("conversation-1", &first.call_id) + .await + .unwrap() + .unwrap() + .id, + "approval-4" + ); +} diff --git a/crates/aionui-db/tests/channel_repository.rs b/crates/aionui-db/tests/channel_repository.rs index 9febfbbb8..bbc117d2c 100644 --- a/crates/aionui-db/tests/channel_repository.rs +++ b/crates/aionui-db/tests/channel_repository.rs @@ -6,7 +6,10 @@ use std::sync::Arc; -use aionui_db::models::{AssistantSessionRow, AssistantUserRow, ChannelPluginRow, PairingCodeRow}; +use aionui_db::models::{ + AssistantSessionRow, AssistantUserRow, ChannelPluginRow, ChannelTopicModelOverrideRow, PairingCodeRow, + TelegramTopicBindingRow, +}; use aionui_db::{DbError, IChannelRepository, SqliteChannelRepository, UpdatePluginStatusParams, init_database_memory}; async fn repo() -> (Arc, aionui_db::Database) { @@ -52,11 +55,25 @@ fn make_session(id: &str, user_id: &str, chat_id: &str) -> AssistantSessionRow { conversation_id: None, workspace: None, chat_id: Some(chat_id.into()), + message_thread_id: None, + bound_agent_id: None, + bound_backend: None, + bound_provider_id: None, + bound_model: None, created_at: now, last_activity: now, } } +fn make_topic_session(id: &str, user_id: &str, chat_id: &str, thread_id: i64) -> AssistantSessionRow { + AssistantSessionRow { + message_thread_id: Some(thread_id), + bound_agent_id: Some("agent-a".into()), + bound_backend: Some("codex".into()), + ..make_session(id, user_id, chat_id) + } +} + fn make_pairing(code: &str, platform_uid: &str, expires_offset_ms: i64) -> PairingCodeRow { let now = aionui_common::now_ms(); PairingCodeRow { @@ -288,3 +305,87 @@ async fn users_ordered_by_authorized_at_desc() { assert_eq!(users[0].id, "u2"); // more recent first assert_eq!(users[1].id, "u1"); } + +#[tokio::test] +async fn telegram_topic_sessions_are_isolated_and_can_be_invalidated_together() { + let (repo, _db) = repo().await; + repo.create_user(&make_user("u1", "tg_1", "telegram")).await.unwrap(); + repo.create_user(&make_user("u2", "tg_2", "telegram")).await.unwrap(); + + let topic_3 = repo + .get_or_create_topic_session("u1", "group", 3, &make_topic_session("s1", "u1", "group", 3)) + .await + .unwrap(); + let topic_5 = repo + .get_or_create_topic_session("u1", "group", 5, &make_topic_session("s2", "u1", "group", 5)) + .await + .unwrap(); + let other_user_topic_3 = repo + .get_or_create_topic_session("u2", "group", 3, &make_topic_session("s3", "u2", "group", 3)) + .await + .unwrap(); + + assert_ne!(topic_3.id, topic_5.id); + assert_ne!(topic_3.id, other_user_topic_3.id); + + repo.delete_sessions_by_topic("group", 3).await.unwrap(); + assert!(repo.get_session(&topic_3.id).await.unwrap().is_none()); + assert!(repo.get_session(&other_user_topic_3.id).await.unwrap().is_none()); + assert!(repo.get_session(&topic_5.id).await.unwrap().is_some()); +} + +#[tokio::test] +async fn telegram_topic_binding_and_model_override_roundtrip() { + let (repo, _db) = repo().await; + let now = aionui_common::now_ms(); + repo.upsert_telegram_topic_binding(&TelegramTopicBindingRow { + chat_id: "group".into(), + message_thread_id: 3, + agent_id: "8e1acf31".into(), + bound_by_user_id: "admin".into(), + created_at: now, + updated_at: now, + }) + .await + .unwrap(); + assert_eq!( + repo.get_telegram_topic_binding("group", 3) + .await + .unwrap() + .unwrap() + .agent_id, + "8e1acf31" + ); + + repo.upsert_topic_model_override(&ChannelTopicModelOverrideRow { + platform: "telegram".into(), + internal_user_id: "u1".into(), + chat_id: "group".into(), + message_thread_id: 3, + agent_id: "8e1acf31".into(), + provider_id: "openai-codex".into(), + model: "gpt-5.3-codex".into(), + updated_at: now, + }) + .await + .unwrap(); + + let selected = repo + .get_topic_model_override("telegram", "u1", "group", 3) + .await + .unwrap() + .unwrap(); + assert_eq!(selected.model, "gpt-5.3-codex"); + assert!( + repo.get_topic_model_override("telegram", "u2", "group", 3) + .await + .unwrap() + .is_none() + ); + assert!( + repo.get_topic_model_override("telegram", "u1", "group", 5) + .await + .unwrap() + .is_none() + ); +} diff --git a/crates/aionui-db/tests/conversation_repository.rs b/crates/aionui-db/tests/conversation_repository.rs index 47c2eaab7..6384593f4 100644 --- a/crates/aionui-db/tests/conversation_repository.rs +++ b/crates/aionui-db/tests/conversation_repository.rs @@ -24,6 +24,12 @@ fn make_conversation(suffix: &str) -> ConversationRow { status: Some("pending".to_string()), source: Some("aionui".to_string()), channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: now, diff --git a/crates/aionui-db/tests/conversation_schema.rs b/crates/aionui-db/tests/conversation_schema.rs index 84451767a..605f093e7 100644 --- a/crates/aionui-db/tests/conversation_schema.rs +++ b/crates/aionui-db/tests/conversation_schema.rs @@ -67,10 +67,13 @@ async fn conversations_accepts_all_columns() { sqlx::query( "INSERT INTO conversations \ (id, user_id, name, type, extra, model, status, source, channel_chat_id, \ + source_channel, source_channel_id, source_chat_id, source_user_id, source_label, created_from, \ pinned, pinned_at, created_at, updated_at) \ VALUES ($1, $2, 'Full Chat', 'acp', '{\"backend\":\"claude\"}', \ '{\"providerId\":\"p1\",\"model\":\"claude-sonnet\"}', \ - 'running', 'telegram', 'user:123', 1, 1700000000000, 1000, 2000)", + 'running', 'telegram', 'user:123', \ + 'telegram', 'bot:main', 'chat:123', 'user:456', 'Telegram', 'telegram', \ + 1, 1700000000000, 1000, 2000)", ) .bind("conv_full") .bind(&user_id) @@ -88,6 +91,12 @@ async fn conversations_accepts_all_columns() { assert_eq!(row.get::("status"), "running"); assert_eq!(row.get::("source"), "telegram"); assert_eq!(row.get::("channel_chat_id"), "user:123"); + assert_eq!(row.get::("source_channel"), "telegram"); + assert_eq!(row.get::("source_channel_id"), "bot:main"); + assert_eq!(row.get::("source_chat_id"), "chat:123"); + assert_eq!(row.get::("source_user_id"), "user:456"); + assert_eq!(row.get::("source_label"), "Telegram"); + assert_eq!(row.get::("created_from"), "telegram"); assert_eq!(row.get::("pinned"), 1); assert_eq!(row.get::("pinned_at"), 1700000000000); } diff --git a/crates/aionui-db/tests/db_lifecycle.rs b/crates/aionui-db/tests/db_lifecycle.rs index 9decce6dd..ff2b70fea 100644 --- a/crates/aionui-db/tests/db_lifecycle.rs +++ b/crates/aionui-db/tests/db_lifecycle.rs @@ -2,6 +2,8 @@ use aionui_db::{ DatabaseInitOptions, init_database, init_database_memory, init_database_with_options, maybe_copy_legacy_database, }; use sqlx::Row; +use sqlx::migrate::Migrator; +use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions}; // -- T1.1 Initialization -- @@ -490,3 +492,89 @@ fn concurrent_init_database_does_not_panic_on_unique_conflict() { let lock = path.with_file_name("aionui-backend.db.migrate.lock"); assert!(lock.exists(), "advisory lock file should be present after migrate"); } + +#[tokio::test] +async fn legacy_roadmap_migration_ranges_are_reconciled_without_losing_topic_bindings() { + let dir = tempfile::tempdir().unwrap(); + let current_migration_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("migrations"); + + for (case_name, legacy_start, current_start, current_end, legacy_shift) in [ + ("original-partial", 17_i64, 28_i64, 29_i64, 11_i64), + ("original-full", 17_i64, 28_i64, 45_i64, 11_i64), + ("intermediate-full", 26_i64, 28_i64, 45_i64, 2_i64), + ] { + let case_dir = dir.path().join(case_name); + let migration_dir = case_dir.join("legacy-migrations"); + std::fs::create_dir_all(&migration_dir).unwrap(); + for entry in std::fs::read_dir(¤t_migration_dir).unwrap() { + let entry = entry.unwrap(); + let file_name = entry.file_name().to_string_lossy().into_owned(); + let version: i64 = file_name[..3].parse().unwrap(); + let legacy_name = if version < legacy_start { + file_name + } else if (current_start..=current_end).contains(&version) { + format!("{:03}_{}", version - legacy_shift, &file_name[4..]) + } else { + continue; + }; + let legacy_path = migration_dir.join(legacy_name); + if legacy_start == 17 && matches!(version, 31 | 32) { + let mut legacy_contents = std::fs::read(entry.path()).unwrap(); + legacy_contents.push(b'\n'); + std::fs::write(legacy_path, legacy_contents).unwrap(); + } else { + std::fs::copy(entry.path(), legacy_path).unwrap(); + } + } + + let path = case_dir.join("legacy-roadmap.db"); + let pool = SqlitePoolOptions::new() + .max_connections(1) + .connect_with(SqliteConnectOptions::new().filename(&path).create_if_missing(true)) + .await + .unwrap(); + Migrator::new(migration_dir).await.unwrap().run(&pool).await.unwrap(); + sqlx::query( + "INSERT INTO telegram_topic_bindings \ + (chat_id, message_thread_id, agent_id, bound_by_user_id, created_at, updated_at) \ + VALUES ('-1003977604085', 3, 'codex-agent', 'admin-user', 1, 1)", + ) + .execute(&pool) + .await + .unwrap(); + pool.close().await; + + let db = init_database(&path).await.unwrap(); + let migrations: Vec<(i64, String)> = sqlx::query_as( + "SELECT version, description FROM _sqlx_migrations WHERE version IN (17, 18, 26, 27, 28, 29) ORDER BY version", + ) + .fetch_all(db.pool()) + .await + .unwrap(); + assert_eq!( + migrations, + vec![ + (17, "drop conversation assistant identity snapshot".to_string()), + (18, "reset builtin assistant enabled".to_string()), + (26, "clear bridge agent command override".to_string()), + (27, "provider model settings".to_string()), + (28, "source channel metadata".to_string()), + (29, "telegram topic single agent".to_string()), + ] + ); + let migration_count: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM _sqlx_migrations WHERE success = 1") + .fetch_one(db.pool()) + .await + .unwrap(); + assert_eq!(migration_count.0, 46); + + let binding: (String,) = sqlx::query_as( + "SELECT agent_id FROM telegram_topic_bindings WHERE chat_id = '-1003977604085' AND message_thread_id = 3", + ) + .fetch_one(db.pool()) + .await + .unwrap(); + assert_eq!(binding.0, "codex-agent"); + db.close().await; + } +} diff --git a/crates/aionui-db/tests/delivery_repository.rs b/crates/aionui-db/tests/delivery_repository.rs new file mode 100644 index 000000000..eddc62216 --- /dev/null +++ b/crates/aionui-db/tests/delivery_repository.rs @@ -0,0 +1,93 @@ +use aionui_db::models::{DevelopmentCiCheckRow, DevelopmentDeliveryRow}; +use aionui_db::{IDevelopmentRepository, SqliteDevelopmentRepository, init_database_memory}; + +async fn setup() -> (SqliteDevelopmentRepository, aionui_db::Database) { + let db = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO projects (id, user_id, name, local_path, project_type, created_at, updated_at) \ + VALUES ('project-delivery', 'system_default_user', 'Delivery', '/tmp/delivery', 'single', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO development_runs \ + (id, user_id, project_id, execution_mode, status, request_summary, acceptance_criteria, created_at, updated_at) \ + VALUES ('run-delivery', 'system_default_user', 'project-delivery', 'single', 'reviewing', 'Ship', '[]', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + (SqliteDevelopmentRepository::new(db.pool().clone()), db) +} + +fn delivery() -> DevelopmentDeliveryRow { + DevelopmentDeliveryRow { + id: "delivery-1".into(), + run_id: "run-delivery".into(), + project_id: "project-delivery".into(), + user_id: "system_default_user".into(), + provider: "github".into(), + repository: Some("example/aion".into()), + branch: "aion/run/run-delivery/delivery".into(), + base_branch: "main".into(), + commit_sha: Some("abc123".into()), + status: "prepared".into(), + push_status: "pending".into(), + pr_number: None, + pr_url: None, + pr_status: "not_created".into(), + ci_status: "not_started".into(), + review_status: "pending".into(), + merge_status: "blocked".into(), + report_json: "{}".into(), + last_error: None, + created_at: 10, + updated_at: 10, + } +} + +#[tokio::test] +async fn delivery_is_idempotent_per_run_and_owner_scoped() { + let (repo, _db) = setup().await; + repo.upsert_delivery(&delivery()).await.unwrap(); + repo.upsert_delivery(&delivery()).await.unwrap(); + + assert!(repo.get_delivery("other-user", "run-delivery").await.unwrap().is_none()); + let stored = repo + .get_delivery("system_default_user", "run-delivery") + .await + .unwrap() + .unwrap(); + assert_eq!(stored.commit_sha.as_deref(), Some("abc123")); +} + +#[tokio::test] +async fn ci_checks_upsert_and_keep_rework_link() { + let (repo, _db) = setup().await; + repo.upsert_delivery(&delivery()).await.unwrap(); + let mut check = DevelopmentCiCheckRow { + id: "check-1".into(), + delivery_id: "delivery-1".into(), + provider_check_id: "provider-1".into(), + name: "test".into(), + status: "failed".into(), + details_url: Some("https://example.invalid/check/1".into()), + summary: Some("unit tests failed".into()), + rework_task_id: Some("task-rework".into()), + started_at: Some(10), + completed_at: Some(20), + created_at: 10, + updated_at: 20, + }; + repo.upsert_ci_check(&check).await.unwrap(); + check.status = "passed".into(); + check.summary = Some("retry passed".into()); + check.updated_at = 30; + repo.upsert_ci_check(&check).await.unwrap(); + + let rows = repo.list_ci_checks("delivery-1").await.unwrap(); + assert_eq!(rows.len(), 1); + assert_eq!(rows[0].status, "passed"); + assert_eq!(rows[0].rework_task_id.as_deref(), Some("task-rework")); +} diff --git a/crates/aionui-db/tests/development_delivery_schema.rs b/crates/aionui-db/tests/development_delivery_schema.rs new file mode 100644 index 000000000..ca3f3e39c --- /dev/null +++ b/crates/aionui-db/tests/development_delivery_schema.rs @@ -0,0 +1,31 @@ +use aionui_db::init_database_memory; + +#[tokio::test] +async fn phase_five_migration_creates_delivery_and_ci_tables() { + let db = init_database_memory().await.unwrap(); + for table in ["development_deliveries", "development_ci_checks"] { + let exists: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name = ?") + .bind(table) + .fetch_one(db.pool()) + .await + .unwrap(); + assert_eq!(exists, 1, "missing {table}"); + } +} + +#[tokio::test] +async fn delivery_is_unique_per_run_and_ci_check_per_provider_id() { + let db = init_database_memory().await.unwrap(); + let delivery_unique: i64 = + sqlx::query_scalar("SELECT COUNT(*) FROM pragma_index_list('development_deliveries') WHERE \"unique\" = 1") + .fetch_one(db.pool()) + .await + .unwrap(); + let checks_unique: i64 = + sqlx::query_scalar("SELECT COUNT(*) FROM pragma_index_list('development_ci_checks') WHERE \"unique\" = 1") + .fetch_one(db.pool()) + .await + .unwrap(); + assert!(delivery_unique >= 1); + assert!(checks_unique >= 1); +} diff --git a/crates/aionui-db/tests/development_operations_repository.rs b/crates/aionui-db/tests/development_operations_repository.rs new file mode 100644 index 000000000..ccd9b0c75 --- /dev/null +++ b/crates/aionui-db/tests/development_operations_repository.rs @@ -0,0 +1,201 @@ +use aionui_db::models::{ + DevelopmentAlertRow, DevelopmentAuditEventRow, DevelopmentPolicyRow, DevelopmentRecoveryRecordRow, + DevelopmentUsageEventRow, +}; +use aionui_db::{IDevelopmentOperationsRepository, SqliteDevelopmentOperationsRepository, init_database_memory}; + +async fn setup() -> (SqliteDevelopmentOperationsRepository, aionui_db::Database) { + let db = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO projects (id, user_id, name, local_path, project_type, created_at, updated_at) \ + VALUES ('project-ops', 'system_default_user', 'Operations', '/tmp/operations', 'single', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + (SqliteDevelopmentOperationsRepository::new(db.pool().clone()), db) +} + +fn policy() -> DevelopmentPolicyRow { + DevelopmentPolicyRow { + id: "policy-1".into(), + user_id: "system_default_user".into(), + project_id: "project-ops".into(), + isolation_mode: "docker".into(), + container_image: Some("node:24-alpine".into()), + devcontainer_config_path: None, + container_cpu_millis: 1000, + container_memory_mb: 2048, + container_pids_limit: 256, + network_mode: "none".into(), + allowed_secret_keys_json: "[\"NPM_TOKEN\"]".into(), + allowed_commands_json: "[\"cargo\"]".into(), + protected_paths_json: "[\".env\"]".into(), + allowed_network_hosts_json: "[]".into(), + protected_branches_json: "[\"main\"]".into(), + dangerous_confirmation_count: 2, + max_duration_ms: 14_400_000, + max_parallel_agents: 4, + max_retries: 3, + max_cost_microunits: 10_000, + max_total_tokens: 0, + fallback_model: None, + alert_percent: 80, + over_limit_action: "pause".into(), + created_at: 1, + updated_at: 1, + } +} + +#[tokio::test] +async fn policy_is_upserted_and_owner_scoped() { + let (repo, _db) = setup().await; + repo.upsert_policy(&policy()).await.unwrap(); + let mut changed = policy(); + changed.isolation_mode = "host".into(); + changed.updated_at = 2; + repo.upsert_policy(&changed).await.unwrap(); + + assert!(repo.get_policy("other", "project-ops").await.unwrap().is_none()); + let stored = repo + .get_policy("system_default_user", "project-ops") + .await + .unwrap() + .unwrap(); + assert_eq!(stored.id, "policy-1"); + assert_eq!(stored.isolation_mode, "host"); + assert_eq!(stored.created_at, 1); +} + +#[tokio::test] +async fn usage_is_append_only_and_summarized_by_owner_and_run() { + let (repo, db) = setup().await; + sqlx::query( + "INSERT INTO development_runs \ + (id, user_id, project_id, execution_mode, status, request_summary, acceptance_criteria, created_at, updated_at) \ + VALUES ('run-ops', 'system_default_user', 'project-ops', 'single', 'running', 'Operate', '[]', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + for (id, duration, cost, retries) in [("usage-1", 120_i64, 50_i64, 0_i64), ("usage-2", 80, 25, 1)] { + repo.append_usage(&DevelopmentUsageEventRow { + id: id.into(), + user_id: "system_default_user".into(), + project_id: "project-ops".into(), + run_id: Some("run-ops".into()), + task_id: None, + usage_type: "quality_gate".into(), + source: "platform".into(), + confidence: "measured".into(), + input_tokens: 0, + output_tokens: 0, + cost_microunits: cost, + duration_ms: duration, + retry_count: retries, + metadata_json: "{}".into(), + created_at: duration, + }) + .await + .unwrap(); + } + + let summary = repo + .summarize_usage("system_default_user", "project-ops", Some("run-ops")) + .await + .unwrap(); + assert_eq!(summary.event_count, 2); + assert_eq!(summary.duration_ms, 200); + assert_eq!(summary.cost_microunits, 75); + assert_eq!(summary.retry_count, 1); + + let mutation = sqlx::query("UPDATE development_usage_events SET cost_microunits = 0 WHERE id = 'usage-1'") + .execute(db.pool()) + .await; + assert!(mutation.is_err(), "usage ledger must reject updates"); +} + +#[tokio::test] +async fn audit_alert_and_recovery_records_are_deterministic() { + let (repo, _db) = setup().await; + repo.append_audit(&DevelopmentAuditEventRow { + id: "audit-1".into(), + user_id: "system_default_user".into(), + actor_type: "user".into(), + actor_id: "system_default_user".into(), + action: "policy.update".into(), + target_type: "project".into(), + target_id: "project-ops".into(), + project_id: "project-ops".into(), + run_id: None, + task_id: None, + result: "success".into(), + redacted_payload_json: "{\"token\":\"[REDACTED]\"}".into(), + created_at: 1, + }) + .await + .unwrap(); + + let mut alert = DevelopmentAlertRow { + id: "alert-1".into(), + user_id: "system_default_user".into(), + project_id: "project-ops".into(), + run_id: None, + alert_type: "budget".into(), + severity: "warning".into(), + status: "open".into(), + message: "80% consumed".into(), + dedupe_key: "budget:project-ops".into(), + created_at: 1, + updated_at: 1, + resolved_at: None, + }; + repo.upsert_alert(&alert).await.unwrap(); + alert.id = "alert-ignored".into(); + alert.message = "100% consumed".into(); + alert.severity = "critical".into(); + alert.updated_at = 2; + repo.upsert_alert(&alert).await.unwrap(); + + let alerts = repo + .list_alerts("system_default_user", "project-ops", None, true) + .await + .unwrap(); + assert_eq!(alerts.len(), 1); + assert_eq!(alerts[0].id, "alert-1"); + assert_eq!(alerts[0].message, "100% consumed"); + + repo.append_recovery(&DevelopmentRecoveryRecordRow { + id: "recovery-1".into(), + user_id: "system_default_user".into(), + project_id: "project-ops".into(), + run_id: None, + recovery_key: "project:project-ops:git".into(), + finding: "git repository unavailable".into(), + decision: "manual_required".into(), + status_before: None, + status_after: None, + details_json: "{}".into(), + created_at: 3, + }) + .await + .unwrap(); + repo.append_recovery(&DevelopmentRecoveryRecordRow { + id: "recovery-2".into(), + ..repo + .list_recovery("system_default_user", "project-ops", None, 10) + .await + .unwrap()[0] + .clone() + }) + .await + .unwrap(); + assert_eq!( + repo.list_recovery("system_default_user", "project-ops", None, 10) + .await + .unwrap() + .len(), + 1, + "recovery_key must be idempotent", + ); +} diff --git a/crates/aionui-db/tests/development_operations_schema.rs b/crates/aionui-db/tests/development_operations_schema.rs new file mode 100644 index 000000000..1b2a9b39c --- /dev/null +++ b/crates/aionui-db/tests/development_operations_schema.rs @@ -0,0 +1,90 @@ +use aionui_db::init_database_memory; + +#[tokio::test] +async fn phase_six_migration_creates_operations_tables_and_constraints() { + let db = init_database_memory().await.unwrap(); + for table in [ + "development_policies", + "development_usage_events", + "development_audit_events", + "development_alerts", + "development_recovery_records", + ] { + let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name = ?") + .bind(table) + .fetch_one(db.pool()) + .await + .unwrap(); + assert_eq!(count, 1, "missing table {table}"); + } + for column in ["isolation_mode", "execution_id"] { + let count: i64 = + sqlx::query_scalar("SELECT COUNT(*) FROM pragma_table_info('quality_gate_runs') WHERE name = ?") + .bind(column) + .fetch_one(db.pool()) + .await + .unwrap(); + assert_eq!(count, 1, "missing quality gate column {column}"); + } + + seed_project(&db).await; + let invalid_mode = sqlx::query( + "INSERT INTO development_policies \ + (id, user_id, project_id, isolation_mode, created_at, updated_at) \ + VALUES ('policy-invalid', 'system_default_user', 'project-ops', 'virtual-machine', 1, 1)", + ) + .execute(db.pool()) + .await; + assert!(invalid_mode.is_err()); + + let invalid_secret_payload = sqlx::query( + "INSERT INTO development_policies \ + (id, user_id, project_id, allowed_secret_keys_json, created_at, updated_at) \ + VALUES ('policy-secret', 'system_default_user', 'project-ops', '{\"TOKEN\":\"secret\"}', 1, 1)", + ) + .execute(db.pool()) + .await; + assert!(invalid_secret_payload.is_err()); +} + +async fn seed_project(db: &aionui_db::Database) { + sqlx::query( + "INSERT INTO projects (id, user_id, name, local_path, project_type, created_at, updated_at) \ + VALUES ('project-ops', 'system_default_user', 'Operations', '/tmp/operations', 'single', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); +} + +#[tokio::test] +async fn alert_dedupe_and_usage_dimensions_are_enforced() { + let db = init_database_memory().await.unwrap(); + seed_project(&db).await; + + sqlx::query( + "INSERT INTO development_alerts \ + (id, user_id, project_id, alert_type, severity, status, message, dedupe_key, created_at, updated_at) \ + VALUES ('alert-1', 'system_default_user', 'project-ops', 'budget', 'warning', 'open', 'near limit', 'budget:project-ops', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + let duplicate = sqlx::query( + "INSERT INTO development_alerts \ + (id, user_id, project_id, alert_type, severity, status, message, dedupe_key, created_at, updated_at) \ + VALUES ('alert-2', 'system_default_user', 'project-ops', 'budget', 'warning', 'open', 'near limit', 'budget:project-ops', 2, 2)", + ) + .execute(db.pool()) + .await; + assert!(duplicate.is_err()); + + let negative_usage = sqlx::query( + "INSERT INTO development_usage_events \ + (id, user_id, project_id, usage_type, source, confidence, duration_ms, created_at) \ + VALUES ('usage-invalid', 'system_default_user', 'project-ops', 'quality_gate', 'platform', 'measured', -1, 1)", + ) + .execute(db.pool()) + .await; + assert!(negative_usage.is_err()); +} diff --git a/crates/aionui-db/tests/development_quality_schema.rs b/crates/aionui-db/tests/development_quality_schema.rs new file mode 100644 index 000000000..da7d9bbc5 --- /dev/null +++ b/crates/aionui-db/tests/development_quality_schema.rs @@ -0,0 +1,68 @@ +use aionui_db::init_database_memory; + +#[tokio::test] +async fn phase_three_migration_creates_evidence_and_gate_tables() { + let db = init_database_memory().await.unwrap(); + for table in [ + "development_runs", + "task_artifacts", + "quality_gate_runs", + "review_findings", + "development_run_roles", + ] { + let exists: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = ?") + .bind(table) + .fetch_one(db.pool()) + .await + .unwrap(); + assert_eq!(exists, 1, "missing table {table}"); + } +} + +#[tokio::test] +async fn development_run_roles_are_limited_to_separated_quality_roles() { + let db = init_database_memory().await.unwrap(); + let schema: String = + sqlx::query_scalar("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'development_run_roles'") + .fetch_one(db.pool()) + .await + .unwrap(); + for role in ["implementer", "tester", "reviewer", "integrator"] { + assert!(schema.contains(role)); + } +} + +#[tokio::test] +async fn team_tasks_accept_expanded_states_and_quality_columns() { + let db = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO team_tasks \ + (id, team_id, status, subject, blocked_by, blocks, acceptance_criteria, task_type, risk_level, \ + review_status, verification_status, created_at, updated_at) \ + VALUES ('task-1', 'team-1', 'review', 'Review me', '[]', '[]', '[\"criterion\"]', \ + 'implementation', 'high', 'in_review', 'passed', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + + let row: (String, String, String, String) = sqlx::query_as( + "SELECT status, acceptance_criteria, review_status, verification_status FROM team_tasks WHERE id = 'task-1'", + ) + .fetch_one(db.pool()) + .await + .unwrap(); + assert_eq!(row.0, "review"); + assert_eq!(row.1, "[\"criterion\"]"); + assert_eq!(row.2, "in_review"); + assert_eq!(row.3, "passed"); + + let invalid = sqlx::query( + "INSERT INTO team_tasks \ + (id, team_id, status, subject, blocked_by, blocks, created_at, updated_at) \ + VALUES ('task-bad', 'team-1', 'invented', 'Bad', '[]', '[]', 1, 1)", + ) + .execute(db.pool()) + .await; + assert!(invalid.is_err()); +} diff --git a/crates/aionui-db/tests/development_repository.rs b/crates/aionui-db/tests/development_repository.rs new file mode 100644 index 000000000..a91750459 --- /dev/null +++ b/crates/aionui-db/tests/development_repository.rs @@ -0,0 +1,233 @@ +use aionui_db::models::{ + DevelopmentRunRoleRow, DevelopmentRunRow, DevelopmentTaskRow, ProjectRow, QualityGateRunRow, ReviewFindingRow, + TaskArtifactRow, +}; +use aionui_db::{ + IDevelopmentRepository, IProjectRepository, SqliteDevelopmentRepository, SqliteProjectRepository, + init_database_memory, +}; + +async fn setup() -> (SqliteDevelopmentRepository, aionui_db::Database) { + let db = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO users (id, username, password_hash, created_at, updated_at) \ + VALUES ('user-1', 'developer', '', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + SqliteProjectRepository::new(db.pool().clone()) + .create(&ProjectRow { + id: "project-1".into(), + user_id: "user-1".into(), + name: "Project".into(), + local_path: "/tmp/project".into(), + repository_url: None, + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + (SqliteDevelopmentRepository::new(db.pool().clone()), db) +} + +fn run() -> DevelopmentRunRow { + DevelopmentRunRow { + id: "run-1".into(), + user_id: "user-1".into(), + project_id: "project-1".into(), + team_id: Some("team-1".into()), + source_channel: Some("webui".into()), + source_user_id: None, + execution_mode: "team".into(), + status: "running".into(), + request_summary: "Implement feature".into(), + acceptance_criteria: r#"["tests pass"]"#.into(), + baseline_commit: Some("abc123".into()), + integration_branch: Some("aion/run/run-1/integration".into()), + started_at: Some(2), + finished_at: None, + created_at: 1, + updated_at: 2, + } +} + +#[tokio::test] +async fn run_is_scoped_to_owner_and_updates_status() { + let (repo, _db) = setup().await; + repo.create_run(&run()).await.unwrap(); + assert!(repo.get_run("run-1", "other").await.unwrap().is_none()); + assert_eq!(repo.list_runs("user-1", Some("project-1")).await.unwrap().len(), 1); + + repo.update_run_status("run-1", "user-1", "verifying", None) + .await + .unwrap(); + assert_eq!( + repo.get_run("run-1", "user-1").await.unwrap().unwrap().status, + "verifying" + ); +} + +#[tokio::test] +async fn run_status_compare_and_set_rejects_stale_versions() { + let (repo, _db) = setup().await; + repo.create_run(&run()).await.unwrap(); + let snapshot = repo.get_run("run-1", "user-1").await.unwrap().unwrap(); + assert!( + repo.update_run_status_if_current("run-1", "user-1", &snapshot.status, snapshot.updated_at, "paused", None,) + .await + .unwrap() + ); + assert!( + !repo + .update_run_status_if_current( + "run-1", + "user-1", + &snapshot.status, + snapshot.updated_at, + "succeeded", + Some(10), + ) + .await + .unwrap() + ); + let persisted = repo.get_run("run-1", "user-1").await.unwrap().unwrap(); + assert_eq!(persisted.status, "paused"); + assert!(persisted.updated_at > snapshot.updated_at); +} + +#[tokio::test] +async fn artifacts_gates_and_findings_roundtrip_by_task() { + let (repo, db) = setup().await; + repo.create_run(&run()).await.unwrap(); + sqlx::query( + "INSERT INTO team_tasks (id, team_id, run_id, subject, blocked_by, blocks, created_at, updated_at) \ + VALUES ('task-1', 'team-1', 'run-1', 'Task', '[]', '[]', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + repo.create_artifact(&TaskArtifactRow { + id: "artifact-1".into(), + run_id: "run-1".into(), + task_id: Some("task-1".into()), + artifact_type: "test".into(), + path_or_uri: "artifacts/test.log".into(), + checksum: "sha256:1".into(), + producer_agent_id: Some("slot-1".into()), + metadata: None, + created_at: 3, + }) + .await + .unwrap(); + repo.create_gate(&QualityGateRunRow { + id: "gate-1".into(), + run_id: "run-1".into(), + task_id: Some("task-1".into()), + gate_type: "unit_test".into(), + command: "cargo test".into(), + working_directory: "/tmp/worktree".into(), + exit_code: Some(0), + status: "passed".into(), + stdout_artifact_id: Some("artifact-1".into()), + stderr_artifact_id: None, + duration_ms: Some(10), + isolation_mode: "host".into(), + execution_id: Some("gate-1".into()), + required: true, + started_at: Some(3), + finished_at: Some(4), + created_at: 3, + }) + .await + .unwrap(); + repo.create_finding(&ReviewFindingRow { + id: "finding-1".into(), + run_id: "run-1".into(), + task_id: "task-1".into(), + reviewer_agent_id: "slot-review".into(), + producer_agent_id: Some("slot-1".into()), + severity: "major".into(), + file_path: Some("src/lib.rs".into()), + line_number: Some(10), + reason: "Bug".into(), + suggestion: Some("Fix".into()), + status: "open".into(), + created_at: 4, + updated_at: 4, + }) + .await + .unwrap(); + + assert_eq!(repo.list_artifacts("run-1", Some("task-1")).await.unwrap().len(), 1); + assert_eq!( + repo.list_gates("run-1", Some("task-1")).await.unwrap()[0].status, + "passed" + ); + assert_eq!( + repo.list_findings("run-1", "task-1").await.unwrap()[0].severity, + "major" + ); + repo.update_finding_status("run-1", "finding-1", "resolved") + .await + .unwrap(); + assert_eq!( + repo.list_findings("run-1", "task-1").await.unwrap()[0].status, + "resolved" + ); +} + +#[tokio::test] +async fn development_tasks_roundtrip_with_quality_state() { + let (repo, _db) = setup().await; + repo.create_run(&run()).await.unwrap(); + repo.create_task(&DevelopmentTaskRow { + id: "task-2".into(), + team_id: "team-1".into(), + run_id: Some("run-1".into()), + subject: "Implement".into(), + description: None, + status: "ready".into(), + owner: Some("slot-1".into()), + blocked_by: "[]".into(), + blocks: "[]".into(), + metadata: None, + acceptance_criteria: r#"["tests pass"]"#.into(), + task_type: "implementation".into(), + risk_level: "high".into(), + assigned_workspace_lease_id: None, + review_status: "pending".into(), + verification_status: "pending".into(), + created_at: 2, + updated_at: 2, + }) + .await + .unwrap(); + + assert_eq!(repo.list_tasks("run-1").await.unwrap().len(), 1); + repo.update_task_state("run-1", "task-2", "review", "in_review", "passed") + .await + .unwrap(); + let task = repo.get_task("run-1", "task-2").await.unwrap().unwrap(); + assert_eq!(task.status, "review"); + assert_eq!(task.review_status, "in_review"); + assert_eq!(task.verification_status, "passed"); +} + +#[tokio::test] +async fn development_roles_are_idempotent_and_run_scoped() { + let (repo, _db) = setup().await; + repo.create_run(&run()).await.unwrap(); + let role = DevelopmentRunRoleRow { + run_id: "run-1".into(), + slot_id: "reviewer-slot".into(), + role: "reviewer".into(), + assigned_at: 2, + }; + repo.assign_role(&role).await.unwrap(); + repo.assign_role(&role).await.unwrap(); + assert_eq!(repo.list_roles("run-1").await.unwrap(), vec![role]); + assert!(repo.list_roles("other-run").await.unwrap().is_empty()); +} diff --git a/crates/aionui-db/tests/project_repository.rs b/crates/aionui-db/tests/project_repository.rs new file mode 100644 index 000000000..c1d3b9ba0 --- /dev/null +++ b/crates/aionui-db/tests/project_repository.rs @@ -0,0 +1,267 @@ +use std::sync::Arc; + +use aionui_db::models::{ + ProjectCommandProfileRow, ProjectKnowledgeContextRow, ProjectKnowledgeFactRow, ProjectKnowledgeIndexRow, + ProjectRepositoryFactsRow, ProjectRow, ProjectRuntimeProfileRow, +}; +use aionui_db::{DbError, IProjectRepository, SqliteProjectRepository, UpdateProjectParams, init_database_memory}; + +const USER: &str = "system_default_user"; + +async fn repo() -> (Arc, aionui_db::Database) { + let db = init_database_memory().await.unwrap(); + let repo = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + (repo, db) +} + +fn project(id: &str, path: &str) -> ProjectRow { + ProjectRow { + id: id.into(), + user_id: USER.into(), + name: format!("Project {id}"), + local_path: path.into(), + repository_url: Some(format!("https://example.com/{id}.git")), + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 100, + updated_at: 100, + } +} + +#[tokio::test] +async fn project_crud_is_scoped_to_owner() { + let (repo, _db) = repo().await; + repo.create(&project("p1", "/tmp/p1")).await.unwrap(); + + assert!(repo.get_for_user("p1", "other-user").await.unwrap().is_none()); + assert_eq!(repo.list_for_user(USER).await.unwrap().len(), 1); + + let updated = repo + .update_for_user( + "p1", + USER, + &UpdateProjectParams { + name: Some("Renamed".into()), + repository_url: Some(None), + ..Default::default() + }, + ) + .await + .unwrap(); + assert_eq!(updated.name, "Renamed"); + assert_eq!(updated.repository_url, None); + + assert!(!repo.delete_for_user("p1", "other-user").await.unwrap()); + assert!(repo.delete_for_user("p1", USER).await.unwrap()); +} + +#[tokio::test] +async fn duplicate_local_path_for_same_owner_returns_conflict() { + let (repo, _db) = repo().await; + repo.create(&project("p1", "/tmp/shared")).await.unwrap(); + + let error = repo.create(&project("p2", "/tmp/shared")).await.unwrap_err(); + assert!(matches!(error, DbError::Conflict(_))); +} + +#[tokio::test] +async fn project_profiles_roundtrip() { + let (repo, _db) = repo().await; + repo.create(&project("p1", "/tmp/p1")).await.unwrap(); + + repo.upsert_command_profile(&ProjectCommandProfileRow { + project_id: "p1".into(), + install_command: Some("bun install".into()), + format_command: Some("bunx oxfmt".into()), + lint_command: None, + typecheck_command: Some("bunx tsc --noEmit".into()), + unit_test_command: Some("bun test".into()), + integration_test_command: None, + e2e_command: None, + build_command: Some("bun run build".into()), + security_scan_command: None, + command_timeout_seconds: 600, + updated_at: 200, + }) + .await + .unwrap(); + repo.upsert_runtime_profile(&ProjectRuntimeProfileRow { + project_id: "p1".into(), + environment_kind: "local".into(), + language: Some("typescript".into()), + package_manager: Some("bun".into()), + runtime_version: None, + env_keys: r#"["NODE_ENV"]"#.into(), + metadata: r#"{"monorepo":false}"#.into(), + updated_at: 200, + }) + .await + .unwrap(); + + let command = repo.get_command_profile("p1", USER).await.unwrap().unwrap(); + let runtime = repo.get_runtime_profile("p1", USER).await.unwrap().unwrap(); + assert_eq!(command.command_timeout_seconds, 600); + assert_eq!(runtime.package_manager.as_deref(), Some("bun")); +} + +#[tokio::test] +async fn resource_binding_replaces_the_previous_project_for_same_owner() { + let (repo, _db) = repo().await; + repo.create(&project("p1", "/tmp/p1")).await.unwrap(); + repo.create(&project("p2", "/tmp/p2")).await.unwrap(); + + repo.bind_resource("p1", USER, "conversation", "c1").await.unwrap(); + repo.bind_resource("p2", USER, "conversation", "c1").await.unwrap(); + + let linked = repo + .get_for_resource(USER, "conversation", "c1") + .await + .unwrap() + .unwrap(); + assert_eq!(linked.id, "p2"); + assert!(repo.list_resource_links("p1", USER).await.unwrap().is_empty()); + assert_eq!(repo.list_resource_links("p2", USER).await.unwrap().len(), 1); +} + +#[tokio::test] +async fn repository_facts_roundtrip_without_exposing_secret_values() { + let (repo, _db) = repo().await; + repo.create(&project("p1", "/tmp/p1")).await.unwrap(); + repo.upsert_repository_facts(&ProjectRepositoryFactsRow { + project_id: "p1".into(), + repository_url: Some("ssh://git@example.test/org/repo.git".into()), + default_branch: Some("main".into()), + baseline_commit: Some("abc123".into()), + repository_dirty: true, + dirty_worktree_choice: "snapshot".into(), + dirty_snapshot_ref: Some("/managed/_snapshots/one".into()), + credential_reference: Some("vault:github-production".into()), + detected_languages_json: r#"["rust"]"#.into(), + detected_package_managers_json: r#"["cargo"]"#.into(), + detected_rules_files_json: r#"["AGENTS.md"]"#.into(), + monorepo_packages_json: r#"["crates/demo"]"#.into(), + submodules_json: "[]".into(), + lfs_detected: true, + detected_at: 300, + }) + .await + .unwrap(); + + let stored = repo.get_repository_facts("p1", USER).await.unwrap().unwrap(); + assert_eq!(stored.baseline_commit.as_deref(), Some("abc123")); + assert_eq!(stored.credential_reference.as_deref(), Some("vault:github-production")); + assert!(!serde_json::to_string(&stored).unwrap().contains("private-token")); + assert!(repo.get_repository_facts("p1", "other-user").await.unwrap().is_none()); +} + +#[tokio::test] +async fn knowledge_generation_and_context_are_atomic_and_owner_scoped() { + let (repo, _db) = repo().await; + repo.create(&project("p1", "/tmp/p1")).await.unwrap(); + let index = ProjectKnowledgeIndexRow { + project_id: "p1".into(), + provider: "codebase-memory".into(), + provider_project_name: "aionui-project-p1".into(), + provider_version: Some("0.9.0".into()), + status: "healthy".into(), + generation: 1, + source_commit: Some("abc123".into()), + indexed_at: Some(400), + changed_paths_json: r#"["src/lib.rs"]"#.into(), + error_category: None, + updated_at: 400, + }; + let facts = vec![ProjectKnowledgeFactRow { + id: "fact-1".into(), + project_id: "p1".into(), + generation: 1, + kind: "symbol".into(), + name: "run".into(), + qualified_name: Some("app.run".into()), + source_path: "src/lib.rs".into(), + source_line: Some(9), + indexed_at: 400, + }]; + repo.commit_knowledge_generation(&index, &facts).await.unwrap(); + + assert_eq!(repo.get_knowledge_index("p1", USER).await.unwrap(), Some(index)); + assert_eq!(repo.list_knowledge_facts("p1", USER).await.unwrap(), facts); + assert!(repo.get_knowledge_index("p1", "other-user").await.unwrap().is_none()); + assert!(repo.list_knowledge_facts("p1", "other-user").await.unwrap().is_empty()); + + let context = ProjectKnowledgeContextRow { + id: "context-1".into(), + project_id: "p1".into(), + provider_project_name: "aionui-project-p1".into(), + generation: 1, + query: "change run".into(), + symbols_json: r#"["app.run"]"#.into(), + callers_json: "[]".into(), + tests_json: r#"["tests/run.rs"]"#.into(), + routes_json: "[]".into(), + data_entities_json: "[]".into(), + created_at: 500, + }; + repo.insert_knowledge_context(&context).await.unwrap(); + assert_eq!( + repo.get_knowledge_context("context-1", USER).await.unwrap(), + Some(context) + ); + assert!( + repo.get_knowledge_context("context-1", "other-user") + .await + .unwrap() + .is_none() + ); +} + +#[tokio::test] +async fn cron_and_channel_ownership_follow_their_bound_conversation_owner() { + let (repo, db) = repo().await; + sqlx::query( + "INSERT INTO conversations (id, user_id, name, type, created_at, updated_at) \ + VALUES ('conversation-owned', 'system_default_user', 'Owned', 'acp', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO cron_jobs \ + (id, name, schedule_kind, schedule_value, payload_message, execution_mode, conversation_id, created_by, \ + created_at, updated_at) \ + VALUES ('cron-owned', 'Owned cron', 'every', '60', 'run', 'existing', 'conversation-owned', 'user', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO assistant_users (id, platform_user_id, platform_type, authorized_at) \ + VALUES ('channel-user', 'telegram-user', 'telegram', 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO assistant_sessions \ + (id, user_id, agent_type, conversation_id, created_at, last_activity) \ + VALUES ('channel-owned', 'channel-user', 'acp', 'conversation-owned', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + + assert!(repo.resource_is_owned(USER, "cron", "cron-owned").await.unwrap()); + assert!(repo.resource_is_owned(USER, "channel", "channel-owned").await.unwrap()); + assert!( + !repo + .resource_is_owned("other-user", "cron", "cron-owned") + .await + .unwrap() + ); + assert!( + !repo + .resource_is_owned("other-user", "channel", "channel-owned") + .await + .unwrap() + ); +} diff --git a/crates/aionui-db/tests/project_schema.rs b/crates/aionui-db/tests/project_schema.rs new file mode 100644 index 000000000..5e836146f --- /dev/null +++ b/crates/aionui-db/tests/project_schema.rs @@ -0,0 +1,84 @@ +use aionui_db::init_database_memory; + +#[tokio::test] +async fn project_migration_creates_all_phase_one_tables() { + let db = init_database_memory().await.unwrap(); + let names: Vec = sqlx::query_scalar( + "SELECT name FROM sqlite_master WHERE type = 'table' AND name IN (\ + 'projects', 'project_command_profiles', 'project_runtime_profiles', 'project_resource_links', \ + 'project_repository_facts') \ + ORDER BY name", + ) + .fetch_all(db.pool()) + .await + .unwrap(); + + assert_eq!( + names, + vec![ + "project_command_profiles", + "project_repository_facts", + "project_resource_links", + "project_runtime_profiles", + "projects", + ] + ); +} + +#[tokio::test] +async fn project_knowledge_migration_creates_indexes_facts_and_contexts() { + let database = init_database_memory().await.unwrap(); + for table in [ + "project_knowledge_indexes", + "project_knowledge_facts", + "project_knowledge_contexts", + ] { + let exists: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = ?") + .bind(table) + .fetch_one(database.pool()) + .await + .unwrap(); + assert_eq!(exists, 1, "missing table {table}"); + } +} + +#[tokio::test] +async fn project_schema_enforces_owner_path_uniqueness_and_resource_types() { + let db = init_database_memory().await.unwrap(); + let pool = db.pool(); + + sqlx::query( + "INSERT INTO projects (id, user_id, name, local_path, project_type, created_at, updated_at) \ + VALUES ('p1', 'system_default_user', 'One', '/tmp/project', 'unknown', 1, 1)", + ) + .execute(pool) + .await + .unwrap(); + + let duplicate = sqlx::query( + "INSERT INTO projects (id, user_id, name, local_path, project_type, created_at, updated_at) \ + VALUES ('p2', 'system_default_user', 'Two', '/tmp/project', 'unknown', 1, 1)", + ) + .execute(pool) + .await; + assert!(duplicate.is_err()); + + for (index, resource_type) in ["conversation", "team", "cron", "channel"].into_iter().enumerate() { + sqlx::query( + "INSERT INTO project_resource_links (project_id, user_id, resource_type, resource_id, created_at) \ + VALUES ('p1', 'system_default_user', ?, ?, 1)", + ) + .bind(resource_type) + .bind(format!("resource-{index}")) + .execute(pool) + .await + .unwrap(); + } + let invalid_link = sqlx::query( + "INSERT INTO project_resource_links (project_id, user_id, resource_type, resource_id, created_at) \ + VALUES ('p1', 'system_default_user', 'unsupported', 'resource-invalid', 1)", + ) + .execute(pool) + .await; + assert!(invalid_link.is_err()); +} diff --git a/crates/aionui-db/tests/team_repository.rs b/crates/aionui-db/tests/team_repository.rs index f5cf8aa90..e70b107eb 100644 --- a/crates/aionui-db/tests/team_repository.rs +++ b/crates/aionui-db/tests/team_repository.rs @@ -41,6 +41,12 @@ fn make_team_for_user(id: &str, user_id: &str, name: &str) -> TeamRow { lead_agent_id: Some("a1".into()), session_mode: None, agents_version: "1.0.1".into(), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, created_at: now, updated_at: now, } @@ -92,6 +98,26 @@ async fn create_and_get_team() { assert_eq!(fetched.lead_agent_id, Some("a1".into())); } +#[tokio::test] +async fn create_and_get_team_preserves_source_metadata() { + let (repo, _db) = repo().await; + let mut team = make_team("t1", "Telegram Team"); + team.source_channel = Some("telegram".into()); + team.source_chat_id = Some("chat:1".into()); + team.source_user_id = Some("user:1".into()); + team.source_label = Some("Telegram".into()); + team.created_from = Some("telegram".into()); + + repo.create_team(&team).await.unwrap(); + + let fetched = repo.get_team("t1").await.unwrap().expect("team exists"); + assert_eq!(fetched.source_channel.as_deref(), Some("telegram")); + assert_eq!(fetched.source_chat_id.as_deref(), Some("chat:1")); + assert_eq!(fetched.source_user_id.as_deref(), Some("user:1")); + assert_eq!(fetched.source_label.as_deref(), Some("Telegram")); + assert_eq!(fetched.created_from.as_deref(), Some("telegram")); +} + #[tokio::test] async fn get_nonexistent_team_returns_none() { let (repo, _db) = repo().await; diff --git a/crates/aionui-db/tests/workspace_lease_repository.rs b/crates/aionui-db/tests/workspace_lease_repository.rs new file mode 100644 index 000000000..0899e6f37 --- /dev/null +++ b/crates/aionui-db/tests/workspace_lease_repository.rs @@ -0,0 +1,95 @@ +use std::sync::Arc; + +use aionui_db::models::AgentWorkspaceLeaseRow; +use aionui_db::{ + AgentWorkspaceLeaseUpdate, IAgentWorkspaceLeaseRepository, SqliteAgentWorkspaceLeaseRepository, + init_database_memory, +}; + +async fn repo() -> (Arc, aionui_db::Database) { + let db = init_database_memory().await.unwrap(); + let repo = Arc::new(SqliteAgentWorkspaceLeaseRepository::new(db.pool().clone())); + (repo, db) +} + +fn lease(id: &str, team_id: &str, slot_id: &str, path: &str) -> AgentWorkspaceLeaseRow { + AgentWorkspaceLeaseRow { + id: id.into(), + team_id: team_id.into(), + user_id: "system_default_user".into(), + slot_id: slot_id.into(), + workspace_mode: "isolated_worktree".into(), + repository_path: "/repo".into(), + worktree_path: path.into(), + branch_name: format!("aion/team/{team_id}/{slot_id}"), + base_commit: "abc123".into(), + allowed_paths: r#"["."]"#.into(), + lease_status: "active".into(), + cleanup_status: "none".into(), + conflict_files: "[]".into(), + last_error: None, + created_at: 10, + updated_at: 10, + released_at: None, + } +} + +#[tokio::test] +async fn lease_roundtrip_and_status_transition() { + let (repo, _db) = repo().await; + repo.create(&lease("l1", "t1", "s1", "/tmp/w1")).await.unwrap(); + + let found = repo.get_for_team_slot("t1", "s1").await.unwrap().unwrap(); + assert_eq!(found.branch_name, "aion/team/t1/s1"); + + repo.update( + "l1", + &AgentWorkspaceLeaseUpdate { + lease_status: Some("cleanup_pending".into()), + cleanup_status: Some("dirty_preserved".into()), + last_error: Some(Some("uncommitted changes".into())), + ..Default::default() + }, + ) + .await + .unwrap(); + + let updated = repo.get("l1").await.unwrap().unwrap(); + assert_eq!(updated.lease_status, "cleanup_pending"); + assert_eq!(updated.cleanup_status, "dirty_preserved"); + assert_eq!(updated.last_error.as_deref(), Some("uncommitted changes")); +} + +#[tokio::test] +async fn team_slot_and_active_worktree_are_unique() { + let (repo, _db) = repo().await; + repo.create(&lease("l1", "t1", "s1", "/tmp/w1")).await.unwrap(); + + assert!(repo.create(&lease("l2", "t1", "s1", "/tmp/w2")).await.is_err()); + assert!(repo.create(&lease("l3", "t2", "s2", "/tmp/w1")).await.is_err()); +} + +#[tokio::test] +async fn list_for_team_and_reconcile_candidates_are_deterministic() { + let (repo, _db) = repo().await; + repo.create(&lease("l2", "t1", "s2", "/tmp/w2")).await.unwrap(); + repo.create(&lease("l1", "t1", "s1", "/tmp/w1")).await.unwrap(); + repo.create(&lease("l3", "t2", "s3", "/tmp/w3")).await.unwrap(); + repo.update( + "l3", + &AgentWorkspaceLeaseUpdate { + lease_status: Some("released".into()), + ..Default::default() + }, + ) + .await + .unwrap(); + + let team = repo.list_for_team("t1").await.unwrap(); + assert_eq!( + team.iter().map(|row| row.slot_id.as_str()).collect::>(), + ["s1", "s2"] + ); + let candidates = repo.list_reconcile_candidates().await.unwrap(); + assert_eq!(candidates.len(), 2); +} diff --git a/crates/aionui-development/Cargo.toml b/crates/aionui-development/Cargo.toml new file mode 100644 index 000000000..6d2fcd63f --- /dev/null +++ b/crates/aionui-development/Cargo.toml @@ -0,0 +1,32 @@ +[package] +name = "aionui-development" +version.workspace = true +edition.workspace = true +license.workspace = true + +[dependencies] +aionui-api-types.workspace = true +aionui-auth.workspace = true +aionui-common.workspace = true +aionui-db.workspace = true +aionui-runtime.workspace = true +async-trait.workspace = true +axum.workspace = true +ed25519-dalek.workspace = true +git2.workspace = true +hex.workspace = true +serde.workspace = true +serde_json.workspace = true +sha2.workspace = true +sqlx.workspace = true +thiserror.workspace = true +tokio.workspace = true +tracing.workspace = true +uuid.workspace = true +zeroize.workspace = true + +[dev-dependencies] +http-body-util.workspace = true +sqlx.workspace = true +tempfile.workspace = true +tower = { workspace = true, features = ["util"] } diff --git a/crates/aionui-development/src/approval.rs b/crates/aionui-development/src/approval.rs new file mode 100644 index 000000000..74abcdc07 --- /dev/null +++ b/crates/aionui-development/src/approval.rs @@ -0,0 +1,339 @@ +use std::sync::Arc; + +use aionui_common::{TimestampMs, now_ms}; +use aionui_db::models::ApprovalRequestRow; +use aionui_db::{DbError, IApprovalRepository}; +use async_trait::async_trait; +use serde::{Deserialize, Serialize}; +use serde_json::Value; +use uuid::Uuid; + +const APPROVAL_TTL_MS: TimestampMs = 10 * 60 * 1_000; + +#[derive(Debug, thiserror::Error)] +pub enum ApprovalError { + #[error("Invalid approval request: {0}")] + BadRequest(String), + #[error("Approval request not found")] + NotFound, + #[error("Approval access denied: {0}")] + Forbidden(String), + #[error("Approval conflicts with current state: {0}")] + Conflict(String), + #[error("Approval resolver failed: {0}")] + Resolver(String), + #[error("Approval persistence failed: {0}")] + Internal(String), +} + +impl From for ApprovalError { + fn from(value: DbError) -> Self { + Self::Internal(value.to_string()) + } +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct ApprovalOption { + pub label: String, + pub value: Value, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub params: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ApprovalSource { + pub channel: String, + pub user_id: String, + pub chat_id: String, + pub thread_id: Option, +} + +#[derive(Debug, Clone)] +pub struct ApprovalRequestInput { + pub requester_user_id: String, + pub project_id: Option, + pub run_id: Option, + pub task_id: Option, + pub conversation_id: String, + pub agent_id: Option, + pub call_id: String, + pub action_type: String, + pub command: Option, + pub working_directory: Option, + pub risk_level: String, + pub options: Vec, + pub source: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ResolveApprovalContext { + Web { + user_id: String, + }, + Channel { + user_id: String, + channel: String, + source_user_id: String, + chat_id: String, + thread_id: Option, + is_admin: bool, + }, +} + +impl ResolveApprovalContext { + fn user_id(&self) -> &str { + match self { + Self::Web { user_id } | Self::Channel { user_id, .. } => user_id, + } + } +} + +#[async_trait] +pub trait ApprovalResolver: Send + Sync { + async fn resolve( + &self, + conversation_id: &str, + call_id: &str, + value: Value, + always_allow: bool, + ) -> Result<(), String>; +} + +#[derive(Clone)] +pub struct ApprovalService { + repository: Arc, + resolver: Arc, +} + +impl ApprovalService { + pub fn new(repository: Arc, resolver: Arc) -> Self { + Self { repository, resolver } + } + + pub async fn create(&self, input: ApprovalRequestInput) -> Result { + validate_input(&input)?; + if let Some(existing) = self + .repository + .get_by_conversation_call(&input.conversation_id, &input.call_id) + .await? + { + if existing.requester_user_id != input.requester_user_id { + return Err(ApprovalError::Forbidden( + "idempotency key belongs to another user".into(), + )); + } + return Ok(existing); + } + + let now = now_ms(); + let source = input.source.as_ref(); + let row = ApprovalRequestRow { + id: short_approval_id(), + requester_user_id: input.requester_user_id, + project_id: input.project_id, + run_id: input.run_id, + task_id: input.task_id, + conversation_id: input.conversation_id, + agent_id: input.agent_id, + call_id: input.call_id, + action_type: input.action_type, + command: input.command.as_deref().map(redact_secrets), + working_directory: input.working_directory, + risk_level: input.risk_level, + options: serde_json::to_string(&input.options) + .map_err(|error| ApprovalError::Internal(error.to_string()))?, + status: "pending".into(), + approver_user_id: None, + source_channel: source.map(|value| value.channel.clone()), + source_user_id: source.map(|value| value.user_id.clone()), + source_chat_id: source.map(|value| value.chat_id.clone()), + source_thread_id: source.and_then(|value| value.thread_id), + expires_at: now + APPROVAL_TTL_MS, + consumed_at: None, + created_at: now, + updated_at: now, + }; + if let Err(error) = self.repository.create(&row).await { + if let Some(existing) = self + .repository + .get_by_conversation_call(&row.conversation_id, &row.call_id) + .await? + { + return Ok(existing); + } + return Err(error.into()); + } + Ok(row) + } + + pub async fn get(&self, user_id: &str, approval_id: &str) -> Result { + let row = self.repository.get(approval_id).await?.ok_or(ApprovalError::NotFound)?; + ensure_owner(&row, user_id)?; + Ok(row) + } + + pub async fn list(&self, user_id: &str, run_id: Option<&str>) -> Result, ApprovalError> { + self.repository.mark_expired(now_ms()).await?; + Ok(self.repository.list_for_user(user_id, run_id).await?) + } + + pub async fn resolve( + &self, + approval_id: &str, + option_index: usize, + context: ResolveApprovalContext, + ) -> Result { + let now = now_ms(); + self.repository.mark_expired(now).await?; + let row = self.repository.get(approval_id).await?.ok_or(ApprovalError::NotFound)?; + ensure_owner(&row, context.user_id())?; + ensure_source(&row, &context)?; + if row.status != "pending" { + return Err(ApprovalError::Conflict(format!("approval is {}", row.status))); + } + let options: Vec = + serde_json::from_str(&row.options).map_err(|error| ApprovalError::Internal(error.to_string()))?; + let option = options + .get(option_index) + .cloned() + .ok_or_else(|| ApprovalError::BadRequest("approval option does not exist".into()))?; + let status = if is_rejection(&option) { "rejected" } else { "approved" }; + if !self + .repository + .consume(approval_id, context.user_id(), status, now) + .await? + { + return Err(ApprovalError::Conflict( + "approval was already consumed or expired".into(), + )); + } + + let always_allow = option + .params + .as_ref() + .and_then(|params| params.get("always_allow")) + .and_then(Value::as_bool) + .unwrap_or(false); + if let Err(error) = self + .resolver + .resolve(&row.conversation_id, &row.call_id, option.value, always_allow) + .await + { + let _ = self + .repository + .cancel_consumed(approval_id, context.user_id(), now_ms()) + .await; + return Err(ApprovalError::Resolver(error)); + } + self.get(context.user_id(), approval_id).await + } +} + +fn validate_input(input: &ApprovalRequestInput) -> Result<(), ApprovalError> { + if input.requester_user_id.trim().is_empty() + || input.conversation_id.trim().is_empty() + || input.call_id.trim().is_empty() + || input.action_type.trim().is_empty() + { + return Err(ApprovalError::BadRequest( + "requester, conversation, call and action are required".into(), + )); + } + if input.options.is_empty() || input.options.len() > 8 { + return Err(ApprovalError::BadRequest( + "approval must contain between one and eight options".into(), + )); + } + if !matches!(input.risk_level.as_str(), "low" | "medium" | "high" | "critical") { + return Err(ApprovalError::BadRequest("unsupported risk level".into())); + } + Ok(()) +} + +fn ensure_owner(row: &ApprovalRequestRow, user_id: &str) -> Result<(), ApprovalError> { + if row.requester_user_id != user_id { + return Err(ApprovalError::Forbidden("approval belongs to another user".into())); + } + Ok(()) +} + +fn ensure_source(row: &ApprovalRequestRow, context: &ResolveApprovalContext) -> Result<(), ApprovalError> { + let ResolveApprovalContext::Channel { + channel, + source_user_id, + chat_id, + thread_id, + is_admin, + .. + } = context + else { + return Ok(()); + }; + if row.source_channel.as_deref() != Some(channel.as_str()) + || row.source_chat_id.as_deref() != Some(chat_id.as_str()) + || row.source_thread_id != *thread_id + || (!*is_admin && row.source_user_id.as_deref() != Some(source_user_id.as_str())) + { + return Err(ApprovalError::Forbidden( + "approval source does not match this channel topic".into(), + )); + } + Ok(()) +} + +fn is_rejection(option: &ApprovalOption) -> bool { + if option + .params + .as_ref() + .and_then(|params| params.get("decision")) + .and_then(Value::as_str) + == Some("reject") + { + return true; + } + let value = option.value.as_str().unwrap_or_default().to_ascii_lowercase(); + let label = option.label.to_ascii_lowercase(); + ["reject", "deny", "cancel"] + .iter() + .any(|word| value.contains(word) || label.contains(word)) +} + +fn short_approval_id() -> String { + Uuid::now_v7().simple().to_string()[..16].to_owned() +} + +fn redact_secrets(command: &str) -> String { + let sensitive = [ + "token", + "password", + "passwd", + "secret", + "api_key", + "apikey", + "authorization", + ]; + let mut redact_next = false; + command + .split_whitespace() + .map(|part| { + if redact_next { + redact_next = false; + return "[REDACTED]".to_owned(); + } + let lower = part.to_ascii_lowercase(); + if let Some((key, _)) = part.split_once('=') + && sensitive.iter().any(|name| key.to_ascii_lowercase().contains(name)) + { + return format!("{key}=[REDACTED]"); + } + if sensitive + .iter() + .any(|name| lower == *name || lower == format!("--{name}")) + { + redact_next = true; + } + part.to_owned() + }) + .collect::>() + .join(" ") +} diff --git a/crates/aionui-development/src/approval_routes.rs b/crates/aionui-development/src/approval_routes.rs new file mode 100644 index 000000000..e25e9cabf --- /dev/null +++ b/crates/aionui-development/src/approval_routes.rs @@ -0,0 +1,99 @@ +#![allow(clippy::disallowed_types)] // HTTP boundary maps crate-owned errors to the shared API response. + +use std::sync::Arc; + +use aionui_api_types::ApiResponse; +use aionui_auth::CurrentUser; +use aionui_common::ApiError; +use aionui_db::models::ApprovalRequestRow; +use axum::Router; +use axum::extract::rejection::JsonRejection; +use axum::extract::{Extension, Json, Path, Query, State}; +use axum::routing::{get, post}; +use serde::Deserialize; + +use crate::approval::{ApprovalError, ApprovalService, ResolveApprovalContext}; + +impl From for ApiError { + fn from(value: ApprovalError) -> Self { + match value { + ApprovalError::BadRequest(message) => Self::BadRequest(message), + ApprovalError::NotFound => Self::NotFound("Approval request".into()), + ApprovalError::Forbidden(message) => Self::Forbidden(message), + ApprovalError::Conflict(message) => Self::Conflict(message), + ApprovalError::Resolver(_) => Self::BadGateway("Agent could not consume the approval".into()), + ApprovalError::Internal(_) => Self::Internal("Approval operation failed".into()), + } + } +} + +#[derive(Clone)] +pub struct ApprovalRouterState { + pub service: Arc, +} + +#[derive(Debug, Default, Deserialize)] +struct ApprovalListQuery { + run_id: Option, +} + +#[derive(Debug, Deserialize)] +struct ResolveApprovalBody { + option_index: usize, +} + +pub fn approval_routes(state: ApprovalRouterState) -> Router { + Router::new() + .route("/api/approvals", get(list_approvals)) + .route("/api/approvals/{approval_id}", get(get_approval)) + .route("/api/approvals/{approval_id}/resolve", post(resolve_approval)) + .with_state(state) +} + +async fn list_approvals( + State(state): State, + Extension(user): Extension, + Query(query): Query, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .list(&user.id, query.run_id.as_deref()) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn get_approval( + State(state): State, + Extension(user): Extension, + Path(approval_id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .get(&user.id, &approval_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn resolve_approval( + State(state): State, + Extension(user): Extension, + Path(approval_id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(body) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .service + .resolve( + &approval_id, + body.option_index, + ResolveApprovalContext::Web { user_id: user.id }, + ) + .await + .map_err(ApiError::from)?, + ))) +} diff --git a/crates/aionui-development/src/delivery.rs b/crates/aionui-development/src/delivery.rs new file mode 100644 index 000000000..e35035c62 --- /dev/null +++ b/crates/aionui-development/src/delivery.rs @@ -0,0 +1,1165 @@ +use std::collections::HashMap; +use std::path::{Path, PathBuf}; +use std::sync::Arc; + +use aionui_common::now_ms; +use aionui_db::models::{ + DevelopmentCiCheckRow, DevelopmentDeliveryRow, DevelopmentDeliveryTagRow, DevelopmentRunRow, DevelopmentTaskRow, + ProjectRow, TaskArtifactRow, +}; +use aionui_db::{IDevelopmentRepository, IProjectRepository}; +use async_trait::async_trait; +use git2::{IndexAddOption, Repository, Signature, build::CheckoutBuilder}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; +use sha2::{Digest, Sha256}; + +use crate::DevelopmentError; +use crate::operations::{DevelopmentOperationsService, redact_sensitive}; +use crate::policy::{PolicyDecision, PolicyOperation}; + +#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)] +pub struct ProviderPullRequest { + pub number: i64, + pub url: String, + pub status: String, + pub review_status: String, +} + +#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)] +pub struct ProviderCiCheck { + pub id: String, + pub name: String, + pub status: String, + pub details_url: Option, + pub summary: Option, +} + +#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)] +pub struct ProviderReviewComment { + pub id: String, + pub body: String, + pub url: Option, + pub author: Option, + pub resolved: bool, +} + +#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)] +pub struct DeliveryProviderSnapshot { + pub pull_request: ProviderPullRequest, + pub checks: Vec, + pub review_comments: Vec, +} + +#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)] +pub struct ProviderTag { + pub name: String, + pub commit_sha: String, + pub remote_url: Option, +} + +#[async_trait] +pub trait DeliveryProvider: Send + Sync { + fn name(&self) -> &'static str { + "github" + } + + async fn preflight(&self, repository: &Path) -> Result<(), String>; + async fn push(&self, repository: &Path, branch: &str) -> Result<(), String>; + async fn ensure_pull_request( + &self, + repository: &Path, + head: &str, + base: &str, + title: &str, + body: &str, + ) -> Result; + async fn synchronize(&self, repository: &Path, number: i64) -> Result; + async fn merge(&self, repository: &Path, number: i64) -> Result<(), String>; + async fn ensure_tag(&self, _repository: &Path, _tag: &str, _commit: &str) -> Result { + Err("delivery provider does not support tags".into()) + } +} + +#[derive(Clone)] +pub struct DeliveryProviderRegistry { + providers: HashMap>, +} + +impl DeliveryProviderRegistry { + pub fn new(provider: Arc) -> Self { + let mut providers = HashMap::new(); + providers.insert(provider.name().to_owned(), provider); + Self { providers } + } + + pub fn with_provider(mut self, provider: Arc) -> Self { + self.providers.insert(provider.name().to_owned(), provider); + self + } + + pub fn get(&self, name: &str) -> Result, DevelopmentError> { + self.providers + .get(name) + .cloned() + .ok_or_else(|| DevelopmentError::BadRequest(format!("unsupported delivery provider: {name}"))) + } + + pub fn name_for_repository(&self, repository: Option<&str>) -> Result<&'static str, DevelopmentError> { + let repository = repository.unwrap_or_default().to_ascii_lowercase(); + if !repository.contains("github") { + return Err(DevelopmentError::BadRequest( + "repository host is not a supported GitHub provider".into(), + )); + } + self.get("github")?; + Ok("github") + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct PrepareDeliveryInput { + pub message: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct CreatePullRequestInput { + pub title: Option, + #[serde(default)] + pub confirmed: bool, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct CreateTagInput { + pub name: String, + pub commit_sha: String, + #[serde(default)] + pub confirmed: bool, + #[serde(default)] + pub confirmation_count: u8, +} + +#[derive(Clone)] +pub struct DeliveryService { + development_repo: Arc, + project_repo: Arc, + providers: DeliveryProviderRegistry, + operations: Option>, +} + +impl DeliveryService { + pub fn new( + development_repo: Arc, + project_repo: Arc, + provider: Arc, + ) -> Self { + Self { + development_repo, + project_repo, + providers: DeliveryProviderRegistry::new(provider), + operations: None, + } + } + + pub fn with_operations(mut self, operations: Arc) -> Self { + self.operations = Some(operations); + self + } + + pub fn with_provider(mut self, provider: Arc) -> Self { + self.providers = self.providers.with_provider(provider); + self + } + + pub async fn get(&self, user_id: &str, run_id: &str) -> Result { + self.get_run(user_id, run_id).await?; + self.development_repo + .get_delivery(user_id, run_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("delivery for run {run_id}"))) + } + + pub async fn prepare( + &self, + user_id: &str, + run_id: &str, + input: PrepareDeliveryInput, + ) -> Result { + if let Some(delivery) = self.development_repo.get_delivery(user_id, run_id).await? + && (delivery.commit_sha.is_some() || delivery.status == "no_change") + { + return Ok(delivery); + } + + let run = self.get_run(user_id, run_id).await?; + self.require_budget(user_id, run_id, "delivery.prepare").await?; + let project = self.get_project(user_id, &run).await?; + let reasons = self.delivery_blockers(&run).await?; + if !reasons.is_empty() { + return Err(DevelopmentError::Conflict(reasons.join("; "))); + } + + let base_branch = project.default_branch.clone().unwrap_or_else(|| "main".into()); + let repository_path = PathBuf::from(&project.local_path); + let message = input + .message + .as_deref() + .map(clean_commit_message) + .transpose()? + .unwrap_or_else(|| format!("chore: deliver {}", clean_summary(&run.request_summary))); + let prepared = prepare_repository( + &repository_path, + run_id, + run.integration_branch.as_deref(), + &base_branch, + &message, + )?; + + let artifacts = self.development_repo.list_artifacts(run_id, None).await?; + if prepared.commit_sha.is_none() + && !artifacts + .iter() + .any(|artifact| artifact.artifact_type == "no_code_change") + { + return Err(DevelopmentError::Conflict( + "repository has no candidate change and no reviewer-approved no-code artifact".into(), + )); + } + if let Some(commit_sha) = prepared.commit_sha.as_deref() + && !artifacts + .iter() + .any(|artifact| artifact.artifact_type == "commit" && artifact.path_or_uri == commit_sha) + { + self.development_repo + .create_artifact(&TaskArtifactRow { + id: uuid::Uuid::now_v7().to_string(), + run_id: run_id.into(), + task_id: None, + artifact_type: "commit".into(), + path_or_uri: commit_sha.into(), + checksum: commit_sha.into(), + producer_agent_id: Some("aion-delivery".into()), + metadata: Some(json!({"branch": prepared.branch, "base_branch": base_branch}).to_string()), + created_at: now_ms(), + }) + .await?; + } + + let provider = self + .providers + .name_for_repository(project.repository_url.as_deref())? + .to_owned(); + let now = now_ms(); + let delivery = DevelopmentDeliveryRow { + id: uuid::Uuid::now_v7().to_string(), + run_id: run_id.into(), + project_id: run.project_id.clone(), + user_id: user_id.into(), + provider, + repository: project.repository_url.clone(), + branch: prepared.branch, + base_branch, + commit_sha: prepared.commit_sha, + status: if prepared.had_change { "prepared" } else { "no_change" }.into(), + push_status: "pending".into(), + pr_number: None, + pr_url: None, + pr_status: "not_created".into(), + ci_status: "not_started".into(), + review_status: "pending".into(), + merge_status: "blocked".into(), + report_json: "{}".into(), + last_error: None, + created_at: now, + updated_at: now, + }; + self.persist_with_report(delivery).await + } + + pub async fn push( + &self, + user_id: &str, + run_id: &str, + confirmation_count: u8, + ) -> Result { + require_confirmation_count(confirmation_count, "push")?; + let mut delivery = self.get(user_id, run_id).await?; + self.authorize_git(user_id, &delivery, "push", Some(&delivery.branch), confirmation_count) + .await?; + if delivery.push_status == "pushed" { + return Ok(delivery); + } + if delivery.commit_sha.is_none() { + return Err(DevelopmentError::Conflict( + "delivery has no candidate commit to push".into(), + )); + } + self.require_budget(user_id, run_id, "delivery.push").await?; + validate_delivery_branch(&delivery.branch, &delivery.base_branch)?; + let path = self.repository_path(user_id, run_id).await?; + let provider = self.providers.get(&delivery.provider)?; + if let Err(error) = provider.preflight(&path).await { + return self.fail_provider_operation(delivery, error).await; + } + if let Err(error) = provider.push(&path, &delivery.branch).await { + return self.fail_provider_operation(delivery, error).await; + } + delivery.push_status = "pushed".into(); + delivery.status = "pushed".into(); + delivery.last_error = None; + delivery.updated_at = now_ms(); + self.persist_with_report(delivery).await + } + + pub async fn create_pull_request( + &self, + user_id: &str, + run_id: &str, + input: CreatePullRequestInput, + ) -> Result { + require_confirmation(input.confirmed, "pull request creation")?; + let mut delivery = self.get(user_id, run_id).await?; + if delivery.pr_number.is_some() { + return Ok(delivery); + } + if delivery.push_status != "pushed" { + return Err(DevelopmentError::Conflict( + "delivery branch must be pushed first".into(), + )); + } + self.require_budget(user_id, run_id, "delivery.pull_request").await?; + let run = self.get_run(user_id, run_id).await?; + let path = self.repository_path(user_id, run_id).await?; + let title = input + .title + .as_deref() + .map(clean_title) + .transpose()? + .unwrap_or_else(|| clean_summary(&run.request_summary)); + let body = self.report_value(user_id, run_id, &delivery).await?.to_string(); + let provider = self.providers.get(&delivery.provider)?; + let pull_request = match provider + .ensure_pull_request(&path, &delivery.branch, &delivery.base_branch, &title, &body) + .await + { + Ok(pull_request) => pull_request, + Err(error) => return self.fail_provider_operation(delivery, error).await, + }; + delivery.pr_number = Some(pull_request.number); + delivery.pr_url = Some(pull_request.url); + delivery.pr_status = pull_request.status; + delivery.review_status = pull_request.review_status; + delivery.status = "pr_open".into(); + delivery.last_error = None; + delivery.updated_at = now_ms(); + self.persist_with_report(delivery).await + } + + pub async fn sync(&self, user_id: &str, run_id: &str) -> Result { + self.require_budget(user_id, run_id, "delivery.sync").await?; + let mut delivery = self.get(user_id, run_id).await?; + let number = delivery + .pr_number + .ok_or_else(|| DevelopmentError::Conflict("pull request has not been created".into()))?; + let run = self.get_run(user_id, run_id).await?; + let path = self.repository_path(user_id, run_id).await?; + let provider = self.providers.get(&delivery.provider)?; + let snapshot = match provider.synchronize(&path, number).await { + Ok(snapshot) => snapshot, + Err(error) => return self.fail_provider_operation(delivery, error).await, + }; + + let existing = self + .development_repo + .list_ci_checks(&delivery.id) + .await? + .into_iter() + .map(|check| (check.provider_check_id.clone(), check)) + .collect::>(); + for check in &snapshot.checks { + let previous = existing.get(&check.id); + let rework_task_id = if check.status == "failed" { + Some( + self.ensure_rework_task( + &run, + &delivery, + check, + previous.and_then(|row| row.rework_task_id.as_deref()), + ) + .await?, + ) + } else { + previous.and_then(|row| row.rework_task_id.clone()) + }; + let now = now_ms(); + self.development_repo + .upsert_ci_check(&DevelopmentCiCheckRow { + id: previous + .map(|row| row.id.clone()) + .unwrap_or_else(|| uuid::Uuid::now_v7().to_string()), + delivery_id: delivery.id.clone(), + provider_check_id: check.id.clone(), + name: check.name.clone(), + status: normalize_check_status(&check.status), + details_url: check.details_url.clone(), + summary: check.summary.clone(), + rework_task_id, + started_at: previous.and_then(|row| row.started_at).or(Some(now)), + completed_at: matches!(check.status.as_str(), "passed" | "failed" | "cancelled" | "skipped") + .then_some(now), + created_at: previous.map(|row| row.created_at).unwrap_or(now), + updated_at: now, + }) + .await?; + } + for comment in snapshot.review_comments.iter().filter(|comment| !comment.resolved) { + self.ensure_review_rework_task(&run, &delivery, comment).await?; + } + + delivery.pr_number = Some(snapshot.pull_request.number); + delivery.pr_url = Some(snapshot.pull_request.url); + delivery.pr_status = snapshot.pull_request.status; + delivery.review_status = snapshot.pull_request.review_status; + delivery.ci_status = aggregate_ci_status(&snapshot.checks).into(); + let mut blockers = self.delivery_blockers(&run).await?; + blockers.extend(self.final_integration_blockers(&delivery).await?); + if delivery.ci_status == "failed" { + delivery.status = "rework_required".into(); + delivery.merge_status = "blocked".into(); + self.development_repo + .update_run_status(run_id, user_id, "rework", None) + .await?; + } else if delivery.ci_status == "passed" && delivery.review_status == "approved" && blockers.is_empty() { + delivery.status = "merge_ready".into(); + delivery.merge_status = "ready".into(); + } else { + delivery.status = "ci_pending".into(); + delivery.merge_status = "blocked".into(); + } + delivery.last_error = None; + delivery.updated_at = now_ms(); + self.persist_with_report(delivery).await + } + + pub async fn merge( + &self, + user_id: &str, + run_id: &str, + confirmation_count: u8, + ) -> Result { + require_confirmation_count(confirmation_count, "merge")?; + let mut delivery = self.get(user_id, run_id).await?; + self.authorize_git( + user_id, + &delivery, + "merge", + Some(&delivery.base_branch), + confirmation_count, + ) + .await?; + if delivery.status == "merged" || delivery.merge_status == "merged" { + return Ok(delivery); + } + let run = self.get_run(user_id, run_id).await?; + let mut blockers = self.delivery_blockers(&run).await?; + blockers.extend(self.final_integration_blockers(&delivery).await?); + if delivery.ci_status != "passed" { + blockers.push("CI checks have not passed".into()); + } + if delivery.review_status != "approved" { + blockers.push("pull request review has not been approved".into()); + } + if delivery.merge_status != "ready" { + blockers.push("delivery has not reached merge-ready state".into()); + } + if !blockers.is_empty() { + return Err(DevelopmentError::Conflict(blockers.join("; "))); + } + self.require_budget(user_id, run_id, "delivery.merge").await?; + let number = delivery + .pr_number + .ok_or_else(|| DevelopmentError::Conflict("pull request has not been created".into()))?; + let path = self.repository_path(user_id, run_id).await?; + let provider = self.providers.get(&delivery.provider)?; + if let Err(error) = provider.merge(&path, number).await { + return self.fail_provider_operation(delivery, error).await; + } + delivery.status = "merged".into(); + delivery.merge_status = "merged".into(); + delivery.pr_status = "merged".into(); + delivery.last_error = None; + delivery.updated_at = now_ms(); + self.development_repo + .update_run_status(run_id, user_id, "succeeded", Some(now_ms())) + .await?; + self.persist_with_report(delivery).await + } + + pub async fn report(&self, user_id: &str, run_id: &str) -> Result { + let delivery = self.get(user_id, run_id).await?; + self.report_value(user_id, run_id, &delivery).await + } + + pub async fn create_tag( + &self, + user_id: &str, + run_id: &str, + input: CreateTagInput, + ) -> Result { + require_confirmation(input.confirmed, "tag creation")?; + require_confirmation_count(input.confirmation_count, "tag creation")?; + validate_tag_name(&input.name)?; + let delivery = self.get(user_id, run_id).await?; + if delivery.status != "merged" || delivery.merge_status != "merged" { + return Err(DevelopmentError::Conflict( + "delivery must be merged before a release tag can be created".into(), + )); + } + if delivery.commit_sha.as_deref() != Some(input.commit_sha.as_str()) { + return Err(DevelopmentError::Conflict( + "tag commit does not match the immutable delivery commit".into(), + )); + } + self.authorize_git(user_id, &delivery, "tag", Some(&input.name), input.confirmation_count) + .await?; + if let Some(existing) = self + .development_repo + .get_delivery_tag(user_id, &delivery.id, &input.name) + .await? + { + if existing.commit_sha != input.commit_sha { + return Err(DevelopmentError::Conflict( + "tag name already belongs to a different commit".into(), + )); + } + return Ok(existing); + } + + self.require_budget(user_id, run_id, "delivery.tag").await?; + let now = now_ms(); + let pending = DevelopmentDeliveryTagRow { + id: uuid::Uuid::now_v7().to_string(), + delivery_id: delivery.id.clone(), + user_id: user_id.into(), + name: input.name.clone(), + commit_sha: input.commit_sha.clone(), + remote_url: None, + status: "pending".into(), + last_error: None, + created_at: now, + updated_at: now, + }; + if !self.development_repo.create_delivery_tag(&pending).await? { + return self + .development_repo + .get_delivery_tag(user_id, &delivery.id, &input.name) + .await? + .ok_or_else(|| DevelopmentError::Conflict("tag creation is already in progress".into())); + } + let path = self.repository_path(user_id, run_id).await?; + let provider = self.providers.get(&delivery.provider)?; + match provider.ensure_tag(&path, &input.name, &input.commit_sha).await { + Ok(tag) => { + self.development_repo + .update_delivery_tag_result( + user_id, + &pending.id, + "succeeded", + tag.remote_url.as_deref(), + None, + now_ms(), + ) + .await?; + } + Err(error) => { + let error = redact_secret(&error); + self.development_repo + .update_delivery_tag_result(user_id, &pending.id, "failed", None, Some(&error), now_ms()) + .await?; + return Err(DevelopmentError::Internal(error)); + } + } + self.development_repo + .get_delivery_tag(user_id, &delivery.id, &input.name) + .await? + .ok_or_else(|| DevelopmentError::Internal("created tag record disappeared".into())) + } + + pub async fn list_tags( + &self, + user_id: &str, + run_id: &str, + ) -> Result, DevelopmentError> { + let delivery = self.get(user_id, run_id).await?; + Ok(self.development_repo.list_delivery_tags(user_id, &delivery.id).await?) + } + + async fn require_budget(&self, user_id: &str, run_id: &str, operation: &str) -> Result<(), DevelopmentError> { + if let Some(operations) = &self.operations { + operations.require_budget(user_id, run_id, operation, 0).await?; + } + Ok(()) + } + + async fn authorize_git( + &self, + user_id: &str, + delivery: &DevelopmentDeliveryRow, + operation: &str, + branch: Option<&str>, + confirmation_count: u8, + ) -> Result<(), DevelopmentError> { + if let Some(operations) = &self.operations { + let decision = operations + .evaluate_policy( + user_id, + &delivery.project_id, + &delivery.run_id, + &PolicyOperation::Git { + operation: operation.into(), + branch: branch.map(str::to_owned), + }, + confirmation_count, + ) + .await?; + if decision != PolicyDecision::Allowed { + return Err(DevelopmentError::BadRequest(format!( + "{operation} does not satisfy the Project policy" + ))); + } + } + Ok(()) + } + + async fn get_run(&self, user_id: &str, run_id: &str) -> Result { + self.development_repo + .get_run(run_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("run {run_id}"))) + } + + async fn get_project(&self, user_id: &str, run: &DevelopmentRunRow) -> Result { + self.project_repo + .get_for_user(&run.project_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("project {}", run.project_id))) + } + + async fn repository_path(&self, user_id: &str, run_id: &str) -> Result { + let run = self.get_run(user_id, run_id).await?; + Ok(PathBuf::from(self.get_project(user_id, &run).await?.local_path)) + } + + async fn delivery_blockers(&self, run: &DevelopmentRunRow) -> Result, DevelopmentError> { + let tasks = self.development_repo.list_tasks(&run.id).await?; + let gates = self.development_repo.list_gates(&run.id, None).await?; + let mut blockers = Vec::new(); + if tasks.is_empty() { + blockers.push("delivery requires at least one completed task".into()); + } + if tasks + .iter() + .any(|task| task.status != "completed" && task.status != "cancelled") + { + blockers.push("one or more development tasks are incomplete".into()); + } + if tasks.iter().filter(|task| task.status != "cancelled").any(|task| { + !matches!(task.review_status.as_str(), "approved" | "not_required") || task.verification_status != "passed" + }) { + blockers.push("one or more development tasks lack review or verification approval".into()); + } + let mut latest_required = HashMap::new(); + for gate in gates.into_iter().filter(|gate| gate.required) { + latest_required.insert((gate.task_id.clone(), gate.gate_type.clone()), gate); + } + if latest_required.is_empty() { + blockers.push("no required quality gate is recorded".into()); + } else if latest_required.values().any(|gate| gate.status != "passed") { + blockers.push("one or more latest required quality gates have not passed".into()); + } + for task in &tasks { + if self + .development_repo + .list_findings(&run.id, &task.id) + .await? + .iter() + .any(|finding| finding.status == "open" && matches!(finding.severity.as_str(), "critical" | "blocker")) + { + blockers.push("critical or blocker review findings remain open".into()); + break; + } + } + Ok(blockers) + } + + async fn final_integration_blockers( + &self, + delivery: &DevelopmentDeliveryRow, + ) -> Result, DevelopmentError> { + let latest = self + .development_repo + .list_gates(&delivery.run_id, None) + .await? + .into_iter() + .filter(|gate| { + gate.required + && gate.task_id.is_none() + // `integration_test` is the public gate/profile identifier. + // Keep accepting legacy `integration` rows created by early + // roadmap builds so upgrades do not strand existing runs. + && matches!(gate.gate_type.as_str(), "integration_test" | "integration") + && gate.created_at >= delivery.created_at + }) + .max_by_key(|gate| gate.created_at); + match latest { + Some(gate) if gate.status == "passed" => Ok(Vec::new()), + Some(_) => Ok(vec![ + "the latest final integration gate for the candidate commit has not passed".into(), + ]), + None => Ok(vec![ + "a required run-level integration gate must pass after candidate creation".into(), + ]), + } + } + + async fn ensure_rework_task( + &self, + run: &DevelopmentRunRow, + delivery: &DevelopmentDeliveryRow, + check: &ProviderCiCheck, + existing_task_id: Option<&str>, + ) -> Result { + let task_id = existing_task_id + .map(str::to_owned) + .unwrap_or_else(|| deterministic_rework_id(&delivery.id, &check.id)); + if let Some(existing) = self.development_repo.get_task(&run.id, &task_id).await? { + if existing.status == "completed" { + self.development_repo + .update_task_state(&run.id, &task_id, "ready", "pending", "pending") + .await?; + } + return Ok(task_id); + } + let now = now_ms(); + self.development_repo + .create_task(&DevelopmentTaskRow { + id: task_id.clone(), + team_id: run.team_id.clone().unwrap_or_else(|| format!("run:{}", run.id)), + run_id: Some(run.id.clone()), + subject: format!("Fix CI check: {}", check.name), + description: check.summary.clone(), + status: "ready".into(), + owner: None, + blocked_by: "[]".into(), + blocks: "[]".into(), + metadata: Some( + json!({ + "delivery_id": delivery.id, + "provider_check_id": check.id, + "details_url": check.details_url, + "summary": check.summary, + }) + .to_string(), + ), + acceptance_criteria: json!([format!("CI check '{}' passes", check.name)]).to_string(), + task_type: "rework".into(), + risk_level: "high".into(), + assigned_workspace_lease_id: None, + review_status: "pending".into(), + verification_status: "pending".into(), + created_at: now, + updated_at: now, + }) + .await?; + Ok(task_id) + } + + async fn ensure_review_rework_task( + &self, + run: &DevelopmentRunRow, + delivery: &DevelopmentDeliveryRow, + comment: &ProviderReviewComment, + ) -> Result { + let task_id = deterministic_review_rework_id(&delivery.id, &comment.id); + if self.development_repo.get_task(&run.id, &task_id).await?.is_some() { + return Ok(task_id); + } + let now = now_ms(); + let body = redact_secret(&comment.body); + self.development_repo + .create_task(&DevelopmentTaskRow { + id: task_id.clone(), + team_id: run.team_id.clone().unwrap_or_else(|| format!("run:{}", run.id)), + run_id: Some(run.id.clone()), + subject: "Address provider review comment".into(), + description: (!body.is_empty()).then_some(body), + status: "ready".into(), + owner: None, + blocked_by: "[]".into(), + blocks: "[]".into(), + metadata: Some( + json!({ + "delivery_id": delivery.id, + "provider_comment_id": comment.id, + "url": comment.url, + "author": comment.author, + }) + .to_string(), + ), + acceptance_criteria: json!(["The provider review comment is addressed and re-reviewed"]).to_string(), + task_type: "review_rework".into(), + risk_level: "high".into(), + assigned_workspace_lease_id: None, + review_status: "pending".into(), + verification_status: "pending".into(), + created_at: now, + updated_at: now, + }) + .await?; + Ok(task_id) + } + + async fn persist_with_report( + &self, + mut delivery: DevelopmentDeliveryRow, + ) -> Result { + delivery.report_json = self + .report_value(&delivery.user_id, &delivery.run_id, &delivery) + .await? + .to_string(); + self.development_repo.upsert_delivery(&delivery).await?; + Ok(delivery) + } + + async fn report_value( + &self, + user_id: &str, + run_id: &str, + delivery: &DevelopmentDeliveryRow, + ) -> Result { + let run = self.get_run(user_id, run_id).await?; + let tasks = self.development_repo.list_tasks(run_id).await?; + let artifacts = self.development_repo.list_artifacts(run_id, None).await?; + let gates = self.development_repo.list_gates(run_id, None).await?; + let checks = self.development_repo.list_ci_checks(&delivery.id).await?; + let mut findings = Vec::new(); + for task in &tasks { + findings.extend(self.development_repo.list_findings(run_id, &task.id).await?); + } + let mut unresolved_risks = self.delivery_blockers(&run).await?; + unresolved_risks.extend(self.final_integration_blockers(delivery).await?); + let acceptance_criteria: Value = serde_json::from_str(&run.acceptance_criteria).unwrap_or_else(|_| json!([])); + Ok(json!({ + "schema_version": 1, + "run": { + "id": run.id, + "project_id": run.project_id, + "request_summary": run.request_summary, + "acceptance_criteria": acceptance_criteria, + "execution_mode": run.execution_mode, + "status": run.status, + }, + "candidate": { + "provider": delivery.provider, + "repository": delivery.repository, + "branch": delivery.branch, + "base_branch": delivery.base_branch, + "commit_sha": delivery.commit_sha, + }, + "pull_request": { + "number": delivery.pr_number, + "url": delivery.pr_url, + "status": delivery.pr_status, + "review_status": delivery.review_status, + }, + "delivery": { + "status": delivery.status, + "push_status": delivery.push_status, + "ci_status": delivery.ci_status, + "merge_status": delivery.merge_status, + "last_error": delivery.last_error, + }, + "tasks": tasks, + "artifacts": artifacts, + "quality_gates": gates, + "review_findings": findings, + "ci_checks": checks, + "unresolved_risks": unresolved_risks, + })) + } + + async fn fail_provider_operation( + &self, + mut delivery: DevelopmentDeliveryRow, + error: String, + ) -> Result { + let redacted = redact_secret(&error); + delivery.status = "failed".into(); + delivery.last_error = Some(redacted.clone()); + delivery.updated_at = now_ms(); + self.persist_with_report(delivery).await?; + Err(DevelopmentError::Internal(format!( + "delivery provider rejected the operation: {redacted}" + ))) + } +} + +struct PreparedGit { + branch: String, + commit_sha: Option, + had_change: bool, +} + +fn prepare_repository( + path: &Path, + run_id: &str, + integration_branch: Option<&str>, + base_branch: &str, + message: &str, +) -> Result { + let repository = Repository::open(path) + .map_err(|error| DevelopmentError::BadRequest(format!("project is not a Git repository: {error}")))?; + if let Some(branch) = integration_branch { + validate_delivery_branch(branch, base_branch)?; + let reference = repository + .find_branch(branch, git2::BranchType::Local) + .map_err(|_| DevelopmentError::Conflict(format!("integration branch {branch} does not exist")))?; + let commit_sha = reference + .get() + .target() + .ok_or_else(|| DevelopmentError::Conflict("integration branch has no commit".into()))? + .to_string(); + return Ok(PreparedGit { + branch: branch.into(), + commit_sha: Some(commit_sha), + had_change: true, + }); + } + + let target_branch = format!("aion/run/{}/delivery", sanitize_branch_component(run_id)); + validate_delivery_branch(&target_branch, base_branch)?; + let current_branch = repository + .head() + .ok() + .and_then(|head| head.shorthand().map(str::to_owned)) + .ok_or_else(|| DevelopmentError::Conflict("delivery requires a named local branch".into()))?; + if current_branch == base_branch { + if repository.find_branch(&target_branch, git2::BranchType::Local).is_err() { + let head = repository + .head() + .and_then(|reference| reference.peel_to_commit()) + .map_err(|error| DevelopmentError::Internal(error.to_string()))?; + repository + .branch(&target_branch, &head, false) + .map_err(|error| DevelopmentError::Conflict(format!("cannot create delivery branch: {error}")))?; + } + repository + .set_head(&format!("refs/heads/{target_branch}")) + .map_err(|error| DevelopmentError::Internal(error.to_string()))?; + repository + .checkout_head(Some(CheckoutBuilder::new().safe())) + .map_err(|error| DevelopmentError::Conflict(format!("cannot safely switch to delivery branch: {error}")))?; + } else if current_branch != target_branch { + return Err(DevelopmentError::Conflict(format!( + "repository is on unrelated branch {current_branch}; expected {base_branch} or {target_branch}" + ))); + } + + let mut index = repository + .index() + .map_err(|error| DevelopmentError::Internal(error.to_string()))?; + index + .add_all(["*"].iter(), IndexAddOption::DEFAULT, None) + .map_err(|error| DevelopmentError::Internal(error.to_string()))?; + index + .update_all(["*"].iter(), None) + .map_err(|error| DevelopmentError::Internal(error.to_string()))?; + index + .write() + .map_err(|error| DevelopmentError::Internal(error.to_string()))?; + let tree_id = index + .write_tree() + .map_err(|error| DevelopmentError::Internal(error.to_string()))?; + let tree = repository + .find_tree(tree_id) + .map_err(|error| DevelopmentError::Internal(error.to_string()))?; + let parent = repository + .head() + .and_then(|reference| reference.peel_to_commit()) + .map_err(|error| DevelopmentError::Internal(error.to_string()))?; + if parent.tree_id() == tree_id { + return Ok(PreparedGit { + branch: target_branch, + commit_sha: None, + had_change: false, + }); + } + let signature = Signature::now("Aion Delivery", "delivery@aionui.local") + .map_err(|error| DevelopmentError::Internal(error.to_string()))?; + let commit = repository + .commit(Some("HEAD"), &signature, &signature, message, &tree, &[&parent]) + .map_err(|error| DevelopmentError::Internal(format!("cannot create delivery commit: {error}")))?; + Ok(PreparedGit { + branch: target_branch, + commit_sha: Some(commit.to_string()), + had_change: true, + }) +} + +fn require_confirmation(confirmed: bool, operation: &str) -> Result<(), DevelopmentError> { + if confirmed { + Ok(()) + } else { + Err(DevelopmentError::BadRequest(format!( + "explicit confirmation is required for {operation}" + ))) + } +} + +fn require_confirmation_count(confirmations: u8, operation: &str) -> Result<(), DevelopmentError> { + if confirmations >= 2 { + Ok(()) + } else { + Err(DevelopmentError::BadRequest(format!( + "two explicit confirmations are required for {operation}" + ))) + } +} + +fn validate_delivery_branch(branch: &str, base_branch: &str) -> Result<(), DevelopmentError> { + if branch == base_branch || matches!(branch, "main" | "master") { + return Err(DevelopmentError::Conflict( + "delivery cannot write directly to a protected branch".into(), + )); + } + if branch.is_empty() + || branch.len() > 240 + || branch.starts_with('-') + || branch.contains("..") + || branch.contains("@{") + || branch.ends_with('/') + || branch.chars().any(|character| { + character.is_whitespace() + || character.is_control() + || matches!(character, '~' | '^' | ':' | '?' | '*' | '[' | '\\') + }) + { + return Err(DevelopmentError::BadRequest("delivery branch name is unsafe".into())); + } + Ok(()) +} + +pub fn validate_tag_name(tag: &str) -> Result<(), DevelopmentError> { + let valid = !tag.is_empty() + && tag.len() <= 128 + && !tag.starts_with(['.', '-']) + && !tag.ends_with('.') + && !tag.contains("..") + && tag + .chars() + .all(|character| character.is_ascii_alphanumeric() || matches!(character, '.' | '-' | '_' | '/')); + if !valid { + return Err(DevelopmentError::BadRequest("invalid release tag name".into())); + } + Ok(()) +} + +fn sanitize_branch_component(value: &str) -> String { + let result = value + .chars() + .map(|character| { + if character.is_ascii_alphanumeric() || matches!(character, '-' | '_') { + character + } else { + '-' + } + }) + .collect::() + .trim_matches('-') + .chars() + .take(64) + .collect::(); + if result.is_empty() { "run".into() } else { result } +} + +fn clean_commit_message(value: &str) -> Result { + let message = value.lines().next().unwrap_or_default().trim(); + if message.is_empty() { + return Err(DevelopmentError::BadRequest("commit message cannot be empty".into())); + } + Ok(message.chars().take(200).collect()) +} + +fn clean_title(value: &str) -> Result { + let title = value.lines().next().unwrap_or_default().trim(); + if title.is_empty() { + return Err(DevelopmentError::BadRequest( + "pull request title cannot be empty".into(), + )); + } + Ok(title.chars().take(200).collect()) +} + +fn clean_summary(value: &str) -> String { + let value = value.lines().next().unwrap_or("Development delivery").trim(); + if value.is_empty() { + "Development delivery".into() + } else { + value.chars().take(160).collect() + } +} + +fn deterministic_rework_id(delivery_id: &str, check_id: &str) -> String { + let digest = Sha256::digest(format!("{delivery_id}:{check_id}").as_bytes()); + format!("ci-rework-{}", hex_prefix(&digest, 16)) +} + +fn deterministic_review_rework_id(delivery_id: &str, comment_id: &str) -> String { + let digest = Sha256::digest(format!("{delivery_id}:review:{comment_id}").as_bytes()); + format!("review-rework-{}", hex_prefix(&digest, 16)) +} + +fn hex_prefix(bytes: &[u8], length: usize) -> String { + bytes + .iter() + .flat_map(|byte| format!("{byte:02x}").chars().collect::>()) + .take(length) + .collect() +} + +fn normalize_check_status(status: &str) -> String { + match status.to_ascii_lowercase().as_str() { + "success" | "passed" => "passed", + "failure" | "failed" | "error" | "timed_out" | "action_required" => "failed", + "cancelled" => "cancelled", + "skipped" | "neutral" => "skipped", + "in_progress" | "pending" => "in_progress", + _ => "queued", + } + .into() +} + +fn aggregate_ci_status(checks: &[ProviderCiCheck]) -> &'static str { + if checks + .iter() + .any(|check| normalize_check_status(&check.status) == "failed") + { + "failed" + } else if !checks.is_empty() + && checks + .iter() + .all(|check| matches!(normalize_check_status(&check.status).as_str(), "passed" | "skipped")) + { + "passed" + } else { + "pending" + } +} + +fn redact_secret(value: &str) -> String { + let mut words = redact_sensitive(value, &[]); + if words.len() > 2000 { + words.truncate(2000); + } + words +} diff --git a/crates/aionui-development/src/deployment.rs b/crates/aionui-development/src/deployment.rs new file mode 100644 index 000000000..453f3130b --- /dev/null +++ b/crates/aionui-development/src/deployment.rs @@ -0,0 +1,478 @@ +use std::sync::Arc; + +use aionui_common::now_ms; +use aionui_db::models::DevelopmentDeploymentRow; +use aionui_db::{IDevelopmentRepository, IProjectRepository}; +use async_trait::async_trait; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; + +use crate::DevelopmentError; +use crate::operations::{DevelopmentOperationsService, redact_sensitive}; +use crate::policy::{PolicyDecision, PolicyOperation}; + +const DEPLOYMENT_APPROVAL_TTL_MS: i64 = 15 * 60 * 1000; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct DeploymentRequestInput { + pub environment: String, + pub deployment_key: String, + pub commit_sha: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct DeploymentExecution { + pub deployment_id: String, + pub deployment_key: String, + pub run_id: String, + pub project_id: String, + pub environment: String, + pub commit_sha: String, +} + +#[async_trait] +pub trait DeploymentProvider: Send + Sync { + async fn deploy(&self, execution: &DeploymentExecution) -> Result, String>; + async fn cancel(&self, remote_id: &str) -> Result<(), String>; +} + +#[derive(Debug, Clone, Default)] +pub struct UnconfiguredDeploymentProvider; + +#[async_trait] +impl DeploymentProvider for UnconfiguredDeploymentProvider { + async fn deploy(&self, _execution: &DeploymentExecution) -> Result, String> { + Err("deployment provider is not configured for this installation".into()) + } + + async fn cancel(&self, _remote_id: &str) -> Result<(), String> { + Err("deployment provider is not configured for this installation".into()) + } +} + +#[derive(Clone)] +pub struct DeploymentService { + development_repo: Arc, + project_repo: Arc, + provider: Arc, + operations: Option>, +} + +impl DeploymentService { + pub fn new( + development_repo: Arc, + project_repo: Arc, + provider: Arc, + ) -> Self { + Self { + development_repo, + project_repo, + provider, + operations: None, + } + } + + pub fn with_operations(mut self, operations: Arc) -> Self { + self.operations = Some(operations); + self + } + + pub async fn request( + &self, + user_id: &str, + run_id: &str, + input: DeploymentRequestInput, + ) -> Result { + validate_identifier("environment", &input.environment)?; + validate_identifier("deployment key", &input.deployment_key)?; + validate_commit(&input.commit_sha)?; + + if let Some(existing) = self + .development_repo + .get_deployment_by_key(user_id, &input.deployment_key) + .await? + { + if existing.run_id != run_id + || existing.environment != input.environment + || existing.commit_sha != input.commit_sha + { + return Err(DevelopmentError::Conflict( + "deployment idempotency key belongs to a different immutable request".into(), + )); + } + return Ok(existing); + } + + let run = self + .development_repo + .get_run(run_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("run {run_id}")))?; + self.project_repo + .get_for_user(&run.project_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("project {}", run.project_id)))?; + let delivery = self + .development_repo + .get_delivery(user_id, run_id) + .await? + .ok_or_else(|| DevelopmentError::Conflict("run has no delivery record".into()))?; + if delivery.status != "merged" + || delivery.merge_status != "merged" + || delivery.ci_status != "passed" + || delivery.review_status != "approved" + { + return Err(DevelopmentError::Conflict( + "deployment requires a merged, reviewed delivery with passing CI".into(), + )); + } + if delivery.commit_sha.as_deref() != Some(input.commit_sha.as_str()) { + return Err(DevelopmentError::Conflict( + "deployment commit does not match the immutable delivery commit".into(), + )); + } + + let now = now_ms(); + let row = DevelopmentDeploymentRow { + id: uuid::Uuid::now_v7().to_string(), + deployment_key: input.deployment_key.clone(), + run_id: run_id.into(), + project_id: run.project_id, + user_id: user_id.into(), + environment: input.environment.clone(), + commit_sha: input.commit_sha.clone(), + status: "pending_approval".into(), + requested_by: user_id.into(), + approved_by: None, + approval_run_id: run_id.into(), + approval_environment: input.environment, + approval_commit_sha: input.commit_sha, + approval_requester: user_id.into(), + approval_deployment_key: input.deployment_key, + approval_expires_at: now + DEPLOYMENT_APPROVAL_TTL_MS, + approved_at: None, + remote_id: None, + attempt_count: 0, + last_error: None, + started_at: None, + finished_at: None, + created_at: now, + updated_at: now, + }; + if !self.development_repo.create_deployment(&row).await? { + return self + .development_repo + .get_deployment_by_key(user_id, &row.deployment_key) + .await? + .ok_or_else(|| DevelopmentError::Conflict("deployment request is already being created".into())); + } + self.audit(&row, "deployment.request", "success", json!({"status": row.status})) + .await?; + Ok(row) + } + + pub async fn get(&self, user_id: &str, deployment_id: &str) -> Result { + self.development_repo + .get_deployment(user_id, deployment_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("deployment {deployment_id}"))) + } + + pub async fn list(&self, user_id: &str, run_id: &str) -> Result, DevelopmentError> { + self.development_repo + .get_run(run_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("run {run_id}")))?; + Ok(self.development_repo.list_deployments(user_id, run_id).await?) + } + + pub async fn approve( + &self, + user_id: &str, + run_id: &str, + deployment_id: &str, + confirmation_count: u8, + ) -> Result { + if confirmation_count < 2 { + return Err(DevelopmentError::BadRequest( + "deployment approval requires two explicit human confirmations".into(), + )); + } + let row = self.get(user_id, deployment_id).await?; + require_run_scope(&row, run_id)?; + if let Some(operations) = &self.operations { + let decision = operations + .evaluate_policy( + user_id, + &row.project_id, + &row.run_id, + &PolicyOperation::Deploy { + target: row.environment.clone(), + }, + confirmation_count, + ) + .await?; + if decision != PolicyDecision::Allowed { + return Err(DevelopmentError::BadRequest( + "deployment approval does not satisfy the Project policy".into(), + )); + } + } + if row.status == "approved" { + return Ok(row); + } + if row.status != "pending_approval" || row.approval_expires_at <= now_ms() { + return Err(DevelopmentError::Conflict( + "deployment approval is no longer pending or has expired".into(), + )); + } + if !self + .development_repo + .approve_deployment(user_id, deployment_id, now_ms()) + .await? + { + return Err(DevelopmentError::Conflict( + "deployment approval was not consumed".into(), + )); + } + let approved = self.get(user_id, deployment_id).await?; + self.audit( + &approved, + "deployment.approve", + "success", + json!({"confirmation_count": confirmation_count, "expires_at": approved.approval_expires_at}), + ) + .await?; + Ok(approved) + } + + pub async fn execute( + &self, + user_id: &str, + run_id: &str, + deployment_id: &str, + ) -> Result { + let row = self.get(user_id, deployment_id).await?; + require_run_scope(&row, run_id)?; + if matches!(row.status.as_str(), "running" | "succeeded") { + return Ok(row); + } + validate_approval_binding(&row, user_id)?; + if let Some(operations) = &self.operations { + operations + .require_budget(user_id, &row.run_id, "deployment.execute", row.attempt_count) + .await?; + } + let now = now_ms(); + if !self + .development_repo + .claim_deployment(user_id, deployment_id, now) + .await? + { + let current = self.get(user_id, deployment_id).await?; + if matches!(current.status.as_str(), "running" | "succeeded") { + return Ok(current); + } + return Err(DevelopmentError::Conflict("deployment could not be claimed".into())); + } + + let execution = DeploymentExecution { + deployment_id: row.id.clone(), + deployment_key: row.deployment_key.clone(), + run_id: row.run_id.clone(), + project_id: row.project_id.clone(), + environment: row.environment.clone(), + commit_sha: row.commit_sha.clone(), + }; + match self.provider.deploy(&execution).await { + Ok(remote_id) => { + self.development_repo + .update_deployment_result( + user_id, + deployment_id, + "succeeded", + remote_id.as_deref(), + None, + now_ms(), + ) + .await?; + let completed = self.get(user_id, deployment_id).await?; + self.audit( + &completed, + "deployment.execute", + "success", + json!({"status": completed.status, "attempt_count": completed.attempt_count}), + ) + .await?; + } + Err(error) => { + let error = redact_sensitive(&error, &[]); + self.development_repo + .update_deployment_result(user_id, deployment_id, "failed", None, Some(&error), now_ms()) + .await?; + let failed = self.get(user_id, deployment_id).await?; + self.audit( + &failed, + "deployment.execute", + "failed", + json!({"status": failed.status, "error": error}), + ) + .await?; + return Err(DevelopmentError::Internal(error)); + } + } + let cancelled = self.get(user_id, deployment_id).await?; + self.audit( + &cancelled, + "deployment.cancel", + "success", + json!({"status": cancelled.status}), + ) + .await?; + Ok(cancelled) + } + + pub async fn cancel( + &self, + user_id: &str, + run_id: &str, + deployment_id: &str, + confirmed: bool, + ) -> Result { + if !confirmed { + return Err(DevelopmentError::BadRequest( + "deployment cancellation requires confirmation".into(), + )); + } + let row = self.get(user_id, deployment_id).await?; + require_run_scope(&row, run_id)?; + if row.status == "cancelled" { + return Ok(row); + } + if matches!(row.status.as_str(), "succeeded" | "failed") { + return Err(DevelopmentError::Conflict( + "completed deployment cannot be cancelled".into(), + )); + } + if let Some(remote_id) = row.remote_id.as_deref() { + self.provider + .cancel(remote_id) + .await + .map_err(|error| DevelopmentError::Internal(redact_sensitive(&error, &[])))?; + } + self.development_repo + .update_deployment_result(user_id, deployment_id, "cancelled", None, None, now_ms()) + .await?; + self.get(user_id, deployment_id).await + } + + pub async fn recover_stale( + &self, + user_id: &str, + run_id: &str, + stale_after_ms: i64, + ) -> Result, DevelopmentError> { + let now = now_ms(); + let rows = self.list(user_id, run_id).await?; + for row in rows + .iter() + .filter(|row| row.status == "running" && row.updated_at.saturating_add(stale_after_ms.max(0)) <= now) + { + self.development_repo + .update_deployment_result( + user_id, + &row.id, + "unknown_remote_state", + None, + Some("process restarted while deployment was running"), + now, + ) + .await?; + let recovered = self.get(user_id, &row.id).await?; + self.audit( + &recovered, + "deployment.recover", + "unknown_remote_state", + json!({"status": recovered.status}), + ) + .await?; + } + self.list(user_id, run_id).await + } + + async fn audit( + &self, + row: &DevelopmentDeploymentRow, + action: &str, + result: &str, + payload: Value, + ) -> Result<(), DevelopmentError> { + if let Some(operations) = &self.operations { + operations + .audit( + &row.user_id, + "user", + &row.user_id, + action, + "deployment", + &row.id, + &row.project_id, + Some(&row.run_id), + None, + result, + payload, + &[], + ) + .await?; + } + Ok(()) + } +} + +fn validate_approval_binding(row: &DevelopmentDeploymentRow, user_id: &str) -> Result<(), DevelopmentError> { + let valid = row.status == "approved" + && row.approved_by.as_deref() == Some(user_id) + && row.approved_at.is_some() + && row.approval_expires_at > now_ms() + && row.approval_run_id == row.run_id + && row.approval_environment == row.environment + && row.approval_commit_sha == row.commit_sha + && row.approval_requester == row.requested_by + && row.approval_requester == user_id + && row.approval_deployment_key == row.deployment_key; + if !valid { + return Err(DevelopmentError::Conflict( + "deployment approval is missing, expired, or does not match the immutable request".into(), + )); + } + Ok(()) +} + +fn require_run_scope(row: &DevelopmentDeploymentRow, run_id: &str) -> Result<(), DevelopmentError> { + if row.run_id != run_id { + return Err(DevelopmentError::NotFound(format!( + "deployment {} for run {run_id}", + row.id + ))); + } + Ok(()) +} + +fn validate_identifier(label: &str, value: &str) -> Result<(), DevelopmentError> { + let valid = !value.is_empty() + && value.len() <= 128 + && value + .chars() + .all(|character| character.is_ascii_alphanumeric() || matches!(character, '-' | '_' | '.' | '/')); + if !valid { + return Err(DevelopmentError::BadRequest(format!("invalid {label}"))); + } + Ok(()) +} + +fn validate_commit(value: &str) -> Result<(), DevelopmentError> { + if value.len() < 7 || value.len() > 64 || !value.chars().all(|character| character.is_ascii_hexdigit()) { + return Err(DevelopmentError::BadRequest("invalid deployment commit SHA".into())); + } + Ok(()) +} diff --git a/crates/aionui-development/src/error.rs b/crates/aionui-development/src/error.rs new file mode 100644 index 000000000..15f571405 --- /dev/null +++ b/crates/aionui-development/src/error.rs @@ -0,0 +1,29 @@ +use aionui_db::DbError; + +#[derive(Debug, thiserror::Error)] +pub enum DevelopmentError { + #[error("Invalid development request: {0}")] + BadRequest(String), + #[error("Development resource not found: {0}")] + NotFound(String), + #[error("Development operation conflicts with current state: {0}")] + Conflict(String), + #[error("Development operation failed: {0}")] + Internal(String), +} + +impl From for DevelopmentError { + fn from(value: DbError) -> Self { + match value { + DbError::NotFound(message) => Self::NotFound(message), + DbError::Conflict(message) => Self::Conflict(message), + other => Self::Internal(other.to_string()), + } + } +} + +impl From for DevelopmentError { + fn from(value: std::io::Error) -> Self { + Self::Internal(value.to_string()) + } +} diff --git a/crates/aionui-development/src/executor.rs b/crates/aionui-development/src/executor.rs new file mode 100644 index 000000000..02f4b9207 --- /dev/null +++ b/crates/aionui-development/src/executor.rs @@ -0,0 +1,489 @@ +use std::collections::{BTreeMap, BTreeSet}; +use std::path::{Component, Path, PathBuf}; +use std::process::Stdio; + +use aionui_db::models::{DevelopmentPolicyRow, ProjectRuntimeProfileRow}; +use aionui_runtime::{Builder, ProcessLeaseSpec}; +use serde::{Deserialize, Serialize}; +use tokio::io::AsyncReadExt; +use zeroize::Zeroize; + +use crate::DevelopmentError; +use crate::operations::redact_sensitive; +use crate::resources::{ResourceLeaseCoordinator, ResourceLeaseInput}; + +const MAX_OUTPUT_BYTES: usize = 1024 * 1024; + +#[derive(Debug)] +pub struct CommandExecutionInput<'a> { + pub execution_id: &'a str, + pub run_id: &'a str, + pub command: &'a str, + pub working_directory: &'a Path, + pub timeout_seconds: i64, + pub policy: &'a DevelopmentPolicyRow, + pub runtime_profile: Option<&'a ProjectRuntimeProfileRow>, + pub environment: BTreeMap, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct ExecutionCommandSpec { + pub program: String, + pub args: Vec, + pub working_directory: PathBuf, + pub environment: BTreeMap, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct CommandExecutionPlan { + pub execution_id: String, + pub isolation_mode: String, + pub environment_id: String, + pub steps: Vec, + pub cleanup: Option, + pub resources: Vec, + #[serde(skip)] + secret_values: Vec, +} + +impl Drop for CommandExecutionPlan { + fn drop(&mut self) { + for value in &mut self.secret_values { + value.zeroize(); + } + for step in &mut self.steps { + step.environment.values_mut().for_each(Zeroize::zeroize); + } + if let Some(cleanup) = &mut self.cleanup { + cleanup.environment.values_mut().for_each(Zeroize::zeroize); + } + } +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct PlannedExecutionResource { + pub resource_kind: String, + pub resource_identifier: String, + pub cleanup_order: i64, +} + +pub(crate) struct ManagedExecutionContext<'a> { + pub user_id: &'a str, + pub project_id: &'a str, + pub run_id: &'a str, + pub task_id: Option<&'a str>, + pub turn_id: Option<&'a str>, + pub gate_id: Option<&'a str>, + pub resources: &'a ResourceLeaseCoordinator, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct CommandExecutionOutput { + pub status: String, + pub exit_code: Option, + pub stdout: String, + pub stderr: String, + pub isolation_mode: String, + pub execution_id: String, +} + +pub fn build_execution_plan(input: &CommandExecutionInput<'_>) -> Result { + if input.timeout_seconds <= 0 { + return Err(DevelopmentError::BadRequest("command timeout must be positive".into())); + } + if input.command.trim().is_empty() { + return Err(DevelopmentError::BadRequest("command must not be empty".into())); + } + let workspace = input + .working_directory + .canonicalize() + .map_err(|error| DevelopmentError::BadRequest(format!("working directory is unavailable: {error}")))?; + if !workspace.is_dir() { + return Err(DevelopmentError::BadRequest( + "working directory is not a directory".into(), + )); + } + let (secret_environment, secret_values) = selected_secret_environment(input)?; + let execution_name = safe_execution_name(input.execution_id); + + match input.policy.isolation_mode.as_str() { + "host" => Ok(CommandExecutionPlan { + execution_id: input.execution_id.into(), + isolation_mode: "host".into(), + environment_id: "host:local".into(), + steps: vec![host_command(input.command, &workspace, &secret_environment)], + cleanup: None, + resources: Vec::new(), + secret_values, + }), + "docker" => { + let image = input + .policy + .container_image + .as_deref() + .map(str::trim) + .filter(|value| !value.is_empty()) + .ok_or_else(|| DevelopmentError::BadRequest("docker policy requires a container image".into()))?; + let container_name = format!("aion-{execution_name}"); + let mut args = vec![ + "run".into(), + "--rm".into(), + "--init".into(), + "--name".into(), + container_name.clone(), + "--label".into(), + format!("aion.run={}", safe_execution_name(input.run_id)), + "--security-opt".into(), + "no-new-privileges".into(), + "--cap-drop".into(), + "ALL".into(), + "--pids-limit".into(), + input.policy.container_pids_limit.to_string(), + "--cpus".into(), + format!("{:.3}", input.policy.container_cpu_millis as f64 / 1000.0), + "--memory".into(), + format!("{}m", input.policy.container_memory_mb), + "--network".into(), + input.policy.network_mode.clone(), + "--workdir".into(), + "/workspace".into(), + "--volume".into(), + format!("{}:/workspace:rw", workspace.display()), + ]; + for key in secret_environment.keys() { + args.push("--env".into()); + args.push(key.clone()); + } + args.extend([image.into(), "sh".into(), "-lc".into(), input.command.into()]); + Ok(CommandExecutionPlan { + execution_id: input.execution_id.into(), + isolation_mode: "docker".into(), + environment_id: format!("docker:{container_name}"), + steps: vec![ExecutionCommandSpec { + program: "docker".into(), + args, + working_directory: workspace.clone(), + environment: secret_environment, + }], + cleanup: Some(ExecutionCommandSpec { + program: "docker".into(), + args: vec!["rm".into(), "--force".into(), container_name.clone()], + working_directory: workspace, + environment: BTreeMap::new(), + }), + resources: vec![PlannedExecutionResource { + resource_kind: "container".into(), + resource_identifier: container_name, + cleanup_order: 40, + }], + secret_values, + }) + } + "devcontainer" => { + let relative_config = input + .policy + .devcontainer_config_path + .as_deref() + .map(str::trim) + .filter(|value| !value.is_empty()) + .ok_or_else(|| DevelopmentError::BadRequest("devcontainer policy requires a config path".into()))?; + let relative_path = Path::new(relative_config); + if relative_path.is_absolute() + || relative_path + .components() + .any(|component| component == Component::ParentDir) + { + return Err(DevelopmentError::BadRequest( + "devcontainer config must stay inside the project".into(), + )); + } + let config = workspace.join(relative_path).canonicalize().map_err(|error| { + DevelopmentError::BadRequest(format!("devcontainer config is unavailable: {error}")) + })?; + if !config.starts_with(&workspace) || config.extension().and_then(|value| value.to_str()) != Some("json") { + return Err(DevelopmentError::BadRequest( + "devcontainer config must be a JSON file inside the project".into(), + )); + } + let common = vec![ + "--workspace-folder".into(), + workspace.to_string_lossy().into_owned(), + "--config".into(), + config.to_string_lossy().into_owned(), + ]; + let mut up = vec!["up".into()]; + up.extend(common.clone()); + let mut exec = vec!["exec".into()]; + exec.extend(common); + exec.extend(["sh".into(), "-lc".into(), input.command.into()]); + let service_identifier = workspace.to_string_lossy().into_owned(); + Ok(CommandExecutionPlan { + execution_id: input.execution_id.into(), + isolation_mode: "devcontainer".into(), + environment_id: format!("devcontainer:{execution_name}"), + steps: vec![ + ExecutionCommandSpec { + program: "devcontainer".into(), + args: up, + working_directory: workspace.clone(), + environment: BTreeMap::new(), + }, + ExecutionCommandSpec { + program: "devcontainer".into(), + args: exec, + working_directory: workspace, + environment: BTreeMap::new(), + }, + ], + cleanup: None, + resources: vec![PlannedExecutionResource { + resource_kind: "service".into(), + resource_identifier: service_identifier, + cleanup_order: 30, + }], + secret_values, + }) + } + other => Err(DevelopmentError::BadRequest(format!( + "unsupported isolation mode: {other}" + ))), + } +} + +pub async fn execute_command(mut input: CommandExecutionInput<'_>) -> Result { + let timeout_seconds = input.timeout_seconds; + let plan = build_execution_plan(&input)?; + input.environment.values_mut().for_each(Zeroize::zeroize); + execute_plan(&plan, timeout_seconds, None).await +} + +pub(crate) async fn execute_plan( + plan: &CommandExecutionPlan, + timeout_seconds: i64, + context: Option<&ManagedExecutionContext<'_>>, +) -> Result { + let mut stdout = String::new(); + let mut stderr = String::new(); + let mut final_status = "passed".to_owned(); + let mut final_exit_code = Some(0); + for step in &plan.steps { + let output = execute_step(step, plan, timeout_seconds, context).await?; + append_bounded(&mut stdout, &output.stdout); + append_bounded(&mut stderr, &output.stderr); + final_status = output.status; + final_exit_code = output.exit_code; + if final_status != "passed" { + if final_status == "timed_out" + && let Some(cleanup) = &plan.cleanup + { + let _ = execute_step(cleanup, plan, 15, context).await; + } + break; + } + } + Ok(CommandExecutionOutput { + status: final_status, + exit_code: final_exit_code, + stdout: redact_sensitive(&stdout, &plan.secret_values), + stderr: redact_sensitive(&stderr, &plan.secret_values), + isolation_mode: plan.isolation_mode.clone(), + execution_id: plan.execution_id.clone(), + }) +} + +struct StepOutput { + status: String, + exit_code: Option, + stdout: String, + stderr: String, +} + +async fn execute_step( + spec: &ExecutionCommandSpec, + plan: &CommandExecutionPlan, + timeout_seconds: i64, + context: Option<&ManagedExecutionContext<'_>>, +) -> Result { + let mut command = Builder::new(&spec.program); + command + .args(&spec.args) + .current_dir(&spec.working_directory) + .envs(&spec.environment) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + let mut child = command + .spawn_leased(ProcessLeaseSpec::new( + format!("{}:process", plan.execution_id), + &plan.environment_id, + std::time::Duration::from_secs(timeout_seconds.max(1) as u64), + )) + .map_err(|error| DevelopmentError::BadRequest(format!("{} is unavailable: {error}", spec.program)))?; + let mut process_resource = match context { + Some(context) => { + let pid = child + .id() + .ok_or_else(|| DevelopmentError::Internal("spawned process has no pid".into()))?; + let created = context + .resources + .create(ResourceLeaseInput { + user_id: context.user_id.into(), + project_id: context.project_id.into(), + run_id: context.run_id.into(), + task_id: context.task_id.map(str::to_owned), + turn_id: context.turn_id.map(str::to_owned), + gate_id: context.gate_id.map(str::to_owned), + environment_id: plan.environment_id.clone(), + environment_kind: plan.isolation_mode.clone(), + resource_kind: "process".into(), + resource_identifier: pid.to_string(), + cleanup_order: 20, + ttl_ms: timeout_seconds.max(1).saturating_mul(1000), + }) + .await; + match created { + Ok(resource) => Some(resource), + Err(error) => { + let _ = child.terminate_tree().await; + return Err(error); + } + } + } + None => None, + }; + let stdout = match child.stdout.take() { + Some(stdout) => stdout, + None => { + let _ = child.terminate_tree().await; + return Err(DevelopmentError::Internal("stdout pipe missing".into())); + } + }; + let stderr = match child.stderr.take() { + Some(stderr) => stderr, + None => { + let _ = child.terminate_tree().await; + return Err(DevelopmentError::Internal("stderr pipe missing".into())); + } + }; + let stdout_task = tokio::spawn(read_bounded(stdout)); + let stderr_task = tokio::spawn(read_bounded(stderr)); + let started = std::time::Instant::now(); + let mut last_persisted_heartbeat = started; + let (status, exit_code): (String, Option) = loop { + if let Some(status) = child.try_wait()? { + break ( + if status.success() { "passed" } else { "failed" }.into(), + status.code().map(i64::from), + ); + } + if started.elapsed() >= std::time::Duration::from_secs(timeout_seconds.max(1) as u64) { + child.terminate_tree().await?; + break ("timed_out".into(), None); + } + child.lease().heartbeat(); + if last_persisted_heartbeat.elapsed() >= std::time::Duration::from_secs(5) + && let (Some(context), Some(resource)) = (context, process_resource.as_mut()) + { + if let Err(error) = context + .resources + .heartbeat(resource, timeout_seconds.max(1).saturating_mul(1000)) + .await + { + let _ = child.terminate_tree().await; + return Err(error); + } + last_persisted_heartbeat = std::time::Instant::now(); + } + tokio::time::sleep(std::time::Duration::from_millis(100)).await; + }; + if let (Some(context), Some(resource)) = (context, process_resource.as_ref()) { + context.resources.complete(resource, &status).await?; + } + Ok(StepOutput { + status, + exit_code, + stdout: stdout_task + .await + .map_err(|error| DevelopmentError::Internal(error.to_string()))??, + stderr: stderr_task + .await + .map_err(|error| DevelopmentError::Internal(error.to_string()))??, + }) +} + +fn host_command(command: &str, workspace: &Path, environment: &BTreeMap) -> ExecutionCommandSpec { + #[cfg(unix)] + let (program, args) = ("sh", vec!["-lc".into(), command.into()]); + #[cfg(windows)] + let (program, args) = ("cmd", vec!["/C".into(), command.into()]); + ExecutionCommandSpec { + program: program.into(), + args, + working_directory: workspace.into(), + environment: environment.clone(), + } +} + +fn selected_secret_environment( + input: &CommandExecutionInput<'_>, +) -> Result<(BTreeMap, Vec), DevelopmentError> { + let policy_keys: BTreeSet = serde_json::from_str(&input.policy.allowed_secret_keys_json) + .map_err(|error| DevelopmentError::BadRequest(format!("invalid policy Secret keys: {error}")))?; + let runtime_keys: BTreeSet = match input.runtime_profile { + Some(profile) => serde_json::from_str(&profile.env_keys) + .map_err(|error| DevelopmentError::BadRequest(format!("invalid runtime env keys: {error}")))?, + None => policy_keys.clone(), + }; + let selected = policy_keys + .intersection(&runtime_keys) + .filter_map(|key| input.environment.get(key).map(|value| (key.clone(), value.clone()))) + .collect::>(); + let values = selected.values().filter(|value| !value.is_empty()).cloned().collect(); + Ok((selected, values)) +} + +fn safe_execution_name(value: &str) -> String { + let mut result = value + .chars() + .map(|character| { + if character.is_ascii_alphanumeric() || matches!(character, '-' | '_') { + character.to_ascii_lowercase() + } else { + '-' + } + }) + .collect::(); + result.truncate(48); + let result = result.trim_matches('-'); + if result.is_empty() { + "execution".into() + } else { + result.into() + } +} + +async fn read_bounded(mut reader: R) -> Result { + let mut collected = Vec::new(); + let mut buffer = [0_u8; 8192]; + loop { + let count = reader.read(&mut buffer).await?; + if count == 0 { + break; + } + if collected.len() < MAX_OUTPUT_BYTES { + let remaining = MAX_OUTPUT_BYTES - collected.len(); + collected.extend_from_slice(&buffer[..count.min(remaining)]); + } + } + Ok(String::from_utf8_lossy(&collected).into_owned()) +} + +fn append_bounded(target: &mut String, value: &str) { + if target.len() >= MAX_OUTPUT_BYTES { + return; + } + if !target.is_empty() && !value.is_empty() { + target.push('\n'); + } + let remaining = MAX_OUTPUT_BYTES.saturating_sub(target.len()); + target.push_str(&value[..value.floor_char_boundary(remaining.min(value.len()))]); +} diff --git a/crates/aionui-development/src/export.rs b/crates/aionui-development/src/export.rs new file mode 100644 index 000000000..e505e8f25 --- /dev/null +++ b/crates/aionui-development/src/export.rs @@ -0,0 +1,1651 @@ +use std::collections::{BTreeMap, BTreeSet}; +use std::io::ErrorKind; +use std::path::{Component, Path, PathBuf}; + +use aionui_api_types::{ + DevelopmentEvaluation, EvaluationComparison, EvaluationComparisonRequest, EvaluationRecordInput, + EvaluationRegression, ImportProjectBundleRequest, PlatformInstanceSummary, ProjectExportBundle, + ProjectExportManifest, ProjectImportReport, +}; +use aionui_common::now_ms; +use aionui_db::SqlitePool; +use ed25519_dalek::{Signature, Signer, SigningKey, Verifier, VerifyingKey}; +use serde_json::Value; +use sha2::{Digest, Sha256}; +use sqlx::{Row, Sqlite, Transaction}; + +use crate::DevelopmentError; + +const FORMAT_VERSION: u32 = 1; +const SCHEMA_VERSION: i64 = 34; +const APP_VERSION: &str = env!("CARGO_PKG_VERSION"); + +#[derive(Clone)] +pub struct PortabilityService { + pool: SqlitePool, + signing_key: SigningKey, + trusted_signers: BTreeSet, + instance_fallback: String, +} + +impl PortabilityService { + pub fn new(pool: SqlitePool, signing_secret: &[u8], instance_fallback: impl Into) -> Self { + let digest = Sha256::digest(signing_secret); + let mut bytes = [0_u8; 32]; + bytes.copy_from_slice(&digest); + let signing_key = SigningKey::from_bytes(&bytes); + let trusted_signers = BTreeSet::from([hex::encode(signing_key.verifying_key().to_bytes())]); + Self { + pool, + signing_key, + trusted_signers, + instance_fallback: instance_fallback.into(), + } + } + + pub fn trust_signer(&mut self, public_key: &str) -> Result<(), DevelopmentError> { + let bytes = hex::decode(public_key) + .map_err(|_| DevelopmentError::BadRequest("invalid trusted signer public key encoding".into()))?; + let bytes: [u8; 32] = bytes + .try_into() + .map_err(|_| DevelopmentError::BadRequest("invalid trusted signer public key".into()))?; + VerifyingKey::from_bytes(&bytes) + .map_err(|_| DevelopmentError::BadRequest("invalid trusted signer public key".into()))?; + self.trusted_signers.insert(hex::encode(bytes)); + Ok(()) + } + + pub fn signer_public_key(&self) -> String { + hex::encode(self.signing_key.verifying_key().to_bytes()) + } + + pub async fn export_project( + &self, + user_id: &str, + project_id: &str, + ) -> Result { + let owned: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM projects WHERE id = ? AND user_id = ?") + .bind(project_id) + .bind(user_id) + .fetch_one(&self.pool) + .await + .map_err(internal)?; + if owned != 1 { + return Err(DevelopmentError::NotFound(format!("project {project_id}"))); + } + + let mut records = BTreeMap::new(); + records.insert( + "projects".into(), + fetch_json( + &self.pool, + "SELECT json_object('id',id,'user_id',user_id,'name',name,'local_path',local_path,\ + 'repository_url',repository_url,'default_branch',default_branch,'project_type',project_type,\ + 'created_at',created_at,'updated_at',updated_at) FROM projects WHERE id=? AND user_id=?", + &[project_id, user_id], + ) + .await?, + ); + records.insert( + "project_command_profiles".into(), + fetch_json( + &self.pool, + "SELECT json_object('project_id',project_id,'install_command',install_command,'format_command',format_command,\ + 'lint_command',lint_command,'typecheck_command',typecheck_command,'unit_test_command',unit_test_command,\ + 'integration_test_command',integration_test_command,'e2e_command',e2e_command,'build_command',build_command,\ + 'security_scan_command',security_scan_command,'command_timeout_seconds',command_timeout_seconds,\ + 'updated_at',updated_at) FROM project_command_profiles WHERE project_id=?", + &[project_id], + ) + .await?, + ); + records.insert( + "project_runtime_profiles".into(), + fetch_json( + &self.pool, + "SELECT json_object('project_id',project_id,'environment_kind',environment_kind,'language',language,\ + 'package_manager',package_manager,'runtime_version',runtime_version,'env_keys',env_keys,\ + 'metadata',metadata,'updated_at',updated_at) FROM project_runtime_profiles WHERE project_id=?", + &[project_id], + ) + .await?, + ); + records.insert( + "project_resource_links".into(), + fetch_json( + &self.pool, + "SELECT json_object('project_id',project_id,'user_id',user_id,'resource_type',resource_type,\ + 'resource_id',resource_id,'created_at',created_at) FROM project_resource_links \ + WHERE project_id=? AND user_id=? AND resource_type IN ('conversation','team')", + &[project_id, user_id], + ) + .await?, + ); + records.insert( + "conversations".into(), + fetch_json( + &self.pool, + "SELECT json_object('id',c.id,'user_id',c.user_id,'name',c.name,'type',c.type,'extra',c.extra,\ + 'model',c.model,'status',c.status,'source',c.source,'channel_chat_id',c.channel_chat_id,\ + 'pinned',c.pinned,'pinned_at',c.pinned_at,'created_at',c.created_at,'updated_at',c.updated_at) \ + FROM conversations c JOIN project_resource_links l ON l.resource_type='conversation' AND l.resource_id=c.id \ + WHERE l.project_id=? AND l.user_id=? ORDER BY c.created_at,c.id", + &[project_id, user_id], + ) + .await?, + ); + records.insert( + "messages".into(), + fetch_json( + &self.pool, + "SELECT json_object('id',m.id,'conversation_id',m.conversation_id,'msg_id',m.msg_id,'type',m.type,\ + 'content',m.content,'position',m.position,'status',m.status,'hidden',m.hidden,'created_at',m.created_at) \ + FROM messages m JOIN project_resource_links l ON l.resource_type='conversation' AND l.resource_id=m.conversation_id \ + WHERE l.project_id=? AND l.user_id=? ORDER BY m.created_at,m.id", + &[project_id, user_id], + ) + .await?, + ); + records.insert( + "teams".into(), + fetch_json( + &self.pool, + "SELECT json_object('id',t.id,'user_id',t.user_id,'name',t.name,'workspace',t.workspace,\ + 'workspace_mode',t.workspace_mode,'agents',t.agents,'lead_agent_id',t.lead_agent_id,\ + 'session_mode',t.session_mode,'agents_version',t.agents_version,'created_at',t.created_at,'updated_at',t.updated_at) \ + FROM teams t JOIN project_resource_links l ON l.resource_type='team' AND l.resource_id=t.id \ + WHERE l.project_id=? AND l.user_id=? ORDER BY t.created_at,t.id", + &[project_id, user_id], + ) + .await?, + ); + records.insert( + "assistant_users".into(), + fetch_json( + &self.pool, + "SELECT DISTINCT json_object('id',u.id,'platform_user_id',u.platform_user_id,'platform_type',u.platform_type) \ + FROM assistant_users u JOIN assistant_sessions s ON s.user_id=u.id \ + JOIN project_resource_links l ON l.resource_type='conversation' AND l.resource_id=s.conversation_id \ + WHERE l.project_id=? AND l.user_id=? ORDER BY u.id", + &[project_id, user_id], + ) + .await?, + ); + records.insert( + "assistant_sessions".into(), + fetch_json( + &self.pool, + "SELECT json_object('id',s.id,'user_id',s.user_id,'agent_type',s.agent_type,\ + 'conversation_id',s.conversation_id,'workspace',s.workspace,'chat_id',s.chat_id,\ + 'message_thread_id',s.message_thread_id,'bound_agent_id',s.bound_agent_id,\ + 'bound_backend',s.bound_backend,'bound_provider_id',s.bound_provider_id,'bound_model',s.bound_model,\ + 'created_at',s.created_at,'last_activity',s.last_activity) \ + FROM assistant_sessions s JOIN project_resource_links l \ + ON l.resource_type='conversation' AND l.resource_id=s.conversation_id \ + WHERE l.project_id=? AND l.user_id=? ORDER BY s.created_at,s.id", + &[project_id, user_id], + ) + .await?, + ); + records.insert( + "telegram_topic_bindings".into(), + fetch_json( + &self.pool, + "SELECT DISTINCT json_object('chat_id',b.chat_id,'message_thread_id',b.message_thread_id,\ + 'agent_id',b.agent_id,'bound_by_user_id',b.bound_by_user_id,'created_at',b.created_at,'updated_at',b.updated_at) \ + FROM telegram_topic_bindings b JOIN assistant_sessions s \ + ON s.chat_id=b.chat_id AND s.message_thread_id=b.message_thread_id \ + JOIN project_resource_links l ON l.resource_type='conversation' AND l.resource_id=s.conversation_id \ + WHERE l.project_id=? AND l.user_id=? ORDER BY b.chat_id,b.message_thread_id", + &[project_id, user_id], + ) + .await?, + ); + records.insert( + "channel_topic_model_overrides".into(), + fetch_json( + &self.pool, + "SELECT DISTINCT json_object('platform',o.platform,'internal_user_id',o.internal_user_id,'chat_id',o.chat_id,\ + 'message_thread_id',o.message_thread_id,'agent_id',o.agent_id,'provider_id',o.provider_id,\ + 'model',o.model,'updated_at',o.updated_at) FROM channel_topic_model_overrides o \ + JOIN assistant_sessions s ON s.chat_id=o.chat_id AND s.message_thread_id=o.message_thread_id \ + JOIN project_resource_links l ON l.resource_type='conversation' AND l.resource_id=s.conversation_id \ + WHERE l.project_id=? AND l.user_id=? AND o.internal_user_id=l.user_id \ + ORDER BY o.chat_id,o.message_thread_id,o.internal_user_id", + &[project_id, user_id], + ) + .await?, + ); + records.insert( + "development_policies".into(), + fetch_json( + &self.pool, + "SELECT json_object('id',id,'user_id',user_id,'project_id',project_id,'isolation_mode',isolation_mode,\ + 'container_image',container_image,'devcontainer_config_path',devcontainer_config_path,\ + 'container_cpu_millis',container_cpu_millis,'container_memory_mb',container_memory_mb,\ + 'container_pids_limit',container_pids_limit,'network_mode',network_mode,\ + 'allowed_secret_keys_json',allowed_secret_keys_json,'allowed_commands_json',allowed_commands_json,\ + 'protected_paths_json',protected_paths_json,'allowed_network_hosts_json',allowed_network_hosts_json,\ + 'protected_branches_json',protected_branches_json,'dangerous_confirmation_count',dangerous_confirmation_count,\ + 'max_duration_ms',max_duration_ms,'max_parallel_agents',max_parallel_agents,'max_retries',max_retries,\ + 'max_cost_microunits',max_cost_microunits,'max_total_tokens',max_total_tokens,'fallback_model',fallback_model,\ + 'alert_percent',alert_percent,'over_limit_action',over_limit_action,'created_at',created_at,'updated_at',updated_at) \ + FROM development_policies WHERE project_id=? AND user_id=?", + &[project_id, user_id], + ) + .await?, + ); + records.insert( + "development_retention_policies".into(), + fetch_json( + &self.pool, + "SELECT json_object('user_id',user_id,'project_id',project_id,\ + 'conversation_history_days',conversation_history_days,'artifact_days',artifact_days,\ + 'evaluation_days',evaluation_days,'immutable_audit_log',immutable_audit_log,'updated_at',updated_at) \ + FROM development_retention_policies WHERE project_id=? AND user_id=?", + &[project_id, user_id], + ) + .await?, + ); + records.insert( + "development_runs".into(), + fetch_json( + &self.pool, + "SELECT json_object('id',id,'user_id',user_id,'project_id',project_id,'team_id',team_id,\ + 'source_channel',source_channel,'source_user_id',source_user_id,'execution_mode',execution_mode,\ + 'status',status,'request_summary',request_summary,'acceptance_criteria',acceptance_criteria,\ + 'baseline_commit',baseline_commit,'integration_branch',integration_branch,'started_at',started_at,\ + 'finished_at',finished_at,'created_at',created_at,'updated_at',updated_at) \ + FROM development_runs WHERE project_id=? AND user_id=? ORDER BY created_at,id", + &[project_id, user_id], + ) + .await?, + ); + records.insert( + "development_deliveries".into(), + fetch_json( + &self.pool, + "SELECT json_object('id',id,'run_id',run_id,'project_id',project_id,'user_id',user_id,'provider',provider,\ + 'repository',repository,'branch',branch,'base_branch',base_branch,'commit_sha',commit_sha,'status',status,\ + 'push_status',push_status,'pr_number',pr_number,'pr_url',pr_url,'pr_status',pr_status,'ci_status',ci_status,\ + 'review_status',review_status,'merge_status',merge_status,'report_json',report_json,'last_error',last_error,\ + 'created_at',created_at,'updated_at',updated_at) FROM development_deliveries \ + WHERE project_id=? AND user_id=? ORDER BY created_at,id", + &[project_id, user_id], + ) + .await?, + ); + records.insert( + "development_audit_events".into(), + fetch_json( + &self.pool, + "SELECT json_object('id',id,'user_id',user_id,'actor_type',actor_type,'actor_id',actor_id,'action',action,\ + 'target_type',target_type,'target_id',target_id,'project_id',project_id,'run_id',run_id,'task_id',task_id,\ + 'result',result,'redacted_payload_json',redacted_payload_json,'created_at',created_at) \ + FROM development_audit_events WHERE project_id=? AND user_id=? ORDER BY created_at,id", + &[project_id, user_id], + ) + .await?, + ); + + let instance = self.platform_instance().await?; + let mut bundle = ProjectExportBundle { + manifest: ProjectExportManifest { + format_version: FORMAT_VERSION, + schema_version: SCHEMA_VERSION, + app_version: APP_VERSION.into(), + source_instance_id: instance.instance_id, + exported_at: now_ms(), + project_id: project_id.into(), + record_counts: BTreeMap::new(), + payload_checksum: String::new(), + signer_public_key: self.signer_public_key(), + signature: String::new(), + }, + records, + }; + self.seal_bundle(&mut bundle)?; + Ok(bundle) + } + + pub fn seal_bundle(&self, bundle: &mut ProjectExportBundle) -> Result<(), DevelopmentError> { + bundle.manifest.record_counts = bundle + .records + .iter() + .map(|(name, values)| (name.clone(), values.len())) + .collect(); + let payload = serde_json::to_vec(&bundle.records).map_err(internal)?; + bundle.manifest.payload_checksum = format!("sha256:{}", hex::encode(Sha256::digest(payload))); + bundle.manifest.signature = hex::encode(self.signing_key.sign(&signature_input(&bundle.manifest)).to_bytes()); + Ok(()) + } + + pub fn validate_bundle(&self, bundle: &ProjectExportBundle) -> Result<(), DevelopmentError> { + if bundle.manifest.format_version != FORMAT_VERSION { + return Err(DevelopmentError::BadRequest(format!( + "unsupported project bundle format version {}", + bundle.manifest.format_version + ))); + } + if bundle.manifest.schema_version > SCHEMA_VERSION { + return Err(DevelopmentError::BadRequest(format!( + "unsupported future schema version {}", + bundle.manifest.schema_version + ))); + } + let allowed = portable_tables(); + if let Some(table) = bundle.records.keys().find(|table| !allowed.contains(table.as_str())) { + return Err(DevelopmentError::BadRequest(format!( + "unsupported or sensitive export table {table}" + ))); + } + let counts: BTreeMap<_, _> = bundle + .records + .iter() + .map(|(name, values)| (name.clone(), values.len())) + .collect(); + if counts != bundle.manifest.record_counts { + return Err(DevelopmentError::BadRequest("record count mismatch".into())); + } + let payload = serde_json::to_vec(&bundle.records).map_err(internal)?; + let checksum = format!("sha256:{}", hex::encode(Sha256::digest(payload))); + if checksum != bundle.manifest.payload_checksum { + return Err(DevelopmentError::BadRequest("project bundle checksum mismatch".into())); + } + let signature_bytes = hex::decode(&bundle.manifest.signature) + .map_err(|_| DevelopmentError::BadRequest("invalid project bundle signature encoding".into()))?; + let signature = Signature::from_slice(&signature_bytes) + .map_err(|_| DevelopmentError::BadRequest("invalid project bundle signature".into()))?; + let public_key_bytes = hex::decode(&bundle.manifest.signer_public_key) + .map_err(|_| DevelopmentError::BadRequest("invalid signer public key encoding".into()))?; + let public_key_bytes: [u8; 32] = public_key_bytes + .try_into() + .map_err(|_| DevelopmentError::BadRequest("invalid signer public key".into()))?; + let normalized_public_key = hex::encode(public_key_bytes); + if !self.trusted_signers.contains(&normalized_public_key) { + return Err(DevelopmentError::BadRequest( + "project bundle signer is not trusted by this server".into(), + )); + } + VerifyingKey::from_bytes(&public_key_bytes) + .map_err(|_| DevelopmentError::BadRequest("invalid signer public key".into()))? + .verify(&signature_input(&bundle.manifest), &signature) + .map_err(|_| DevelopmentError::BadRequest("project bundle signature verification failed".into()))?; + Ok(()) + } + + pub async fn import_project( + &self, + owner_id: &str, + request: ImportProjectBundleRequest, + ) -> Result { + self.validate_bundle(&request.bundle)?; + validate_absolute_import_path(&request.local_path)?; + let user_exists: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM users WHERE id=?") + .bind(owner_id) + .fetch_one(&self.pool) + .await + .map_err(internal)?; + if user_exists != 1 { + return Err(DevelopmentError::NotFound(format!("owner {owner_id}"))); + } + let project = only_record(&request.bundle, "projects")?; + let project_id = text(project, "id")?.to_owned(); + if project_id != request.bundle.manifest.project_id { + return Err(DevelopmentError::BadRequest( + "manifest project id does not match payload".into(), + )); + } + let source_path = text(project, "local_path")?.to_owned(); + validate_import_relationships(&request.bundle, &source_path, &request.local_path)?; + for policy in records(&request.bundle, "development_policies") { + if let Some(path) = optional_text(policy, "devcontainer_config_path")? { + validate_relative_path(path)?; + } + } + let conflicts = + collect_import_conflicts(&self.pool, owner_id, &project_id, &request.local_path, &request.bundle).await?; + if !conflicts.is_empty() { + return Ok(ProjectImportReport { + project_id, + owner_id: owner_id.into(), + imported: false, + imported_counts: BTreeMap::new(), + conflicts, + }); + } + + let mut transaction = self.pool.begin().await.map_err(internal)?; + let result = import_records( + &mut transaction, + owner_id, + &request.local_path, + &source_path, + &request.bundle, + ) + .await; + if let Err(error) = result { + transaction.rollback().await.map_err(internal)?; + return Err(DevelopmentError::Internal(format!( + "import transaction failed: {error}" + ))); + } + transaction.commit().await.map_err(internal)?; + Ok(ProjectImportReport { + project_id, + owner_id: owner_id.into(), + imported: true, + imported_counts: request.bundle.manifest.record_counts, + conflicts: Vec::new(), + }) + } + + pub async fn platform_instance(&self) -> Result { + let now = now_ms(); + sqlx::query( + "INSERT OR IGNORE INTO platform_instances \ + (singleton,instance_id,schema_version,app_version,first_started_at,last_started_at) VALUES (1,?,?,?,?,?)", + ) + .bind(&self.instance_fallback) + .bind(SCHEMA_VERSION) + .bind(APP_VERSION) + .bind(now) + .bind(now) + .execute(&self.pool) + .await + .map_err(internal)?; + let row = sqlx::query( + "SELECT instance_id,schema_version,app_version,first_started_at,last_started_at FROM platform_instances WHERE singleton=1", + ) + .fetch_one(&self.pool) + .await + .map_err(internal)?; + let page_count: i64 = sqlx::query_scalar("PRAGMA page_count") + .fetch_one(&self.pool) + .await + .map_err(internal)?; + let page_size: i64 = sqlx::query_scalar("PRAGMA page_size") + .fetch_one(&self.pool) + .await + .map_err(internal)?; + Ok(PlatformInstanceSummary { + instance_id: row.try_get("instance_id").map_err(internal)?, + schema_version: row.try_get("schema_version").map_err(internal)?, + app_version: row.try_get("app_version").map_err(internal)?, + first_started_at: row.try_get("first_started_at").map_err(internal)?, + last_started_at: row.try_get("last_started_at").map_err(internal)?, + data_size_bytes: page_count.saturating_mul(page_size), + }) + } + + pub async fn record_startup(&self) -> Result<(), DevelopmentError> { + let now = now_ms(); + sqlx::query( + "INSERT OR IGNORE INTO platform_instances \ + (singleton,instance_id,schema_version,app_version,first_started_at,last_started_at) VALUES (1,?,?,?,?,?)", + ) + .bind(&self.instance_fallback) + .bind(SCHEMA_VERSION) + .bind(APP_VERSION) + .bind(now) + .bind(now) + .execute(&self.pool) + .await + .map_err(internal)?; + sqlx::query("UPDATE platform_instances SET schema_version=?,app_version=?,last_started_at=? WHERE singleton=1") + .bind(SCHEMA_VERSION) + .bind(APP_VERSION) + .bind(now) + .execute(&self.pool) + .await + .map_err(internal)?; + Ok(()) + } + + pub async fn record_evaluation( + &self, + user_id: &str, + input: EvaluationRecordInput, + ) -> Result { + validate_evaluation(&input)?; + let owned: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM projects WHERE id=? AND user_id=?") + .bind(&input.project_id) + .bind(user_id) + .fetch_one(&self.pool) + .await + .map_err(internal)?; + if owned != 1 { + return Err(DevelopmentError::NotFound(format!("project {}", input.project_id))); + } + if input.accepted_baseline && input.result != "passed" { + return Err(DevelopmentError::BadRequest( + "accepted baseline requires a passing evaluation".into(), + )); + } + let row = DevelopmentEvaluation { + id: uuid::Uuid::now_v7().to_string(), + user_id: user_id.into(), + project_id: input.project_id, + release_id: input.release_id, + scenario_id: input.scenario_id, + result: input.result, + duration_ms: input.duration_ms, + failure_category: input.failure_category, + input_tokens: input.input_tokens, + output_tokens: input.output_tokens, + cost_microunits: input.cost_microunits, + cost_source: input.cost_source, + accepted_baseline: input.accepted_baseline, + created_at: now_ms(), + }; + let mut transaction = self.pool.begin().await.map_err(internal)?; + sqlx::query( + "INSERT INTO development_evaluations \ + (id,user_id,project_id,release_id,scenario_id,result,duration_ms,failure_category,input_tokens,\ + output_tokens,cost_microunits,cost_source,accepted_baseline,created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)", + ) + .bind(&row.id) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.release_id) + .bind(&row.scenario_id) + .bind(&row.result) + .bind(row.duration_ms) + .bind(&row.failure_category) + .bind(row.input_tokens) + .bind(row.output_tokens) + .bind(row.cost_microunits) + .bind(&row.cost_source) + .bind(row.accepted_baseline) + .bind(row.created_at) + .execute(&mut *transaction) + .await + .map_err(|error| DevelopmentError::Conflict(format!("evaluation already exists or is invalid: {error}")))?; + if row.accepted_baseline { + sqlx::query( + "INSERT INTO development_evaluation_baselines (user_id,project_id,release_id,accepted_at) \ + VALUES (?,?,?,?) ON CONFLICT(user_id,project_id) DO UPDATE SET \ + release_id=excluded.release_id,accepted_at=excluded.accepted_at", + ) + .bind(&row.user_id) + .bind(&row.project_id) + .bind(&row.release_id) + .bind(row.created_at) + .execute(&mut *transaction) + .await + .map_err(internal)?; + } + transaction.commit().await.map_err(internal)?; + Ok(row) + } + + pub async fn compare_evaluations( + &self, + user_id: &str, + request: EvaluationComparisonRequest, + ) -> Result { + if request.required_scenarios.is_empty() + || !(0..=10_000).contains(&request.max_duration_regression_percent) + || !(0..=10_000).contains(&request.max_cost_regression_percent) + { + return Err(DevelopmentError::BadRequest( + "invalid evaluation comparison thresholds".into(), + )); + } + let mut regressions = Vec::new(); + let baseline_release: Option = sqlx::query_scalar( + "SELECT release_id FROM development_evaluation_baselines WHERE user_id=? AND project_id=?", + ) + .bind(user_id) + .bind(&request.project_id) + .fetch_optional(&self.pool) + .await + .map_err(internal)?; + let baseline_releases = baseline_release.iter().cloned().collect(); + for scenario in &request.required_scenarios { + let current = evaluation_row( + &self.pool, + "SELECT * FROM development_evaluations WHERE user_id=? AND project_id=? AND release_id=? AND scenario_id=?", + user_id, + &request.project_id, + &request.release_id, + scenario, + ) + .await?; + let Some(current) = current else { + regressions.push(regression( + scenario, + "missing", + "required scenario has no current result", + )); + continue; + }; + if current.result != "passed" { + regressions.push(regression( + scenario, + current.failure_category.as_deref().unwrap_or("result"), + "current scenario did not pass", + )); + } + let Some(baseline_release) = baseline_release.as_deref() else { + regressions.push(regression( + scenario, + "baseline_missing", + "accepted baseline release is missing", + )); + continue; + }; + if baseline_release == request.release_id { + regressions.push(regression( + scenario, + "baseline_invalid", + "candidate release cannot be its own baseline", + )); + continue; + } + let baseline = evaluation_row( + &self.pool, + "SELECT * FROM development_evaluations WHERE user_id=? AND project_id=? AND release_id=? \ + AND scenario_id=?", + user_id, + &request.project_id, + baseline_release, + scenario, + ) + .await?; + let Some(baseline) = baseline else { + regressions.push(regression( + scenario, + "baseline_missing", + "scenario is missing from accepted baseline release", + )); + continue; + }; + if baseline.result != "passed" { + regressions.push(regression( + scenario, + "baseline_invalid", + "accepted baseline scenario did not pass", + )); + continue; + } + if exceeds_percent( + current.duration_ms, + baseline.duration_ms, + request.max_duration_regression_percent, + ) { + regressions.push(regression( + scenario, + "duration", + "duration exceeded accepted baseline threshold", + )); + } + if exceeds_percent( + current.cost_microunits, + baseline.cost_microunits, + request.max_cost_regression_percent, + ) { + regressions.push(regression( + scenario, + "cost", + "cost exceeded accepted baseline threshold", + )); + } + } + Ok(EvaluationComparison { + allowed: regressions.is_empty(), + release_id: request.release_id, + baseline_release_ids: baseline_releases, + regressions, + }) + } +} + +fn signature_input(manifest: &ProjectExportManifest) -> Vec { + format!( + "{}\n{}\n{}\n{}\n{}\n{}\n{:?}\n{}\n{}", + manifest.format_version, + manifest.schema_version, + manifest.app_version, + manifest.source_instance_id, + manifest.exported_at, + manifest.project_id, + manifest.record_counts, + manifest.signer_public_key, + manifest.payload_checksum + ) + .into_bytes() +} + +fn portable_tables() -> BTreeSet<&'static str> { + [ + "projects", + "project_command_profiles", + "project_runtime_profiles", + "project_resource_links", + "conversations", + "messages", + "teams", + "assistant_users", + "assistant_sessions", + "telegram_topic_bindings", + "channel_topic_model_overrides", + "development_policies", + "development_retention_policies", + "development_runs", + "development_deliveries", + "development_audit_events", + ] + .into_iter() + .collect() +} + +async fn fetch_json(pool: &SqlitePool, sql: &str, binds: &[&str]) -> Result, DevelopmentError> { + let mut query = sqlx::query_scalar::<_, String>(sql); + for value in binds { + query = query.bind(*value); + } + query + .fetch_all(pool) + .await + .map_err(internal)? + .into_iter() + .map(|value| serde_json::from_str(&value).map_err(internal)) + .collect() +} + +fn records<'a>(bundle: &'a ProjectExportBundle, table: &str) -> &'a [Value] { + bundle.records.get(table).map(Vec::as_slice).unwrap_or_default() +} + +fn only_record<'a>(bundle: &'a ProjectExportBundle, table: &str) -> Result<&'a Value, DevelopmentError> { + let values = records(bundle, table); + if values.len() != 1 { + return Err(DevelopmentError::BadRequest(format!( + "{table} must contain exactly one record" + ))); + } + Ok(&values[0]) +} + +fn text<'a>(value: &'a Value, key: &str) -> Result<&'a str, DevelopmentError> { + value + .get(key) + .and_then(Value::as_str) + .ok_or_else(|| DevelopmentError::BadRequest(format!("missing or invalid field {key}"))) +} + +fn optional_text<'a>(value: &'a Value, key: &str) -> Result, DevelopmentError> { + match value.get(key) { + None | Some(Value::Null) => Ok(None), + Some(Value::String(value)) => Ok(Some(value)), + _ => Err(DevelopmentError::BadRequest(format!("invalid field {key}"))), + } +} + +fn number(value: &Value, key: &str) -> Result { + value + .get(key) + .and_then(Value::as_i64) + .ok_or_else(|| DevelopmentError::BadRequest(format!("missing or invalid field {key}"))) +} + +fn optional_number(value: &Value, key: &str) -> Result, DevelopmentError> { + match value.get(key) { + None | Some(Value::Null) => Ok(None), + Some(Value::Number(value)) => value + .as_i64() + .map(Some) + .ok_or_else(|| DevelopmentError::BadRequest(format!("invalid field {key}"))), + _ => Err(DevelopmentError::BadRequest(format!("invalid field {key}"))), + } +} + +fn validate_absolute_import_path(path: &str) -> Result<(), DevelopmentError> { + let path = Path::new(path); + if !path.is_absolute() + || path + .components() + .any(|component| matches!(component, Component::ParentDir)) + { + return Err(DevelopmentError::BadRequest( + "path traversal in import local_path".into(), + )); + } + let mut current = PathBuf::new(); + for component in path.components() { + current.push(component.as_os_str()); + match std::fs::symlink_metadata(¤t) { + Ok(metadata) if metadata.file_type().is_symlink() => { + return Err(DevelopmentError::BadRequest(format!( + "import path contains a symbolic link: {}", + current.display() + ))); + } + Ok(metadata) if current == path && !metadata.is_dir() => { + return Err(DevelopmentError::BadRequest(format!( + "import local_path is not a directory: {}", + current.display() + ))); + } + Ok(_) => {} + Err(error) if error.kind() == ErrorKind::NotFound => {} + Err(error) => { + return Err(DevelopmentError::BadRequest(format!( + "cannot validate import path {}: {error}", + current.display() + ))); + } + } + } + Ok(()) +} + +fn validate_relative_path(path: &str) -> Result<(), DevelopmentError> { + let path = Path::new(path); + if path.is_absolute() + || path + .components() + .any(|component| matches!(component, Component::ParentDir)) + { + return Err(DevelopmentError::BadRequest( + "path traversal in portable configuration".into(), + )); + } + Ok(()) +} + +fn record_ids(bundle: &ProjectExportBundle, table: &str, key: &str) -> Result, DevelopmentError> { + let mut ids = BTreeSet::new(); + for row in records(bundle, table) { + let id = text(row, key)?.to_owned(); + if !ids.insert(id.clone()) { + return Err(DevelopmentError::BadRequest(format!( + "import validation failed: duplicate {table}:{id}" + ))); + } + } + Ok(ids) +} + +fn require_unique_key(seen: &mut BTreeSet, table: &str, key: String) -> Result<(), DevelopmentError> { + if seen.insert(key.clone()) { + Ok(()) + } else { + Err(DevelopmentError::BadRequest(format!( + "import validation failed: duplicate {table}:{key}" + ))) + } +} + +fn validate_project_references( + bundle: &ProjectExportBundle, + table: &str, + project_id: &str, +) -> Result<(), DevelopmentError> { + for row in records(bundle, table) { + if text(row, "project_id")? != project_id { + return Err(DevelopmentError::BadRequest(format!( + "import validation failed: {table} references another project" + ))); + } + } + Ok(()) +} + +fn require_reference( + table: &str, + value: &str, + target_table: &str, + targets: &BTreeSet, +) -> Result<(), DevelopmentError> { + if targets.contains(value) { + Ok(()) + } else { + Err(DevelopmentError::BadRequest(format!( + "import validation failed: {table} references missing {target_table}:{value}" + ))) + } +} + +fn remap_workspace(workspace: &str, source_path: &str, local_path: &str) -> Result { + validate_absolute_import_path(source_path)?; + validate_absolute_import_path(workspace)?; + let relative = Path::new(workspace).strip_prefix(source_path).map_err(|_| { + DevelopmentError::BadRequest(format!( + "import validation failed: team workspace is outside source project: {workspace}" + )) + })?; + let remapped = Path::new(local_path).join(relative).to_string_lossy().into_owned(); + validate_absolute_import_path(&remapped)?; + Ok(remapped) +} + +fn validate_import_relationships( + bundle: &ProjectExportBundle, + source_path: &str, + local_path: &str, +) -> Result<(), DevelopmentError> { + let project_id = text(only_record(bundle, "projects")?, "id")?; + let conversations = record_ids(bundle, "conversations", "id")?; + let messages = record_ids(bundle, "messages", "id")?; + let teams = record_ids(bundle, "teams", "id")?; + let assistant_users = record_ids(bundle, "assistant_users", "id")?; + let assistant_sessions = record_ids(bundle, "assistant_sessions", "id")?; + let runs = record_ids(bundle, "development_runs", "id")?; + let deliveries = record_ids(bundle, "development_deliveries", "id")?; + let audits = record_ids(bundle, "development_audit_events", "id")?; + let _ = (messages, assistant_sessions, deliveries, audits); + + for table in [ + "project_command_profiles", + "project_runtime_profiles", + "development_policies", + "development_retention_policies", + ] { + if records(bundle, table).len() > 1 { + return Err(DevelopmentError::BadRequest(format!( + "import validation failed: duplicate {table}:{project_id}" + ))); + } + } + + for table in [ + "project_command_profiles", + "project_runtime_profiles", + "project_resource_links", + "development_policies", + "development_retention_policies", + "development_runs", + "development_deliveries", + "development_audit_events", + ] { + validate_project_references(bundle, table, project_id)?; + } + for row in records(bundle, "messages") { + require_reference( + "messages", + text(row, "conversation_id")?, + "conversations", + &conversations, + )?; + } + for row in records(bundle, "teams") { + remap_workspace(text(row, "workspace")?, source_path, local_path)?; + } + let mut resource_links = BTreeSet::new(); + for row in records(bundle, "project_resource_links") { + let resource_type = text(row, "resource_type")?; + let resource_id = text(row, "resource_id")?; + require_unique_key( + &mut resource_links, + "project_resource_links", + format!("{resource_type}:{resource_id}"), + )?; + match resource_type { + "conversation" => { + require_reference("project_resource_links", resource_id, "conversations", &conversations)? + } + "team" => require_reference("project_resource_links", resource_id, "teams", &teams)?, + _ => { + return Err(DevelopmentError::BadRequest(format!( + "import validation failed: unsupported resource link type {resource_type}" + ))); + } + } + } + let mut user_identities = BTreeSet::new(); + for row in records(bundle, "assistant_users") { + require_unique_key( + &mut user_identities, + "assistant_users identity", + format!("{}:{}", text(row, "platform_type")?, text(row, "platform_user_id")?), + )?; + } + let mut session_topics = BTreeSet::new(); + let mut session_identities = BTreeSet::new(); + for row in records(bundle, "assistant_sessions") { + require_reference( + "assistant_sessions", + text(row, "user_id")?, + "assistant_users", + &assistant_users, + )?; + require_reference( + "assistant_sessions", + text(row, "conversation_id")?, + "conversations", + &conversations, + )?; + if let Some(workspace) = optional_text(row, "workspace")? { + remap_workspace(workspace, source_path, local_path)?; + } + if let (Some(chat_id), Some(thread_id)) = ( + optional_text(row, "chat_id")?, + optional_number(row, "message_thread_id")?, + ) { + session_topics.insert(format!("{chat_id}:{thread_id}")); + } + require_unique_key( + &mut session_identities, + "assistant_sessions identity", + format!( + "{}:{}:{}", + text(row, "user_id")?, + optional_text(row, "chat_id")?.unwrap_or(""), + optional_number(row, "message_thread_id")? + .map(|value| value.to_string()) + .unwrap_or_default() + ), + )?; + } + let mut topic_bindings = BTreeSet::new(); + for row in records(bundle, "telegram_topic_bindings") { + let topic = format!("{}:{}", text(row, "chat_id")?, number(row, "message_thread_id")?); + require_unique_key(&mut topic_bindings, "telegram_topic_bindings", topic.clone())?; + require_reference( + "telegram_topic_bindings", + &topic, + "assistant_sessions topic", + &session_topics, + )?; + } + let mut model_overrides = BTreeSet::new(); + for row in records(bundle, "channel_topic_model_overrides") { + let topic = format!("{}:{}", text(row, "chat_id")?, number(row, "message_thread_id")?); + require_unique_key( + &mut model_overrides, + "channel_topic_model_overrides", + format!("{}:{topic}", text(row, "platform")?), + )?; + require_reference( + "channel_topic_model_overrides", + &topic, + "assistant_sessions topic", + &session_topics, + )?; + } + for row in records(bundle, "development_runs") { + if let Some(team_id) = optional_text(row, "team_id")? { + require_reference("development_runs", team_id, "teams", &teams)?; + } + } + let mut delivery_runs = BTreeSet::new(); + for row in records(bundle, "development_deliveries") { + let run_id = text(row, "run_id")?; + require_unique_key(&mut delivery_runs, "development_deliveries run", run_id.to_owned())?; + require_reference("development_deliveries", run_id, "development_runs", &runs)?; + } + for row in records(bundle, "development_audit_events") { + if let Some(run_id) = optional_text(row, "run_id")? { + require_reference("development_audit_events", run_id, "development_runs", &runs)?; + } + } + Ok(()) +} + +async fn collect_id_conflicts( + pool: &SqlitePool, + bundle: &ProjectExportBundle, + export_table: &str, + database_table: &str, +) -> Result, DevelopmentError> { + let mut conflicts = Vec::new(); + let sql = format!("SELECT COUNT(*) FROM {database_table} WHERE id=?"); + for id in record_ids(bundle, export_table, "id")? { + let exists: i64 = sqlx::query_scalar(&sql) + .bind(&id) + .fetch_one(pool) + .await + .map_err(internal)?; + if exists != 0 { + conflicts.push(format!("{export_table}:{id}")); + } + } + Ok(conflicts) +} + +async fn collect_import_conflicts( + pool: &SqlitePool, + owner_id: &str, + project_id: &str, + local_path: &str, + bundle: &ProjectExportBundle, +) -> Result, DevelopmentError> { + let mut conflicts = Vec::new(); + let project_exists: i64 = + sqlx::query_scalar("SELECT COUNT(*) FROM projects WHERE id=? OR (user_id=? AND local_path=?)") + .bind(project_id) + .bind(owner_id) + .bind(local_path) + .fetch_one(pool) + .await + .map_err(internal)?; + if project_exists != 0 { + conflicts.push(format!("projects:{project_id}")); + } + for (export_table, database_table) in [ + ("conversations", "conversations"), + ("messages", "messages"), + ("teams", "teams"), + ("assistant_sessions", "assistant_sessions"), + ("development_policies", "development_policies"), + ("development_runs", "development_runs"), + ("development_deliveries", "development_deliveries"), + ("development_audit_events", "development_audit_events"), + ] { + conflicts.extend(collect_id_conflicts(pool, bundle, export_table, database_table).await?); + } + let mut assistant_user_ids = BTreeMap::new(); + for row in records(bundle, "assistant_users") { + let source_id = text(row, "id")?; + let platform_user_id = text(row, "platform_user_id")?; + let platform_type = text(row, "platform_type")?; + let matching: Option = + sqlx::query_scalar("SELECT id FROM assistant_users WHERE platform_user_id=? AND platform_type=?") + .bind(platform_user_id) + .bind(platform_type) + .fetch_optional(pool) + .await + .map_err(internal)?; + match matching { + Some(target_id) => { + assistant_user_ids.insert(source_id.to_owned(), target_id); + } + None => conflicts.push(format!( + "assistant_users:{platform_type}:{platform_user_id}:re_pair_required" + )), + } + } + for row in records(bundle, "assistant_sessions") { + let source_user_id = text(row, "user_id")?; + let Some(target_user_id) = assistant_user_ids.get(source_user_id) else { + continue; + }; + let chat_id = optional_text(row, "chat_id")?; + let thread_id = optional_number(row, "message_thread_id")?; + let matching: Option = sqlx::query_scalar( + "SELECT id FROM assistant_sessions \ + WHERE user_id=? AND chat_id IS ? AND message_thread_id IS ?", + ) + .bind(target_user_id) + .bind(chat_id) + .bind(thread_id) + .fetch_optional(pool) + .await + .map_err(internal)?; + if let Some(existing_id) = matching { + conflicts.push(format!("assistant_sessions:{existing_id}")); + } + } + for row in records(bundle, "telegram_topic_bindings") { + let chat_id = text(row, "chat_id")?; + let thread_id = number(row, "message_thread_id")?; + let exists: i64 = + sqlx::query_scalar("SELECT COUNT(*) FROM telegram_topic_bindings WHERE chat_id=? AND message_thread_id=?") + .bind(chat_id) + .bind(thread_id) + .fetch_one(pool) + .await + .map_err(internal)?; + if exists != 0 { + conflicts.push(format!("telegram_topic_bindings:{chat_id}:{thread_id}")); + } + } + for row in records(bundle, "channel_topic_model_overrides") { + let chat_id = text(row, "chat_id")?; + let thread_id = number(row, "message_thread_id")?; + let exists: i64 = sqlx::query_scalar( + "SELECT COUNT(*) FROM channel_topic_model_overrides \ + WHERE platform=? AND internal_user_id=? AND chat_id=? AND message_thread_id=?", + ) + .bind(text(row, "platform")?) + .bind(owner_id) + .bind(chat_id) + .bind(thread_id) + .fetch_one(pool) + .await + .map_err(internal)?; + if exists != 0 { + conflicts.push(format!("channel_topic_model_overrides:{chat_id}:{thread_id}")); + } + } + conflicts.sort(); + conflicts.dedup(); + Ok(conflicts) +} + +async fn import_records( + transaction: &mut Transaction<'_, Sqlite>, + owner_id: &str, + local_path: &str, + source_path: &str, + bundle: &ProjectExportBundle, +) -> Result<(), DevelopmentError> { + let project = only_record(bundle, "projects")?; + sqlx::query( + "INSERT INTO projects (id,user_id,name,local_path,repository_url,default_branch,project_type,created_at,updated_at) \ + VALUES (?,?,?,?,?,?,?,?,?)", + ) + .bind(text(project, "id")?) + .bind(owner_id) + .bind(text(project, "name")?) + .bind(local_path) + .bind(optional_text(project, "repository_url")?) + .bind(optional_text(project, "default_branch")?) + .bind(text(project, "project_type")?) + .bind(number(project, "created_at")?) + .bind(number(project, "updated_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + + let mut assistant_user_ids = BTreeMap::new(); + for row in records(bundle, "assistant_users") { + let source_id = text(row, "id")?; + let existing: Option = + sqlx::query_scalar("SELECT id FROM assistant_users WHERE platform_user_id=? AND platform_type=?") + .bind(text(row, "platform_user_id")?) + .bind(text(row, "platform_type")?) + .fetch_optional(&mut **transaction) + .await + .map_err(internal)?; + let target_id = existing.ok_or_else(|| { + DevelopmentError::BadRequest(format!( + "assistant user {source_id} must be paired on the target instance before import" + )) + })?; + assistant_user_ids.insert(source_id.to_owned(), target_id); + } + + for row in records(bundle, "project_command_profiles") { + sqlx::query( + "INSERT INTO project_command_profiles (project_id,install_command,format_command,lint_command,typecheck_command,\ + unit_test_command,integration_test_command,e2e_command,build_command,security_scan_command,command_timeout_seconds,updated_at) \ + VALUES (?,?,?,?,?,?,?,?,?,?,?,?)", + ) + .bind(text(row, "project_id")?) + .bind(optional_text(row, "install_command")?) + .bind(optional_text(row, "format_command")?) + .bind(optional_text(row, "lint_command")?) + .bind(optional_text(row, "typecheck_command")?) + .bind(optional_text(row, "unit_test_command")?) + .bind(optional_text(row, "integration_test_command")?) + .bind(optional_text(row, "e2e_command")?) + .bind(optional_text(row, "build_command")?) + .bind(optional_text(row, "security_scan_command")?) + .bind(number(row, "command_timeout_seconds")?) + .bind(number(row, "updated_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + for row in records(bundle, "project_runtime_profiles") { + sqlx::query( + "INSERT INTO project_runtime_profiles (project_id,environment_kind,language,package_manager,runtime_version,env_keys,metadata,updated_at) \ + VALUES (?,?,?,?,?,?,?,?)", + ) + .bind(text(row, "project_id")?) + .bind(text(row, "environment_kind")?) + .bind(optional_text(row, "language")?) + .bind(optional_text(row, "package_manager")?) + .bind(optional_text(row, "runtime_version")?) + .bind(text(row, "env_keys")?) + .bind(text(row, "metadata")?) + .bind(number(row, "updated_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + for row in records(bundle, "conversations") { + sqlx::query( + "INSERT INTO conversations (id,user_id,name,type,extra,model,status,source,channel_chat_id,pinned,pinned_at,created_at,updated_at) \ + VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", + ) + .bind(text(row, "id")?) + .bind(owner_id) + .bind(text(row, "name")?) + .bind(text(row, "type")?) + .bind(text(row, "extra")?) + .bind(optional_text(row, "model")?) + .bind(text(row, "status")?) + .bind(optional_text(row, "source")?) + .bind(optional_text(row, "channel_chat_id")?) + .bind(number(row, "pinned")?) + .bind(optional_number(row, "pinned_at")?) + .bind(number(row, "created_at")?) + .bind(number(row, "updated_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + for row in records(bundle, "messages") { + sqlx::query( + "INSERT INTO messages (id,conversation_id,msg_id,type,content,position,status,hidden,created_at) VALUES (?,?,?,?,?,?,?,?,?)", + ) + .bind(text(row, "id")?) + .bind(text(row, "conversation_id")?) + .bind(optional_text(row, "msg_id")?) + .bind(text(row, "type")?) + .bind(text(row, "content")?) + .bind(optional_text(row, "position")?) + .bind(optional_text(row, "status")?) + .bind(number(row, "hidden")?) + .bind(number(row, "created_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + for row in records(bundle, "teams") { + let workspace = remap_workspace(text(row, "workspace")?, source_path, local_path)?; + sqlx::query( + "INSERT INTO teams (id,user_id,name,workspace,workspace_mode,agents,lead_agent_id,session_mode,agents_version,created_at,updated_at) \ + VALUES (?,?,?,?,?,?,?,?,?,?,?)", + ) + .bind(text(row, "id")?) + .bind(owner_id) + .bind(text(row, "name")?) + .bind(&workspace) + .bind(text(row, "workspace_mode")?) + .bind(text(row, "agents")?) + .bind(optional_text(row, "lead_agent_id")?) + .bind(optional_text(row, "session_mode")?) + .bind(text(row, "agents_version")?) + .bind(number(row, "created_at")?) + .bind(number(row, "updated_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + for row in records(bundle, "project_resource_links") { + sqlx::query( + "INSERT INTO project_resource_links (project_id,user_id,resource_type,resource_id,created_at) VALUES (?,?,?,?,?)", + ) + .bind(text(row, "project_id")?) + .bind(owner_id) + .bind(text(row, "resource_type")?) + .bind(text(row, "resource_id")?) + .bind(number(row, "created_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + for row in records(bundle, "telegram_topic_bindings") { + sqlx::query( + "INSERT INTO telegram_topic_bindings (chat_id,message_thread_id,agent_id,bound_by_user_id,created_at,updated_at) \ + VALUES (?,?,?,?,?,?)", + ) + .bind(text(row, "chat_id")?) + .bind(number(row, "message_thread_id")?) + .bind(text(row, "agent_id")?) + .bind(text(row, "bound_by_user_id")?) + .bind(number(row, "created_at")?) + .bind(number(row, "updated_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + for row in records(bundle, "channel_topic_model_overrides") { + sqlx::query( + "INSERT INTO channel_topic_model_overrides (platform,internal_user_id,chat_id,message_thread_id,agent_id,provider_id,model,updated_at) \ + VALUES (?,?,?,?,?,?,?,?)", + ) + .bind(text(row, "platform")?) + .bind(owner_id) + .bind(text(row, "chat_id")?) + .bind(number(row, "message_thread_id")?) + .bind(text(row, "agent_id")?) + .bind(text(row, "provider_id")?) + .bind(text(row, "model")?) + .bind(number(row, "updated_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + for row in records(bundle, "development_policies") { + sqlx::query( + "INSERT INTO development_policies (id,user_id,project_id,isolation_mode,container_image,devcontainer_config_path,\ + container_cpu_millis,container_memory_mb,container_pids_limit,network_mode,allowed_secret_keys_json,\ + allowed_commands_json,protected_paths_json,allowed_network_hosts_json,protected_branches_json,\ + dangerous_confirmation_count,max_duration_ms,max_parallel_agents,max_retries,max_cost_microunits,\ + max_total_tokens,fallback_model,alert_percent,over_limit_action,created_at,updated_at) \ + VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", + ) + .bind(text(row, "id")?) + .bind(owner_id) + .bind(text(row, "project_id")?) + .bind(text(row, "isolation_mode")?) + .bind(optional_text(row, "container_image")?) + .bind(optional_text(row, "devcontainer_config_path")?) + .bind(number(row, "container_cpu_millis")?) + .bind(number(row, "container_memory_mb")?) + .bind(number(row, "container_pids_limit")?) + .bind(text(row, "network_mode")?) + .bind(text(row, "allowed_secret_keys_json")?) + .bind(text(row, "allowed_commands_json")?) + .bind(text(row, "protected_paths_json")?) + .bind(text(row, "allowed_network_hosts_json")?) + .bind(text(row, "protected_branches_json")?) + .bind(number(row, "dangerous_confirmation_count")?) + .bind(number(row, "max_duration_ms")?) + .bind(number(row, "max_parallel_agents")?) + .bind(number(row, "max_retries")?) + .bind(number(row, "max_cost_microunits")?) + .bind(number(row, "max_total_tokens")?) + .bind(optional_text(row, "fallback_model")?) + .bind(number(row, "alert_percent")?) + .bind(text(row, "over_limit_action")?) + .bind(number(row, "created_at")?) + .bind(number(row, "updated_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + for row in records(bundle, "assistant_sessions") { + let source_user_id = text(row, "user_id")?; + let target_user_id = assistant_user_ids.get(source_user_id).ok_or_else(|| { + DevelopmentError::BadRequest(format!( + "import validation failed: assistant session user {source_user_id}" + )) + })?; + let workspace = optional_text(row, "workspace")? + .map(|path| remap_workspace(path, source_path, local_path)) + .transpose()?; + sqlx::query( + "INSERT INTO assistant_sessions \ + (id,user_id,agent_type,conversation_id,workspace,chat_id,message_thread_id,bound_agent_id,\ + bound_backend,bound_provider_id,bound_model,created_at,last_activity) \ + VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", + ) + .bind(text(row, "id")?) + .bind(target_user_id) + .bind(text(row, "agent_type")?) + .bind(text(row, "conversation_id")?) + .bind(workspace) + .bind(optional_text(row, "chat_id")?) + .bind(optional_number(row, "message_thread_id")?) + .bind(optional_text(row, "bound_agent_id")?) + .bind(optional_text(row, "bound_backend")?) + .bind(optional_text(row, "bound_provider_id")?) + .bind(optional_text(row, "bound_model")?) + .bind(number(row, "created_at")?) + .bind(number(row, "last_activity")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + for row in records(bundle, "development_retention_policies") { + sqlx::query( + "INSERT INTO development_retention_policies \ + (user_id,project_id,conversation_history_days,artifact_days,evaluation_days,immutable_audit_log,updated_at) \ + VALUES (?,?,?,?,?,?,?)", + ) + .bind(owner_id) + .bind(text(row, "project_id")?) + .bind(number(row, "conversation_history_days")?) + .bind(number(row, "artifact_days")?) + .bind(number(row, "evaluation_days")?) + .bind(number(row, "immutable_audit_log")?) + .bind(number(row, "updated_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + for row in records(bundle, "development_runs") { + sqlx::query( + "INSERT INTO development_runs (id,user_id,project_id,team_id,source_channel,source_user_id,execution_mode,status,\ + request_summary,acceptance_criteria,baseline_commit,integration_branch,started_at,finished_at,created_at,updated_at) \ + VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", + ) + .bind(text(row, "id")?) + .bind(owner_id) + .bind(text(row, "project_id")?) + .bind(optional_text(row, "team_id")?) + .bind(optional_text(row, "source_channel")?) + .bind(optional_text(row, "source_user_id")?) + .bind(text(row, "execution_mode")?) + .bind(text(row, "status")?) + .bind(text(row, "request_summary")?) + .bind(text(row, "acceptance_criteria")?) + .bind(optional_text(row, "baseline_commit")?) + .bind(optional_text(row, "integration_branch")?) + .bind(optional_number(row, "started_at")?) + .bind(optional_number(row, "finished_at")?) + .bind(number(row, "created_at")?) + .bind(number(row, "updated_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + for row in records(bundle, "development_deliveries") { + sqlx::query( + "INSERT INTO development_deliveries (id,run_id,project_id,user_id,provider,repository,branch,base_branch,commit_sha,\ + status,push_status,pr_number,pr_url,pr_status,ci_status,review_status,merge_status,report_json,last_error,created_at,updated_at) \ + VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", + ) + .bind(text(row, "id")?) + .bind(text(row, "run_id")?) + .bind(text(row, "project_id")?) + .bind(owner_id) + .bind(text(row, "provider")?) + .bind(optional_text(row, "repository")?) + .bind(text(row, "branch")?) + .bind(text(row, "base_branch")?) + .bind(optional_text(row, "commit_sha")?) + .bind(text(row, "status")?) + .bind(text(row, "push_status")?) + .bind(optional_number(row, "pr_number")?) + .bind(optional_text(row, "pr_url")?) + .bind(text(row, "pr_status")?) + .bind(text(row, "ci_status")?) + .bind(text(row, "review_status")?) + .bind(text(row, "merge_status")?) + .bind(text(row, "report_json")?) + .bind(optional_text(row, "last_error")?) + .bind(number(row, "created_at")?) + .bind(number(row, "updated_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + for row in records(bundle, "development_audit_events") { + sqlx::query( + "INSERT INTO development_audit_events (id,user_id,actor_type,actor_id,action,target_type,target_id,project_id,\ + run_id,task_id,result,redacted_payload_json,created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", + ) + .bind(text(row, "id")?) + .bind(owner_id) + .bind(text(row, "actor_type")?) + .bind(if text(row, "actor_type")? == "user" { + owner_id + } else { + text(row, "actor_id")? + }) + .bind(text(row, "action")?) + .bind(text(row, "target_type")?) + .bind(text(row, "target_id")?) + .bind(text(row, "project_id")?) + .bind(optional_text(row, "run_id")?) + .bind(Option::::None) + .bind(text(row, "result")?) + .bind(text(row, "redacted_payload_json")?) + .bind(number(row, "created_at")?) + .execute(&mut **transaction) + .await + .map_err(internal)?; + } + Ok(()) +} + +fn validate_evaluation(input: &EvaluationRecordInput) -> Result<(), DevelopmentError> { + if input.project_id.trim().is_empty() + || input.release_id.trim().is_empty() + || input.scenario_id.trim().is_empty() + || !matches!(input.result.as_str(), "passed" | "failed" | "error" | "skipped") + || input.duration_ms < 0 + || input.input_tokens < 0 + || input.output_tokens < 0 + || input.cost_microunits < 0 + || input.cost_source.trim().is_empty() + { + return Err(DevelopmentError::BadRequest("invalid evaluation record".into())); + } + Ok(()) +} + +async fn evaluation_row( + pool: &SqlitePool, + sql: &str, + user_id: &str, + project_id: &str, + release_id: &str, + scenario_id: &str, +) -> Result, DevelopmentError> { + let row = sqlx::query(sql) + .bind(user_id) + .bind(project_id) + .bind(release_id) + .bind(scenario_id) + .fetch_optional(pool) + .await + .map_err(internal)?; + row.map(|row| { + Ok(DevelopmentEvaluation { + id: row.try_get("id").map_err(internal)?, + user_id: row.try_get("user_id").map_err(internal)?, + project_id: row.try_get("project_id").map_err(internal)?, + release_id: row.try_get("release_id").map_err(internal)?, + scenario_id: row.try_get("scenario_id").map_err(internal)?, + result: row.try_get("result").map_err(internal)?, + duration_ms: row.try_get("duration_ms").map_err(internal)?, + failure_category: row.try_get("failure_category").map_err(internal)?, + input_tokens: row.try_get("input_tokens").map_err(internal)?, + output_tokens: row.try_get("output_tokens").map_err(internal)?, + cost_microunits: row.try_get("cost_microunits").map_err(internal)?, + cost_source: row.try_get("cost_source").map_err(internal)?, + accepted_baseline: row.try_get("accepted_baseline").map_err(internal)?, + created_at: row.try_get("created_at").map_err(internal)?, + }) + }) + .transpose() +} + +fn exceeds_percent(current: i64, baseline: i64, allowed_percent: i64) -> bool { + if baseline == 0 { + return current > 0; + } + let allowed = i128::from(baseline) * i128::from(100 + allowed_percent) / 100; + i128::from(current) > allowed +} + +fn regression(scenario: &str, category: &str, message: &str) -> EvaluationRegression { + EvaluationRegression { + scenario_id: scenario.into(), + category: category.into(), + message: message.into(), + } +} + +fn internal(error: impl std::fmt::Display) -> DevelopmentError { + DevelopmentError::Internal(error.to_string()) +} diff --git a/crates/aionui-development/src/lib.rs b/crates/aionui-development/src/lib.rs new file mode 100644 index 000000000..755a0aba2 --- /dev/null +++ b/crates/aionui-development/src/lib.rs @@ -0,0 +1,69 @@ +mod approval; +mod approval_routes; +mod delivery; +mod deployment; +mod error; +mod executor; +mod export; +mod observed_usage; +mod operations; +mod policy; +mod pricing; +mod providers; +mod requirements; +mod resources; +mod retention; +mod routes; +mod runner; +mod secrets; +mod service; +mod types; +mod workspace; + +pub use aionui_api_types::{ + DevelopmentEvaluation, DevelopmentRetentionPolicy, EvaluationComparison, EvaluationComparisonRequest, + EvaluationRecordInput, EvaluationRegression, ImportProjectBundleRequest, PlatformInstanceSummary, + ProjectExportBundle, ProjectExportManifest, ProjectImportReport, RetentionCleanupReport, RetentionCleanupRequest, + RetentionPolicyInput, +}; +pub use approval::{ + ApprovalError, ApprovalOption, ApprovalRequestInput, ApprovalResolver, ApprovalService, ApprovalSource, + ResolveApprovalContext, +}; +pub use approval_routes::{ApprovalRouterState, approval_routes}; +pub use delivery::{ + CreatePullRequestInput, CreateTagInput, DeliveryProvider, DeliveryProviderRegistry, DeliveryProviderSnapshot, + DeliveryService, PrepareDeliveryInput, ProviderCiCheck, ProviderPullRequest, ProviderReviewComment, ProviderTag, +}; +pub use deployment::{ + DeploymentExecution, DeploymentProvider, DeploymentRequestInput, DeploymentService, UnconfiguredDeploymentProvider, +}; +pub use error::DevelopmentError; +pub use executor::{ + CommandExecutionInput, CommandExecutionOutput, CommandExecutionPlan, ExecutionCommandSpec, + PlannedExecutionResource, build_execution_plan, execute_command, +}; +pub use export::PortabilityService; +pub use observed_usage::{DevelopmentBudgetAdmission, DevelopmentUsageIngestor, ObservedAgentTurnUsage}; +pub use operations::{ + BudgetEvaluation, DevelopmentOperationsService, DevelopmentOperationsSnapshot, DevelopmentPolicyInput, + RecoveryDecisionInput, default_policy, redact_sensitive, +}; +pub use policy::{DevelopmentPolicyRules, PolicyDecision, PolicyEngine, PolicyOperation}; +pub use pricing::{ModelPriceInput, PricingService, RecordedUsageOutcome, UsageDimension, UsageMeasurement}; +pub use providers::GitHubCliDeliveryProvider as GhCliDeliveryProvider; +pub use providers::GitHubCliDeliveryProvider; +pub use resources::{ + CleanupTarget, DevelopmentResourceController, ResourceLeaseCoordinator, ResourceLeaseInput, + SystemDevelopmentResourceController, +}; +pub use retention::RetentionService; +pub use routes::{DevelopmentRouterState, development_routes}; +pub use runner::{DevelopmentRunner, RunnerContext}; +pub use secrets::{ + MaterializedSecretEnvironment, SecretAccessContext, SecretCreateInput, SecretGrantInput, SecretGrantMetadata, + SecretMetadata, SecretRedactor, SecretReferenceRequest, SecretService, +}; +pub use service::{CompletionEvaluation, DevelopmentService}; +pub use types::*; +pub use workspace::{DevelopmentWorkspacePort, PrepareDevelopmentWorkspace, PreparedDevelopmentWorkspace}; diff --git a/crates/aionui-development/src/observed_usage.rs b/crates/aionui-development/src/observed_usage.rs new file mode 100644 index 000000000..09e61b982 --- /dev/null +++ b/crates/aionui-development/src/observed_usage.rs @@ -0,0 +1,460 @@ +use std::sync::Arc; + +use aionui_db::models::DevelopmentRunRow; +use aionui_db::{IDevelopmentOperationsRepository, IDevelopmentRepository, IProjectRepository}; +use serde_json::{Value, json}; + +use crate::{ + BudgetEvaluation, DevelopmentError, DevelopmentOperationsService, PricingService, RecordedUsageOutcome, + UsageMeasurement, +}; + +#[derive(Debug, Clone)] +pub struct ObservedAgentTurnUsage { + pub user_id: String, + pub conversation_id: String, + pub turn_id: String, + pub agent_id: Option, + pub provider: String, + pub model: String, + pub team_id: Option, + pub slot_id: Option, + pub usage: Option, + pub duration_ms: i64, + pub retry_count: i64, + pub occurred_at: i64, +} + +#[derive(Debug, Clone)] +pub struct DevelopmentBudgetAdmission { + pub run_id: String, + pub run_status: String, + pub evaluation: BudgetEvaluation, +} + +#[derive(Clone)] +pub struct DevelopmentUsageIngestor { + project_repo: Arc, + development_repo: Arc, + operations_repo: Arc, + operations: DevelopmentOperationsService, + pricing: PricingService, +} + +#[derive(Debug, Clone, Copy, Default)] +struct UsageSnapshot { + input_tokens: i64, + output_tokens: i64, + cache_read_tokens: i64, + cache_write_tokens: i64, + cost_microunits: Option, +} + +#[derive(Debug, Clone, Copy, Default)] +struct ReportedUsageSnapshot { + input_tokens: Option, + output_tokens: Option, + cache_read_tokens: Option, + cache_write_tokens: Option, + cost_microunits: Option, +} + +impl DevelopmentUsageIngestor { + pub fn new( + project_repo: Arc, + development_repo: Arc, + operations_repo: Arc, + operations: DevelopmentOperationsService, + pricing: PricingService, + ) -> Self { + Self { + project_repo, + development_repo, + operations_repo, + operations, + pricing, + } + } + + pub async fn admit( + &self, + user_id: &str, + conversation_id: &str, + team_id: Option<&str>, + ) -> Result, DevelopmentError> { + let Some(project) = self.resolve_project(user_id, conversation_id, team_id).await? else { + return Ok(None); + }; + let runs = self.development_repo.list_runs(user_id, Some(&project.id)).await?; + let Some(run) = select_run(&runs, team_id)? else { + return Ok(None); + }; + let evaluation = self + .operations + .evaluate_budget(user_id, &run.id, "agent_turn_admission", 0) + .await?; + Ok(Some(DevelopmentBudgetAdmission { + run_id: run.id.clone(), + run_status: run.status.clone(), + evaluation, + })) + } + + pub async fn record( + &self, + event: ObservedAgentTurnUsage, + ) -> Result, DevelopmentError> { + let project = self + .resolve_project(&event.user_id, &event.conversation_id, event.team_id.as_deref()) + .await?; + let Some(project) = project else { + return Ok(None); + }; + + let runs = self + .development_repo + .list_runs(&event.user_id, Some(&project.id)) + .await?; + let Some(run) = select_run(&runs, event.team_id.as_deref())? else { + return Ok(None); + }; + + let previous = self + .operations_repo + .latest_priced_usage_for_conversation(&event.user_id, &event.conversation_id) + .await? + .and_then(|row| serde_json::from_str::(&row.metadata_json).ok()) + .map(|metadata| snapshot_from_metadata(&metadata)) + .unwrap_or_default(); + let reported = reported_snapshot_from_usage(event.usage.as_ref()); + let current = merge_reported_snapshot(reported, previous); + let delta = snapshot_delta(reported, previous); + let context_occupancy = context_occupancy(event.usage.as_ref()); + + let tasks = self.development_repo.list_tasks(&run.id).await?; + let task_owner = event.slot_id.as_deref().or(event.agent_id.as_deref()); + let mut matching_tasks = tasks.iter().filter(|task| { + !matches!(task.status.as_str(), "completed" | "cancelled" | "deleted") + && task_owner.is_some_and(|owner| task.owner.as_deref() == Some(owner)) + }); + let owner_task = matching_tasks.next().filter(|_| matching_tasks.next().is_none()); + let active_tasks = tasks + .iter() + .filter(|task| !matches!(task.status.as_str(), "completed" | "cancelled" | "deleted")) + .collect::>(); + let task_id = owner_task + .or_else(|| (run.execution_mode == "single" && active_tasks.len() == 1).then(|| active_tasks[0])) + .map(|task| task.id.clone()); + + let provider = non_empty_or_unknown(&event.provider); + let model = non_empty_or_unknown(&event.model); + let event_id = format!("{}:{}", event.conversation_id, event.turn_id); + let outcome = self + .pricing + .record_observed( + UsageMeasurement { + user_id: event.user_id, + project_id: project.id, + conversation_id: Some(event.conversation_id), + agent_id: event.agent_id, + task_id, + run_id: Some(run.id.clone()), + team_id: event.team_id, + provider, + model, + input_tokens: delta.input_tokens, + output_tokens: delta.output_tokens, + cache_read_tokens: delta.cache_read_tokens, + cache_write_tokens: delta.cache_write_tokens, + duration_ms: event.duration_ms.max(0), + retry_count: event.retry_count.max(0), + provider_reported_cost_microunits: delta.cost_microunits, + occurred_at: event.occurred_at, + }, + &event_id, + json!({ + "turn_id": event.turn_id, + "observed_cumulative": { + "input_tokens": current.input_tokens, + "output_tokens": current.output_tokens, + "cache_read_tokens": current.cache_read_tokens, + "cache_write_tokens": current.cache_write_tokens, + "cost_microunits": current.cost_microunits, + }, + "context_occupancy": context_occupancy, + "usage_observation_status": if event.usage.is_some() { "reported" } else { "unavailable" }, + }), + ) + .await?; + Ok(Some(outcome)) + } + + pub async fn pause_after_observation_failure( + &self, + user_id: &str, + conversation_id: &str, + team_id: Option<&str>, + message: &str, + ) -> Result, DevelopmentError> { + let Some(project) = self.resolve_project(user_id, conversation_id, team_id).await? else { + return Ok(None); + }; + let runs = self.development_repo.list_runs(user_id, Some(&project.id)).await?; + let Some(run) = select_run(&runs, team_id)? else { + return Ok(None); + }; + self.operations + .pause_after_runtime_action_failure(user_id, &run.id, message) + .await?; + Ok(Some(run.id.clone())) + } + + async fn resolve_project( + &self, + user_id: &str, + conversation_id: &str, + team_id: Option<&str>, + ) -> Result, DevelopmentError> { + if let Some(project) = self + .project_repo + .get_for_resource(user_id, "conversation", conversation_id) + .await? + { + Ok(Some(project)) + } else if let Some(team_id) = team_id { + self.project_repo + .get_for_resource(user_id, "team", team_id) + .await + .map_err(DevelopmentError::from) + } else { + Ok(None) + } + } +} + +fn non_empty_or_unknown(value: &str) -> String { + let value = value.trim(); + if value.is_empty() { + "unknown".into() + } else { + value.into() + } +} + +fn reported_snapshot_from_usage(usage: Option<&Value>) -> ReportedUsageSnapshot { + let Some(usage) = usage else { + return ReportedUsageSnapshot::default(); + }; + let mut snapshot = ReportedUsageSnapshot { + input_tokens: integer_at(usage, &["input_tokens", "inputTokens"]), + output_tokens: integer_at(usage, &["output_tokens", "outputTokens"]), + cache_read_tokens: integer_at(usage, &["cache_read_tokens", "cacheReadTokens"]), + cache_write_tokens: integer_at(usage, &["cache_write_tokens", "cacheWriteTokens"]), + cost_microunits: integer_at(usage, &["cost_microunits", "costMicrounits"]), + }; + if snapshot.cost_microunits.is_none() + && let Some(cost) = usage.get("cost") + && cost + .get("currency") + .and_then(Value::as_str) + .is_some_and(|currency| currency.eq_ignore_ascii_case("USD")) + && let Some(amount) = cost.get("amount").and_then(Value::as_f64) + && amount.is_finite() + && amount >= 0.0 + { + snapshot.cost_microunits = Some((amount * 1_000_000.0).round() as i64); + } + snapshot +} + +fn merge_reported_snapshot(reported: ReportedUsageSnapshot, previous: UsageSnapshot) -> UsageSnapshot { + UsageSnapshot { + input_tokens: reported.input_tokens.unwrap_or(previous.input_tokens), + output_tokens: reported.output_tokens.unwrap_or(previous.output_tokens), + cache_read_tokens: reported.cache_read_tokens.unwrap_or(previous.cache_read_tokens), + cache_write_tokens: reported.cache_write_tokens.unwrap_or(previous.cache_write_tokens), + cost_microunits: reported.cost_microunits.or(previous.cost_microunits), + } +} + +fn context_occupancy(usage: Option<&Value>) -> Option { + let usage = usage?; + let used = integer_at(usage, &["used"])?; + Some(json!({ + "used": used, + "size": integer_at(usage, &["size"]), + })) +} + +fn snapshot_from_metadata(metadata: &Value) -> UsageSnapshot { + let value = metadata.get("observed_cumulative").unwrap_or(&Value::Null); + UsageSnapshot { + input_tokens: integer_at(value, &["input_tokens"]).unwrap_or_default(), + output_tokens: integer_at(value, &["output_tokens"]).unwrap_or_default(), + cache_read_tokens: integer_at(value, &["cache_read_tokens"]).unwrap_or_default(), + cache_write_tokens: integer_at(value, &["cache_write_tokens"]).unwrap_or_default(), + cost_microunits: integer_at(value, &["cost_microunits"]), + } +} + +fn integer_at(value: &Value, keys: &[&str]) -> Option { + keys.iter() + .find_map(|key| value.get(*key)) + .and_then(|value| { + value + .as_i64() + .or_else(|| value.as_u64().and_then(|value| i64::try_from(value).ok())) + }) + .filter(|value| *value >= 0) +} + +fn snapshot_delta(current: ReportedUsageSnapshot, previous: UsageSnapshot) -> UsageSnapshot { + UsageSnapshot { + input_tokens: current + .input_tokens + .map_or(0, |current| counter_delta(current, previous.input_tokens)), + output_tokens: current + .output_tokens + .map_or(0, |current| counter_delta(current, previous.output_tokens)), + cache_read_tokens: current + .cache_read_tokens + .map_or(0, |current| counter_delta(current, previous.cache_read_tokens)), + cache_write_tokens: current + .cache_write_tokens + .map_or(0, |current| counter_delta(current, previous.cache_write_tokens)), + cost_microunits: current.cost_microunits.map(|current| { + previous + .cost_microunits + .map_or(current, |previous| counter_delta(current, previous)) + }), + } +} + +fn select_run<'a>( + runs: &'a [DevelopmentRunRow], + team_id: Option<&str>, +) -> Result, DevelopmentError> { + let compatible = runs + .iter() + .filter(|run| match team_id { + Some(team_id) => run.team_id.as_deref() == Some(team_id), + None => run.team_id.is_none() && run.execution_mode == "single", + }) + .collect::>(); + let open = compatible + .iter() + .copied() + .filter(|run| !matches!(run.status.as_str(), "succeeded" | "failed" | "paused" | "cancelled")) + .collect::>(); + if open.len() > 1 { + return Err(DevelopmentError::Conflict( + "multiple compatible development runs are active; bind the conversation to an unambiguous run".into(), + )); + } + if let Some(run) = open.into_iter().next() { + return Ok(Some(run)); + } + Ok(compatible + .into_iter() + .max_by_key(|run| (run.updated_at, run.created_at, run.id.as_str())) + .filter(|run| matches!(run.status.as_str(), "paused" | "cancelled"))) +} + +fn counter_delta(current: i64, previous: i64) -> i64 { + if current >= previous { + current - previous + } else { + current + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn run(id: &str, team_id: Option<&str>, execution_mode: &str, status: &str, updated_at: i64) -> DevelopmentRunRow { + DevelopmentRunRow { + id: id.into(), + user_id: "user".into(), + project_id: "project".into(), + team_id: team_id.map(str::to_owned), + source_channel: None, + source_user_id: None, + execution_mode: execution_mode.into(), + status: status.into(), + request_summary: "test".into(), + acceptance_criteria: "[]".into(), + baseline_commit: None, + integration_branch: None, + started_at: Some(updated_at), + finished_at: None, + created_at: updated_at, + updated_at, + } + } + + #[test] + fn acp_context_occupancy_is_not_misreported_as_billable_tokens() { + let reported = reported_snapshot_from_usage(Some(&json!({ + "used": 42, + "size": 100, + "cost": {"amount": 1.25, "currency": "USD"} + }))); + assert_eq!(reported.input_tokens, None); + assert_eq!(reported.cost_microunits, Some(1_250_000)); + assert_eq!( + context_occupancy(Some(&json!({"used": 42, "size": 100}))), + Some(json!({"used": 42, "size": 100})) + ); + } + + #[test] + fn missing_usage_preserves_the_previous_cumulative_watermark() { + let previous = UsageSnapshot { + input_tokens: 100, + output_tokens: 20, + cache_read_tokens: 5, + cache_write_tokens: 3, + cost_microunits: Some(50), + }; + let missing = ReportedUsageSnapshot::default(); + assert_eq!(snapshot_delta(missing, previous).input_tokens, 0); + let preserved = merge_reported_snapshot(missing, previous); + let resumed = reported_snapshot_from_usage(Some(&json!({"input_tokens": 130, "output_tokens": 25}))); + let delta = snapshot_delta(resumed, preserved); + assert_eq!(delta.input_tokens, 30); + assert_eq!(delta.output_tokens, 5); + } + + #[test] + fn counter_reset_starts_a_new_observation_epoch() { + assert_eq!(counter_delta(10, 100), 10); + assert_eq!(counter_delta(120, 100), 20); + } + + #[test] + fn run_selection_never_crosses_team_or_single_boundaries() { + let runs = vec![ + run("other-team", Some("team-b"), "team", "running", 4), + run("single", None, "single", "running", 3), + run("wanted-team", Some("team-a"), "team", "running", 2), + ]; + assert_eq!(select_run(&runs, Some("team-a")).unwrap().unwrap().id, "wanted-team"); + assert_eq!(select_run(&runs, None).unwrap().unwrap().id, "single"); + } + + #[test] + fn ambiguous_active_single_runs_fail_closed() { + let runs = vec![ + run("single-a", None, "single", "running", 2), + run("single-b", None, "single", "reviewing", 1), + ]; + assert!(matches!(select_run(&runs, None), Err(DevelopmentError::Conflict(_)))); + } + + #[test] + fn completed_historical_run_does_not_block_an_unattached_conversation() { + let runs = vec![run("completed", None, "single", "succeeded", 1)]; + assert!(select_run(&runs, None).unwrap().is_none()); + } +} diff --git a/crates/aionui-development/src/operations.rs b/crates/aionui-development/src/operations.rs new file mode 100644 index 000000000..07b8d2574 --- /dev/null +++ b/crates/aionui-development/src/operations.rs @@ -0,0 +1,1257 @@ +use std::collections::BTreeSet; +use std::path::{Component, Path}; +use std::sync::Arc; + +use aionui_common::now_ms; +use aionui_db::models::{ + DevelopmentAlertRow, DevelopmentAuditEventRow, DevelopmentPolicyRow, DevelopmentRecoveryRecordRow, + DevelopmentRunRow, DevelopmentUsageDimensionSummary, DevelopmentUsageEventRow, DevelopmentUsageSummary, + UsageDimension, +}; +use aionui_db::{ + IAgentWorkspaceLeaseRepository, IDevelopmentOperationsRepository, IDevelopmentRepository, IProjectRepository, +}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; + +use crate::DevelopmentError; +use crate::policy::{DevelopmentPolicyRules, PolicyDecision, PolicyEngine, PolicyOperation}; +use crate::resources::{DevelopmentResourceController, ResourceLeaseCoordinator}; + +const DEFAULT_MAX_DURATION_MS: i64 = 4 * 60 * 60 * 1000; +const MAX_AUDIT_PAYLOAD_BYTES: usize = 32 * 1024; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct DevelopmentPolicyInput { + pub isolation_mode: String, + pub container_image: Option, + pub devcontainer_config_path: Option, + pub container_cpu_millis: i64, + pub container_memory_mb: i64, + pub container_pids_limit: i64, + pub network_mode: String, + #[serde(default)] + pub allowed_secret_keys: Vec, + #[serde(default)] + pub allowed_commands: Vec, + #[serde(default)] + pub protected_paths: Vec, + #[serde(default)] + pub allowed_network_hosts: Vec, + #[serde(default)] + pub protected_branches: Vec, + #[serde(default = "default_confirmation_count")] + pub dangerous_confirmation_count: i64, + pub max_duration_ms: i64, + pub max_parallel_agents: i64, + pub max_retries: i64, + pub max_cost_microunits: i64, + #[serde(default)] + pub max_total_tokens: i64, + #[serde(default)] + pub fallback_model: Option, + pub alert_percent: i64, + pub over_limit_action: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct BudgetEvaluation { + pub allowed: bool, + pub action: String, + pub reasons: Vec, + pub usage: DevelopmentUsageSummary, + pub replacement_model: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct DevelopmentOperationsSnapshot { + pub policy: DevelopmentPolicyRow, + pub usage: DevelopmentUsageSummary, + pub priced_usage: DevelopmentUsageDimensionSummary, + pub alerts: Vec, + pub audit: Vec, + pub recovery: Vec, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct RecoveryDecisionInput { + pub action: String, +} + +#[derive(Clone)] +pub struct DevelopmentOperationsService { + operations_repo: Arc, + development_repo: Arc, + project_repo: Arc, + lease_repo: Arc, + resource_coordinator: Option, + resource_controller: Option>, +} + +impl DevelopmentOperationsService { + pub fn new( + operations_repo: Arc, + development_repo: Arc, + project_repo: Arc, + lease_repo: Arc, + ) -> Self { + Self { + operations_repo, + development_repo, + project_repo, + lease_repo, + resource_coordinator: None, + resource_controller: None, + } + } + + pub fn with_resources( + mut self, + coordinator: ResourceLeaseCoordinator, + controller: Arc, + ) -> Self { + self.resource_coordinator = Some(coordinator); + self.resource_controller = Some(controller); + self + } + + pub async fn get_policy(&self, user_id: &str, project_id: &str) -> Result { + self.require_project(user_id, project_id).await?; + Ok(self + .operations_repo + .get_policy(user_id, project_id) + .await? + .unwrap_or_else(|| default_policy(user_id, project_id))) + } + + pub async fn upsert_policy( + &self, + user_id: &str, + project_id: &str, + input: DevelopmentPolicyInput, + ) -> Result { + self.require_project(user_id, project_id).await?; + validate_policy(&input)?; + let existing = self.operations_repo.get_policy(user_id, project_id).await?; + let now = now_ms(); + let mut secret_keys: Vec = input + .allowed_secret_keys + .into_iter() + .map(|key| key.trim().to_owned()) + .collect::>() + .into_iter() + .collect(); + secret_keys.sort(); + let allowed_commands = normalized_values(input.allowed_commands); + let protected_paths = normalized_values(input.protected_paths); + let allowed_network_hosts = normalized_values(input.allowed_network_hosts); + let protected_branches = normalized_values(input.protected_branches); + let row = DevelopmentPolicyRow { + id: existing + .as_ref() + .map(|row| row.id.clone()) + .unwrap_or_else(|| uuid::Uuid::now_v7().to_string()), + user_id: user_id.into(), + project_id: project_id.into(), + isolation_mode: input.isolation_mode, + container_image: clean_optional(input.container_image), + devcontainer_config_path: clean_optional(input.devcontainer_config_path), + container_cpu_millis: input.container_cpu_millis, + container_memory_mb: input.container_memory_mb, + container_pids_limit: input.container_pids_limit, + network_mode: input.network_mode, + allowed_secret_keys_json: serde_json::to_string(&secret_keys) + .map_err(|error| DevelopmentError::Internal(error.to_string()))?, + allowed_commands_json: json_array(&allowed_commands)?, + protected_paths_json: json_array(&protected_paths)?, + allowed_network_hosts_json: json_array(&allowed_network_hosts)?, + protected_branches_json: json_array(&protected_branches)?, + dangerous_confirmation_count: input.dangerous_confirmation_count, + max_duration_ms: input.max_duration_ms, + max_parallel_agents: input.max_parallel_agents, + max_retries: input.max_retries, + max_cost_microunits: input.max_cost_microunits, + max_total_tokens: input.max_total_tokens, + fallback_model: clean_optional(input.fallback_model), + alert_percent: input.alert_percent, + over_limit_action: input.over_limit_action, + created_at: existing.map(|row| row.created_at).unwrap_or(now), + updated_at: now, + }; + self.operations_repo.upsert_policy(&row).await?; + self.audit( + user_id, + "user", + user_id, + "policy.update", + "project", + project_id, + project_id, + None, + None, + "success", + json!({ + "isolation_mode": row.isolation_mode, + "network_mode": row.network_mode, + "allowed_secret_keys": secret_keys, + "allowed_commands": allowed_commands, + "protected_paths": protected_paths, + "allowed_network_hosts": allowed_network_hosts, + "protected_branches": protected_branches, + "dangerous_confirmation_count": row.dangerous_confirmation_count, + "max_duration_ms": row.max_duration_ms, + "max_parallel_agents": row.max_parallel_agents, + "max_retries": row.max_retries, + "max_cost_microunits": row.max_cost_microunits, + "max_total_tokens": row.max_total_tokens, + "fallback_model": row.fallback_model, + "over_limit_action": row.over_limit_action, + }), + &[], + ) + .await?; + Ok(row) + } + + pub async fn evaluate_policy( + &self, + user_id: &str, + project_id: &str, + target_id: &str, + operation: &PolicyOperation, + confirmations: u8, + ) -> Result { + self.require_project(user_id, project_id).await?; + if !target_id.is_empty() { + let run = self.require_run(user_id, target_id).await?; + if run.project_id != project_id { + return Err(DevelopmentError::NotFound(format!("run {target_id}"))); + } + } + let policy = self.get_policy(user_id, project_id).await?; + let rules = DevelopmentPolicyRules { + allowed_commands: parse_string_array(&policy.allowed_commands_json)?, + protected_paths: parse_string_array(&policy.protected_paths_json)?, + allowed_network_hosts: parse_string_array(&policy.allowed_network_hosts_json)?, + protected_branches: parse_string_array(&policy.protected_branches_json)?, + dangerous_confirmation_count: u8::try_from(policy.dangerous_confirmation_count) + .map_err(|_| DevelopmentError::Internal("invalid persisted confirmation count".into()))?, + }; + let decision = PolicyEngine::evaluate(&rules, operation, confirmations); + let result = match decision { + PolicyDecision::Allowed => "success", + PolicyDecision::Denied { .. } => "denied", + PolicyDecision::ConfirmationRequired { .. } => "confirmation_required", + }; + self.audit( + user_id, + "user", + user_id, + &format!("policy.{}", policy_operation_kind(operation)), + "development_run", + target_id, + project_id, + (!target_id.is_empty()).then_some(target_id), + None, + result, + json!({"decision": decision, "confirmations": confirmations}), + &[], + ) + .await?; + Ok(decision) + } + + pub async fn evaluate_budget( + &self, + user_id: &str, + run_id: &str, + operation: &str, + prospective_retry_count: i64, + ) -> Result { + let run = self.require_run(user_id, run_id).await?; + let policy = self.get_policy(user_id, &run.project_id).await?; + let usage = self + .operations_repo + .summarize_usage(user_id, &run.project_id, Some(run_id)) + .await?; + let mut reasons = Vec::new(); + let elapsed = run + .started_at + .map(|started| now_ms().saturating_sub(started)) + .unwrap_or(0); + let consumed_duration = elapsed.max(usage.duration_ms); + if consumed_duration > policy.max_duration_ms { + reasons.push(format!( + "duration budget exceeded: {consumed_duration}ms > {}ms", + policy.max_duration_ms + )); + } + if policy.max_cost_microunits > 0 && usage.cost_microunits > policy.max_cost_microunits { + reasons.push(format!( + "cost budget exceeded: {} > {} microunits", + usage.cost_microunits, policy.max_cost_microunits + )); + } + let total_tokens = usage.input_tokens.saturating_add(usage.output_tokens); + if policy.max_total_tokens > 0 && total_tokens > policy.max_total_tokens { + reasons.push(format!( + "token budget exceeded: {total_tokens} > {}", + policy.max_total_tokens + )); + } + if prospective_retry_count > policy.max_retries { + reasons.push(format!( + "retry budget exceeded: {prospective_retry_count} > {}", + policy.max_retries + )); + } + if operation == "assign_role" { + let roles = self.development_repo.list_roles(run_id).await?; + let slots = roles.iter().map(|role| role.slot_id.as_str()).collect::>(); + if slots.len() as i64 >= policy.max_parallel_agents { + reasons.push(format!( + "parallel agent budget exceeded: {} >= {}", + slots.len(), + policy.max_parallel_agents + )); + } + } + reasons.sort(); + + let threshold_reached = budget_threshold_reached(&policy, &usage, consumed_duration); + if threshold_reached || !reasons.is_empty() { + let severity = if reasons.is_empty() { "warning" } else { "critical" }; + let message = if reasons.is_empty() { + format!("development budget reached {}% warning threshold", policy.alert_percent) + } else { + reasons.join("; ") + }; + self.upsert_alert(&run, "budget", severity, &message, &format!("budget:{run_id}")) + .await?; + } + + let allowed = reasons.is_empty() || policy.over_limit_action == "notify"; + if !reasons.is_empty() { + self.audit( + user_id, + "system", + "development-policy-engine", + &format!("budget.{operation}"), + "development_run", + run_id, + &run.project_id, + Some(run_id), + None, + if allowed { "success" } else { "denied" }, + json!({ + "reasons": reasons, + "action": policy.over_limit_action, + "replacement_model": policy.fallback_model, + "usage": usage + }), + &[], + ) + .await?; + self.apply_budget_action(&run, &policy.over_limit_action).await?; + } + Ok(BudgetEvaluation { + allowed, + action: policy.over_limit_action, + reasons, + usage, + replacement_model: policy.fallback_model, + }) + } + + pub async fn require_budget( + &self, + user_id: &str, + run_id: &str, + operation: &str, + prospective_retry_count: i64, + ) -> Result { + let evaluation = self + .evaluate_budget(user_id, run_id, operation, prospective_retry_count) + .await?; + if evaluation.allowed { + Ok(evaluation) + } else { + Err(DevelopmentError::Conflict(format!( + "development budget blocked {operation}: {}", + evaluation.reasons.join("; ") + ))) + } + } + + pub async fn record_usage(&self, row: DevelopmentUsageEventRow) -> Result<(), DevelopmentError> { + self.require_project(&row.user_id, &row.project_id).await?; + if let Some(run_id) = row.run_id.as_deref() { + let run = self.require_run(&row.user_id, run_id).await?; + if run.project_id != row.project_id { + return Err(DevelopmentError::BadRequest( + "usage run does not belong to the project".into(), + )); + } + } + let run_id = row.run_id.clone(); + let user_id = row.user_id.clone(); + let retry_count = row.retry_count; + self.operations_repo.append_usage(&row).await?; + if let Some(run_id) = run_id { + self.evaluate_budget(&user_id, &run_id, "usage_recorded", retry_count) + .await?; + } + Ok(()) + } + + async fn apply_budget_action(&self, run: &DevelopmentRunRow, action: &str) -> Result<(), DevelopmentError> { + if !budget_action_can_transition(&run.status) { + return Ok(()); + } + match action { + "pause" => { + self.pause_run_if_snapshot_current(run).await?; + } + "terminate" => { + let claimed = self + .development_repo + .update_run_status_if_current( + &run.id, + &run.user_id, + &run.status, + run.updated_at, + "integrating", + None, + ) + .await?; + if !claimed { + return Ok(()); + } + let Some(claimed_run) = self.development_repo.get_run(&run.id, &run.user_id).await? else { + return Err(DevelopmentError::Internal( + "budget termination claim disappeared".into(), + )); + }; + if let (Some(coordinator), Some(controller)) = (&self.resource_coordinator, &self.resource_controller) + && let Err(error) = coordinator.cancel_run(&run.user_id, &run.id, controller.as_ref()).await + { + let _ = self + .development_repo + .update_run_status_if_current( + &run.id, + &run.user_id, + "integrating", + claimed_run.updated_at, + "paused", + None, + ) + .await?; + return Err(error); + } + self.development_repo + .update_run_status_if_current( + &run.id, + &run.user_id, + "integrating", + claimed_run.updated_at, + "cancelled", + Some(now_ms()), + ) + .await?; + } + "notify" | "downgrade_model" => {} + _ => return Err(DevelopmentError::Internal("invalid persisted budget action".into())), + } + Ok(()) + } + + async fn pause_run_if_snapshot_current(&self, run: &DevelopmentRunRow) -> Result<(), DevelopmentError> { + self.development_repo + .update_run_status_if_current(&run.id, &run.user_id, &run.status, run.updated_at, "paused", None) + .await?; + Ok(()) + } + + pub async fn pause_after_runtime_action_failure( + &self, + user_id: &str, + run_id: &str, + message: &str, + ) -> Result<(), DevelopmentError> { + let run = self.require_run(user_id, run_id).await?; + if budget_action_can_transition(&run.status) { + self.pause_run_if_snapshot_current(&run).await?; + } + self.upsert_alert( + &run, + "budget", + "critical", + message, + &format!("budget-runtime-action:{}", run.id), + ) + .await?; + self.audit( + user_id, + "system", + "development-policy-engine", + "budget.runtime_action_failed", + "development_run", + run_id, + &run.project_id, + Some(run_id), + None, + "denied", + json!({"reason": message, "fallback_action": "pause"}), + &[], + ) + .await?; + Ok(()) + } + + pub async fn snapshot( + &self, + user_id: &str, + project_id: &str, + run_id: Option<&str>, + ) -> Result { + self.require_project(user_id, project_id).await?; + if let Some(run_id) = run_id { + let run = self.require_run(user_id, run_id).await?; + if run.project_id != project_id { + return Err(DevelopmentError::NotFound(format!("run {run_id}"))); + } + } + let usage_dimension = run_id + .map(|run_id| UsageDimension::Run(run_id.to_owned())) + .unwrap_or_else(|| UsageDimension::Project(project_id.to_owned())); + Ok(DevelopmentOperationsSnapshot { + policy: self.get_policy(user_id, project_id).await?, + usage: self + .operations_repo + .summarize_usage(user_id, project_id, run_id) + .await?, + priced_usage: self + .operations_repo + .summarize_usage_dimension(user_id, &usage_dimension) + .await?, + alerts: self + .operations_repo + .list_alerts(user_id, project_id, run_id, true) + .await?, + audit: self.operations_repo.list_audit(user_id, project_id, run_id, 50).await?, + recovery: self + .operations_repo + .list_recovery(user_id, project_id, run_id, 50) + .await?, + }) + } + + pub async fn acknowledge_alert( + &self, + user_id: &str, + project_id: &str, + alert_id: &str, + ) -> Result<(), DevelopmentError> { + self.require_project(user_id, project_id).await?; + let belongs_to_project = self + .operations_repo + .list_alerts(user_id, project_id, None, false) + .await? + .iter() + .any(|alert| alert.id == alert_id); + if !belongs_to_project { + return Err(DevelopmentError::NotFound(format!("alert {alert_id}"))); + } + if !self + .operations_repo + .update_alert_status(user_id, alert_id, "acknowledged", None) + .await? + { + return Err(DevelopmentError::NotFound(format!("alert {alert_id}"))); + } + self.audit( + user_id, + "user", + user_id, + "alert.acknowledge", + "development_alert", + alert_id, + project_id, + None, + None, + "success", + json!({}), + &[], + ) + .await?; + Ok(()) + } + + pub async fn reconcile_stale_runs( + &self, + stale_after_ms: i64, + ) -> Result, DevelopmentError> { + if let Some(resources) = &self.resource_coordinator { + resources.reconcile_stale(now_ms()).await?; + } + self.reconcile_stale_runs_scoped(None, stale_after_ms).await + } + + pub async fn reconcile_stale_runs_for_user( + &self, + user_id: &str, + stale_after_ms: i64, + ) -> Result, DevelopmentError> { + if stale_after_ms <= 0 { + return Err(DevelopmentError::BadRequest("stale_after_ms must be positive".into())); + } + if let Some(resources) = &self.resource_coordinator { + resources.reconcile_stale_for_user(user_id, now_ms()).await?; + } + self.reconcile_stale_runs_scoped(Some(user_id), stale_after_ms).await + } + + async fn reconcile_stale_runs_scoped( + &self, + user_id: Option<&str>, + stale_after_ms: i64, + ) -> Result, DevelopmentError> { + if stale_after_ms <= 0 { + return Err(DevelopmentError::BadRequest("stale_after_ms must be positive".into())); + } + let candidates = self + .operations_repo + .list_recovery_candidates(now_ms().saturating_sub(stale_after_ms)) + .await?; + let mut records = Vec::with_capacity(candidates.len()); + for run in candidates { + if user_id.is_some_and(|user_id| user_id != run.user_id) { + continue; + } + let mut interrupted_gate_count = 0_usize; + for mut gate in self.development_repo.list_gates(&run.id, None).await? { + if gate.status == "running" { + gate.status = "interrupted".into(); + gate.finished_at = Some(now_ms()); + gate.duration_ms = gate + .started_at + .map(|started_at| now_ms().saturating_sub(started_at).max(0)); + self.development_repo.update_gate(&gate).await?; + interrupted_gate_count += 1; + } + } + let project = self.project_repo.get_for_user(&run.project_id, &run.user_id).await?; + let mut findings = vec![match project { + None => "project registration is missing".to_owned(), + Some(project) if !Path::new(&project.local_path).is_dir() => { + "project working directory is missing".to_owned() + } + Some(project) if git2::Repository::discover(&project.local_path).is_err() => { + "project Git repository is unavailable".to_owned() + } + Some(_) => "run heartbeat is stale and requires an explicit recovery decision".to_owned(), + }]; + if let Some(team_id) = run.team_id.as_deref() { + let leases = self.lease_repo.list_for_team(team_id).await?; + let relevant = leases + .iter() + .filter(|lease| lease.lease_status != "released") + .collect::>(); + if relevant.is_empty() { + findings.push("team run has no active workspace lease registered".into()); + } + for lease in relevant { + if lease.lease_status != "active" { + findings.push(format!( + "workspace lease {} is in {} state", + lease.id, lease.lease_status + )); + } else if !Path::new(&lease.worktree_path).is_dir() { + findings.push(format!("workspace lease {} worktree is missing", lease.id)); + } else if git2::Repository::discover(&lease.worktree_path).is_err() { + findings.push(format!("workspace lease {} Git worktree is unavailable", lease.id)); + } + if lease.cleanup_status != "not_started" && lease.cleanup_status != "completed" { + findings.push(format!( + "workspace lease {} cleanup is {}", + lease.id, lease.cleanup_status + )); + } + } + } + if interrupted_gate_count > 0 { + findings.push(format!( + "marked {interrupted_gate_count} unfinished quality gate(s) as interrupted" + )); + } + let finding = findings.join("; "); + let recovery_key = format!("run:{}:stale", run.id); + let existing = self + .operations_repo + .list_recovery(&run.user_id, &run.project_id, Some(&run.id), 200) + .await? + .into_iter() + .find(|row| row.recovery_key == recovery_key); + let record = DevelopmentRecoveryRecordRow { + id: existing + .as_ref() + .map(|row| row.id.clone()) + .unwrap_or_else(|| uuid::Uuid::now_v7().to_string()), + user_id: run.user_id.clone(), + project_id: run.project_id.clone(), + run_id: Some(run.id.clone()), + recovery_key: recovery_key.clone(), + finding: finding.clone(), + decision: "manual_required".into(), + status_before: Some(run.status.clone()), + status_after: Some(run.status.clone()), + details_json: json!({"updated_at": run.updated_at}).to_string(), + created_at: existing.map(|row| row.created_at).unwrap_or_else(now_ms), + }; + self.operations_repo.append_recovery(&record).await?; + self.audit( + &run.user_id, + "system", + "development-recovery-reconciler", + "recovery.detect", + "development_run", + &run.id, + &run.project_id, + Some(&run.id), + None, + "success", + json!({"finding": finding, "decision": "manual_required"}), + &[], + ) + .await?; + self.upsert_alert( + &run, + "recovery", + "critical", + &finding, + &format!("recovery:{recovery_key}"), + ) + .await?; + records.push(record); + } + Ok(records) + } + + pub async fn decide_recovery( + &self, + user_id: &str, + run_id: &str, + input: RecoveryDecisionInput, + ) -> Result { + if !matches!( + input.action.as_str(), + "resume" | "retry" | "rollback" | "takeover" | "terminate" + ) { + return Err(DevelopmentError::BadRequest( + "recovery action must be resume, retry, rollback, takeover, or terminate".into(), + )); + } + let run = self.require_run(user_id, run_id).await?; + let recovery_key = format!("run:{run_id}:stale"); + let existing = self + .operations_repo + .list_recovery(user_id, &run.project_id, Some(run_id), 200) + .await? + .into_iter() + .find(|row| row.recovery_key == recovery_key); + let has_recovery_context = existing.as_ref().is_some_and(|row| { + matches!(row.decision.as_str(), "manual_required" | "interrupted") || row.decision == input.action + }); + if run.status == "succeeded" + || (!matches!(run.status.as_str(), "paused" | "cancelled") && !has_recovery_context) + { + return Err(DevelopmentError::Conflict(format!( + "run {} is not awaiting recovery", + run.id + ))); + } + let target = if matches!(input.action.as_str(), "resume" | "retry" | "takeover") { + "running" + } else { + "cancelled" + }; + let pending_record = DevelopmentRecoveryRecordRow { + id: existing + .as_ref() + .map(|row| row.id.clone()) + .unwrap_or_else(|| uuid::Uuid::now_v7().to_string()), + user_id: user_id.into(), + project_id: run.project_id.clone(), + run_id: Some(run_id.into()), + recovery_key, + finding: existing + .as_ref() + .map(|row| row.finding.clone()) + .unwrap_or_else(|| "manual recovery decision".into()), + decision: input.action.clone(), + status_before: existing + .as_ref() + .and_then(|row| row.status_before.clone()) + .or_else(|| Some(run.status.clone())), + status_after: None, + details_json: json!({"state": "pending"}).to_string(), + created_at: existing.as_ref().map(|row| row.created_at).unwrap_or_else(now_ms), + }; + if !self + .operations_repo + .claim_recovery_and_update_run(&pending_record, &run.status, run.updated_at, "paused", None, now_ms()) + .await? + { + return Err(DevelopmentError::Conflict(format!( + "run {} changed state or already has a different recovery decision", + run.id + ))); + } + let recovering_run = self.require_run(user_id, run_id).await?; + if recovering_run.status != "paused" { + return Err(DevelopmentError::Conflict( + "run left its safe recovery state before resources were reconciled".into(), + )); + } + if let Some(resources) = &self.resource_coordinator { + let decision = if input.action == "resume" { + "retry" + } else { + input.action.as_str() + }; + for lease in self.operations_repo.list_resource_leases(user_id, run_id, true).await? { + resources.record_recovery_decision(&lease.id, decision).await?; + } + if matches!(decision, "rollback" | "terminate") + && let Some(controller) = &self.resource_controller + { + resources.cancel_run(user_id, run_id, controller.as_ref()).await?; + } + } + let finished_at = (target == "cancelled").then(now_ms); + if !self + .development_repo + .update_run_status_if_current( + run_id, + user_id, + &recovering_run.status, + recovering_run.updated_at, + target, + finished_at, + ) + .await? + { + return Err(DevelopmentError::Conflict( + "run left its safe recovery state while resources were reconciled".into(), + )); + } + let record = DevelopmentRecoveryRecordRow { + status_after: Some(target.into()), + details_json: "{}".into(), + ..pending_record + }; + self.operations_repo.append_recovery(&record).await?; + for alert in self + .operations_repo + .list_alerts(user_id, &run.project_id, Some(run_id), true) + .await? + { + if alert.alert_type == "recovery" { + self.operations_repo + .update_alert_status(user_id, &alert.id, "resolved", Some(now_ms())) + .await?; + } + } + self.audit( + user_id, + "user", + user_id, + &format!("recovery.{}", input.action), + "development_run", + run_id, + &run.project_id, + Some(run_id), + None, + "success", + json!({"status_before": record.status_before, "status_after": record.status_after}), + &[], + ) + .await?; + Ok(record) + } + + // Keep the audit schema explicit at call sites so security-relevant actor, target, + // ownership and scope fields cannot be silently inherited from ambient state. + #[allow(clippy::too_many_arguments)] + pub async fn audit( + &self, + user_id: &str, + actor_type: &str, + actor_id: &str, + action: &str, + target_type: &str, + target_id: &str, + project_id: &str, + run_id: Option<&str>, + task_id: Option<&str>, + result: &str, + payload: Value, + secret_values: &[String], + ) -> Result<(), DevelopmentError> { + let payload = serde_json::to_string(&payload).map_err(|error| DevelopmentError::Internal(error.to_string()))?; + let mut payload = redact_sensitive(&payload, secret_values); + if payload.len() > MAX_AUDIT_PAYLOAD_BYTES { + payload.truncate(MAX_AUDIT_PAYLOAD_BYTES); + } + let payload = if serde_json::from_str::(&payload).is_ok() { + payload + } else { + serde_json::to_string(&json!({"redacted_text": payload})) + .map_err(|error| DevelopmentError::Internal(error.to_string()))? + }; + self.operations_repo + .append_audit(&DevelopmentAuditEventRow { + id: uuid::Uuid::now_v7().to_string(), + user_id: user_id.into(), + actor_type: actor_type.into(), + actor_id: actor_id.into(), + action: action.into(), + target_type: target_type.into(), + target_id: target_id.into(), + project_id: project_id.into(), + run_id: run_id.map(str::to_owned), + task_id: task_id.map(str::to_owned), + result: result.into(), + redacted_payload_json: payload, + created_at: now_ms(), + }) + .await?; + Ok(()) + } + + async fn require_project( + &self, + user_id: &str, + project_id: &str, + ) -> Result { + self.project_repo + .get_for_user(project_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("project {project_id}"))) + } + + async fn require_run(&self, user_id: &str, run_id: &str) -> Result { + self.development_repo + .get_run(run_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("run {run_id}"))) + } + + async fn upsert_alert( + &self, + run: &DevelopmentRunRow, + alert_type: &str, + severity: &str, + message: &str, + dedupe_key: &str, + ) -> Result<(), DevelopmentError> { + let existing = self + .operations_repo + .list_alerts(&run.user_id, &run.project_id, Some(&run.id), false) + .await? + .into_iter() + .find(|row| row.dedupe_key == dedupe_key); + let now = now_ms(); + self.operations_repo + .upsert_alert(&DevelopmentAlertRow { + id: existing + .as_ref() + .map(|row| row.id.clone()) + .unwrap_or_else(|| uuid::Uuid::now_v7().to_string()), + user_id: run.user_id.clone(), + project_id: run.project_id.clone(), + run_id: Some(run.id.clone()), + alert_type: alert_type.into(), + severity: severity.into(), + status: "open".into(), + message: redact_sensitive(message, &[]), + dedupe_key: dedupe_key.into(), + created_at: existing.map(|row| row.created_at).unwrap_or(now), + updated_at: now, + resolved_at: None, + }) + .await?; + Ok(()) + } +} + +pub fn default_policy(user_id: &str, project_id: &str) -> DevelopmentPolicyRow { + DevelopmentPolicyRow { + id: format!("default:{project_id}"), + user_id: user_id.into(), + project_id: project_id.into(), + isolation_mode: "host".into(), + container_image: None, + devcontainer_config_path: None, + container_cpu_millis: 1000, + container_memory_mb: 2048, + container_pids_limit: 256, + network_mode: "none".into(), + allowed_secret_keys_json: "[]".into(), + allowed_commands_json: "[]".into(), + protected_paths_json: "[\".env\",\".git\",\".github/workflows\"]".into(), + allowed_network_hosts_json: "[]".into(), + protected_branches_json: "[\"main\",\"master\"]".into(), + dangerous_confirmation_count: 2, + max_duration_ms: DEFAULT_MAX_DURATION_MS, + max_parallel_agents: 4, + max_retries: 3, + max_cost_microunits: 0, + max_total_tokens: 0, + fallback_model: None, + alert_percent: 80, + over_limit_action: "pause".into(), + created_at: 0, + updated_at: 0, + } +} + +fn validate_policy(input: &DevelopmentPolicyInput) -> Result<(), DevelopmentError> { + if !matches!(input.isolation_mode.as_str(), "host" | "docker" | "devcontainer") { + return Err(DevelopmentError::BadRequest("unsupported isolation_mode".into())); + } + if input.isolation_mode == "docker" && clean_optional(input.container_image.clone()).is_none() { + return Err(DevelopmentError::BadRequest( + "docker isolation requires container_image".into(), + )); + } + if input.isolation_mode == "devcontainer" { + let path = clean_optional(input.devcontainer_config_path.clone()) + .ok_or_else(|| DevelopmentError::BadRequest("devcontainer isolation requires config path".into()))?; + let candidate = Path::new(&path); + if candidate.is_absolute() + || candidate + .components() + .any(|component| component == Component::ParentDir) + || candidate.extension().and_then(|value| value.to_str()) != Some("json") + { + return Err(DevelopmentError::BadRequest( + "devcontainer config path must be a relative JSON path inside the project".into(), + )); + } + } + if !matches!(input.network_mode.as_str(), "none" | "bridge") { + return Err(DevelopmentError::BadRequest( + "network_mode must be none or bridge".into(), + )); + } + if !(100..=64_000).contains(&input.container_cpu_millis) + || !(128..=262_144).contains(&input.container_memory_mb) + || !(16..=32_768).contains(&input.container_pids_limit) + || input.max_duration_ms <= 0 + || !(1..=64).contains(&input.max_parallel_agents) + || !(0..=100).contains(&input.max_retries) + || input.max_cost_microunits < 0 + || input.max_total_tokens < 0 + || !(1..=2).contains(&input.dangerous_confirmation_count) + || !(1..=100).contains(&input.alert_percent) + { + return Err(DevelopmentError::BadRequest("policy limits are out of range".into())); + } + if !matches!( + input.over_limit_action.as_str(), + "notify" | "pause" | "downgrade_model" | "terminate" + ) { + return Err(DevelopmentError::BadRequest("unsupported over_limit_action".into())); + } + if input.over_limit_action == "downgrade_model" && clean_optional(input.fallback_model.clone()).is_none() { + return Err(DevelopmentError::BadRequest( + "downgrade_model requires fallback_model".into(), + )); + } + for key in &input.allowed_secret_keys { + if !valid_env_key(key.trim()) { + return Err(DevelopmentError::BadRequest(format!( + "invalid Secret environment key: {key}" + ))); + } + } + Ok(()) +} + +fn default_confirmation_count() -> i64 { + 2 +} + +fn normalized_values(values: Vec) -> Vec { + values + .into_iter() + .map(|value| value.trim().to_owned()) + .filter(|value| !value.is_empty()) + .collect::>() + .into_iter() + .collect() +} + +fn json_array(values: &[String]) -> Result { + serde_json::to_string(values).map_err(|error| DevelopmentError::Internal(error.to_string())) +} + +fn parse_string_array(value: &str) -> Result, DevelopmentError> { + serde_json::from_str(value).map_err(|_| DevelopmentError::Internal("invalid persisted policy rules".into())) +} + +fn policy_operation_kind(operation: &PolicyOperation) -> &'static str { + match operation { + PolicyOperation::Command { .. } => "command", + PolicyOperation::Path { .. } => "path", + PolicyOperation::Network { .. } => "network", + PolicyOperation::Git { .. } => "git", + PolicyOperation::Deploy { .. } => "deploy", + PolicyOperation::Delete { .. } => "delete", + } +} + +fn valid_env_key(value: &str) -> bool { + let mut chars = value.chars(); + matches!(chars.next(), Some('_' | 'A'..='Z')) + && chars.all(|character| matches!(character, '_' | 'A'..='Z' | '0'..='9')) + && value.len() <= 128 +} + +fn budget_threshold_reached(policy: &DevelopmentPolicyRow, usage: &DevelopmentUsageSummary, duration_ms: i64) -> bool { + let percentage = + |used: i64, limit: i64| limit > 0 && used.saturating_mul(100) >= limit.saturating_mul(policy.alert_percent); + percentage(duration_ms, policy.max_duration_ms) || percentage(usage.cost_microunits, policy.max_cost_microunits) +} + +fn budget_action_can_transition(status: &str) -> bool { + matches!( + status, + "preflight" | "running" | "waiting_approval" | "verifying" | "reviewing" | "rework" + ) +} + +fn clean_optional(value: Option) -> Option { + value.and_then(|value| { + let value = value.trim(); + (!value.is_empty()).then(|| value.to_owned()) + }) +} + +pub fn redact_sensitive(value: &str, secret_values: &[String]) -> String { + crate::secrets::redact_text(value, secret_values) +} + +#[cfg(test)] +mod tests { + use super::*; + use aionui_db::{ + IDevelopmentRepository, SqliteAgentWorkspaceLeaseRepository, SqliteDevelopmentOperationsRepository, + SqliteDevelopmentRepository, SqliteProjectRepository, init_database_memory, + }; + + async fn budget_action_fixture() -> (DevelopmentOperationsService, Arc) { + let db = init_database_memory().await.expect("database"); + sqlx::query( + "INSERT INTO users (id, username, password_hash, created_at, updated_at) \ + VALUES ('budget-user', 'budget', '', 1, 1)", + ) + .execute(db.pool()) + .await + .expect("user"); + sqlx::query( + "INSERT INTO projects \ + (id, user_id, name, local_path, project_type, created_at, updated_at) \ + VALUES ('budget-project', 'budget-user', 'Budget', '/tmp/budget-project', 'single', 1, 1)", + ) + .execute(db.pool()) + .await + .expect("project"); + let development_repo = Arc::new(SqliteDevelopmentRepository::new(db.pool().clone())); + development_repo + .create_run(&DevelopmentRunRow { + id: "budget-run".into(), + user_id: "budget-user".into(), + project_id: "budget-project".into(), + team_id: None, + source_channel: None, + source_user_id: None, + execution_mode: "single".into(), + status: "running".into(), + request_summary: "Budget race".into(), + acceptance_criteria: "[]".into(), + baseline_commit: None, + integration_branch: None, + started_at: Some(1), + finished_at: None, + created_at: 1, + updated_at: 1, + }) + .await + .expect("run"); + let service = DevelopmentOperationsService::new( + Arc::new(SqliteDevelopmentOperationsRepository::new(db.pool().clone())), + development_repo.clone(), + Arc::new(SqliteProjectRepository::new(db.pool().clone())), + Arc::new(SqliteAgentWorkspaceLeaseRepository::new(db.pool().clone())), + ); + (service, development_repo) + } + + #[tokio::test] + async fn stale_budget_actions_do_not_reopen_a_terminal_run() { + for action in ["pause", "terminate"] { + let (service, repository) = budget_action_fixture().await; + let stale = repository + .get_run("budget-run", "budget-user") + .await + .expect("read stale run") + .expect("run exists"); + repository + .update_run_status("budget-run", "budget-user", "succeeded", Some(10)) + .await + .expect("finish run concurrently"); + + service + .apply_budget_action(&stale, action) + .await + .expect("stale action is ignored"); + + let current = repository + .get_run("budget-run", "budget-user") + .await + .expect("read current run") + .expect("run exists"); + assert_eq!(current.status, "succeeded"); + assert_eq!(current.finished_at, Some(10)); + } + } + + #[tokio::test] + async fn stale_runtime_failure_pause_does_not_reopen_a_terminal_run() { + let (service, repository) = budget_action_fixture().await; + let stale = repository + .get_run("budget-run", "budget-user") + .await + .expect("read stale run") + .expect("run exists"); + repository + .update_run_status("budget-run", "budget-user", "cancelled", Some(20)) + .await + .expect("cancel run concurrently"); + + service + .pause_run_if_snapshot_current(&stale) + .await + .expect("stale pause is ignored"); + + let current = repository + .get_run("budget-run", "budget-user") + .await + .expect("read current run") + .expect("run exists"); + assert_eq!(current.status, "cancelled"); + assert_eq!(current.finished_at, Some(20)); + } +} diff --git a/crates/aionui-development/src/policy.rs b/crates/aionui-development/src/policy.rs new file mode 100644 index 000000000..695f67659 --- /dev/null +++ b/crates/aionui-development/src/policy.rs @@ -0,0 +1,119 @@ +use std::path::{Component, Path}; + +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct DevelopmentPolicyRules { + pub allowed_commands: Vec, + pub protected_paths: Vec, + pub allowed_network_hosts: Vec, + pub protected_branches: Vec, + pub dangerous_confirmation_count: u8, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[serde(tag = "type", rename_all = "snake_case")] +pub enum PolicyOperation { + Command { program: String }, + Path { path: String, write: bool }, + Network { host: String }, + Git { operation: String, branch: Option }, + Deploy { target: String }, + Delete { path: String }, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[serde(tag = "decision", rename_all = "snake_case")] +pub enum PolicyDecision { + Allowed, + Denied { reason: String }, + ConfirmationRequired { remaining: u8 }, +} + +pub struct PolicyEngine; + +impl PolicyEngine { + pub fn evaluate(rules: &DevelopmentPolicyRules, operation: &PolicyOperation, confirmations: u8) -> PolicyDecision { + match operation { + PolicyOperation::Command { program } => { + let command = Path::new(program) + .file_name() + .and_then(|value| value.to_str()) + .unwrap_or(program); + if rules.allowed_commands.iter().any(|allowed| allowed == command) { + PolicyDecision::Allowed + } else { + PolicyDecision::Denied { + reason: "command is outside the Project allowlist".into(), + } + } + } + PolicyOperation::Path { path, write } => { + if unsafe_path(path) { + return PolicyDecision::Denied { + reason: "path escapes the Project boundary".into(), + }; + } + if *write + && rules + .protected_paths + .iter() + .any(|protected| path_matches(protected, path)) + { + PolicyDecision::Denied { + reason: "path is protected".into(), + } + } else { + PolicyDecision::Allowed + } + } + PolicyOperation::Network { host } => { + if rules + .allowed_network_hosts + .iter() + .any(|allowed| allowed.eq_ignore_ascii_case(host)) + { + PolicyDecision::Allowed + } else { + PolicyDecision::Denied { + reason: "network destination is outside the Project allowlist".into(), + } + } + } + PolicyOperation::Git { operation, branch } => { + let dangerous = matches!(operation.as_str(), "push" | "merge" | "force_push" | "tag") + || branch + .as_ref() + .is_some_and(|branch| rules.protected_branches.iter().any(|protected| protected == branch)); + confirmation(rules, confirmations, dangerous) + } + PolicyOperation::Deploy { .. } | PolicyOperation::Delete { .. } => confirmation(rules, confirmations, true), + } + } +} + +fn confirmation(rules: &DevelopmentPolicyRules, confirmations: u8, required: bool) -> PolicyDecision { + if !required { + return PolicyDecision::Allowed; + } + let required = rules.dangerous_confirmation_count.max(1); + if confirmations >= required { + PolicyDecision::Allowed + } else { + PolicyDecision::ConfirmationRequired { + remaining: required - confirmations, + } + } +} + +fn unsafe_path(value: &str) -> bool { + let path = Path::new(value); + path.is_absolute() || path.components().any(|component| component == Component::ParentDir) +} + +fn path_matches(protected: &str, candidate: &str) -> bool { + candidate == protected + || candidate + .strip_prefix(protected) + .is_some_and(|remainder| remainder.starts_with('/') || remainder.starts_with('\\')) +} diff --git a/crates/aionui-development/src/pricing.rs b/crates/aionui-development/src/pricing.rs new file mode 100644 index 000000000..7406b086f --- /dev/null +++ b/crates/aionui-development/src/pricing.rs @@ -0,0 +1,251 @@ +use std::sync::Arc; + +use aionui_common::now_ms; +use aionui_db::IDevelopmentOperationsRepository; +use aionui_db::models::{DevelopmentModelPriceRow, DevelopmentPricedUsageEventRow}; +use serde::{Deserialize, Serialize}; + +use crate::DevelopmentError; +use crate::operations::{BudgetEvaluation, DevelopmentOperationsService}; + +pub use aionui_db::UsageDimension; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct ModelPriceInput { + pub provider: String, + pub model: String, + pub input_per_million_microunits: i64, + pub output_per_million_microunits: i64, + pub cache_read_per_million_microunits: i64, + pub cache_write_per_million_microunits: i64, + pub source_id: String, + pub version: String, + pub effective_at: i64, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct UsageMeasurement { + pub user_id: String, + pub project_id: String, + pub conversation_id: Option, + pub agent_id: Option, + pub task_id: Option, + pub run_id: Option, + pub team_id: Option, + pub provider: String, + pub model: String, + pub input_tokens: i64, + pub output_tokens: i64, + pub cache_read_tokens: i64, + pub cache_write_tokens: i64, + pub duration_ms: i64, + pub retry_count: i64, + pub provider_reported_cost_microunits: Option, + pub occurred_at: i64, +} + +#[derive(Clone)] +pub struct PricingService { + operations: Arc, + budget: Option, +} + +#[derive(Debug, Clone)] +pub struct RecordedUsageOutcome { + pub row: DevelopmentPricedUsageEventRow, + pub budget: Option, + pub inserted: bool, +} + +impl PricingService { + pub fn new(operations: Arc) -> Self { + Self { + operations, + budget: None, + } + } + + pub fn with_budget(mut self, budget: DevelopmentOperationsService) -> Self { + self.budget = Some(budget); + self + } + + pub async fn upsert_price(&self, input: ModelPriceInput) -> Result { + validate_price(&input)?; + let row = DevelopmentModelPriceRow { + id: uuid::Uuid::now_v7().to_string(), + provider: input.provider.trim().into(), + model: input.model.trim().into(), + input_per_million_microunits: input.input_per_million_microunits, + output_per_million_microunits: input.output_per_million_microunits, + cache_read_per_million_microunits: input.cache_read_per_million_microunits, + cache_write_per_million_microunits: input.cache_write_per_million_microunits, + source_id: input.source_id.trim().into(), + version: input.version.trim().into(), + effective_at: input.effective_at, + created_at: now_ms(), + }; + self.operations.upsert_model_price(&row).await?; + Ok(row) + } + + pub async fn record( + &self, + measurement: UsageMeasurement, + ) -> Result { + Ok(self.record_inner(measurement, None, None).await?.row) + } + + pub async fn record_observed( + &self, + measurement: UsageMeasurement, + event_id: &str, + metadata: serde_json::Value, + ) -> Result { + if event_id.trim().is_empty() { + return Err(DevelopmentError::BadRequest("usage event id is required".into())); + } + self.record_inner(measurement, Some(event_id), Some(metadata)).await + } + + async fn record_inner( + &self, + measurement: UsageMeasurement, + event_id: Option<&str>, + metadata: Option, + ) -> Result { + validate_measurement(&measurement)?; + let price = self + .operations + .resolve_model_price(&measurement.provider, &measurement.model, measurement.occurred_at) + .await?; + let (cost, status, origin, source, version, effective_at, confidence) = + if let Some(reported) = measurement.provider_reported_cost_microunits { + (reported, "known", "provider_reported", None, None, None, "reported") + } else if let Some(price) = price { + ( + estimated_cost(&measurement, &price)?, + "known", + "platform_estimated", + Some(price.source_id), + Some(price.version), + Some(price.effective_at), + "estimated", + ) + } else { + (0, "unknown", "unknown", None, None, None, "estimated") + }; + let row = DevelopmentPricedUsageEventRow { + id: event_id + .map(|event_id| format!("observed-agent-turn:{event_id}")) + .unwrap_or_else(|| uuid::Uuid::now_v7().to_string()), + user_id: measurement.user_id, + project_id: measurement.project_id, + run_id: measurement.run_id, + task_id: measurement.task_id, + conversation_id: measurement.conversation_id, + agent_id: measurement.agent_id, + team_id: measurement.team_id, + usage_type: "agent_turn".into(), + source: if origin == "provider_reported" { + "provider" + } else { + "platform" + } + .into(), + confidence: confidence.into(), + provider: measurement.provider, + model: measurement.model, + input_tokens: measurement.input_tokens, + output_tokens: measurement.output_tokens, + cache_read_tokens: measurement.cache_read_tokens, + cache_write_tokens: measurement.cache_write_tokens, + cost_microunits: cost, + cost_status: status.into(), + cost_origin: origin.into(), + price_source_id: source, + price_version: version, + price_effective_at: effective_at, + duration_ms: measurement.duration_ms, + retry_count: measurement.retry_count, + metadata_json: serde_json::to_string(&metadata.unwrap_or_else(|| serde_json::json!({}))) + .map_err(|error| DevelopmentError::Internal(error.to_string()))?, + created_at: measurement.occurred_at, + }; + let inserted = self.operations.append_priced_usage_once(&row).await?; + // Budget enforcement is deliberately retried even when the usage row + // already exists. A previous attempt may have committed the append and + // then failed while persisting the alert/status transition. Both the + // evaluator and runtime actions are idempotent, so a duplicate turn is + // the recovery signal rather than a reason to skip enforcement forever. + let budget = if let (Some(budget), Some(run_id)) = (&self.budget, row.run_id.as_deref()) { + Some( + budget + .evaluate_budget(&row.user_id, run_id, "usage_recorded", row.retry_count) + .await?, + ) + } else { + None + }; + Ok(RecordedUsageOutcome { row, budget, inserted }) + } +} + +fn estimated_cost(measurement: &UsageMeasurement, price: &DevelopmentModelPriceRow) -> Result { + let parts = [ + (measurement.input_tokens, price.input_per_million_microunits), + (measurement.output_tokens, price.output_per_million_microunits), + (measurement.cache_read_tokens, price.cache_read_per_million_microunits), + (measurement.cache_write_tokens, price.cache_write_per_million_microunits), + ]; + let total = parts.into_iter().try_fold(0_i128, |total, (tokens, rate)| { + total.checked_add(i128::from(tokens) * i128::from(rate)) + }); + let total = total + .and_then(|total| total.checked_add(999_999)) + .map(|total| total / 1_000_000) + .and_then(|total| i64::try_from(total).ok()) + .ok_or_else(|| DevelopmentError::BadRequest("usage cost overflow".into()))?; + Ok(total) +} + +fn validate_price(input: &ModelPriceInput) -> Result<(), DevelopmentError> { + if input.provider.trim().is_empty() + || input.model.trim().is_empty() + || input.source_id.trim().is_empty() + || input.version.trim().is_empty() + || [ + input.input_per_million_microunits, + input.output_per_million_microunits, + input.cache_read_per_million_microunits, + input.cache_write_per_million_microunits, + ] + .into_iter() + .any(|value| value < 0) + { + return Err(DevelopmentError::BadRequest("invalid model price".into())); + } + Ok(()) +} + +fn validate_measurement(input: &UsageMeasurement) -> Result<(), DevelopmentError> { + if input.user_id.is_empty() + || input.project_id.is_empty() + || input.provider.is_empty() + || input.model.is_empty() + || [ + input.input_tokens, + input.output_tokens, + input.cache_read_tokens, + input.cache_write_tokens, + input.duration_ms, + input.retry_count, + input.provider_reported_cost_microunits.unwrap_or(0), + ] + .into_iter() + .any(|value| value < 0) + { + return Err(DevelopmentError::BadRequest("invalid usage measurement".into())); + } + Ok(()) +} diff --git a/crates/aionui-development/src/providers/github.rs b/crates/aionui-development/src/providers/github.rs new file mode 100644 index 000000000..bf228642e --- /dev/null +++ b/crates/aionui-development/src/providers/github.rs @@ -0,0 +1,337 @@ +use std::path::Path; + +use aionui_runtime::Builder; +use async_trait::async_trait; +use git2::Repository; +use serde_json::Value; +use sha2::{Digest, Sha256}; + +use crate::delivery::{ + DeliveryProvider, DeliveryProviderSnapshot, ProviderCiCheck, ProviderPullRequest, ProviderReviewComment, + ProviderTag, validate_tag_name, +}; + +#[derive(Debug, Clone, Default)] +pub struct GitHubCliDeliveryProvider; + +#[async_trait] +impl DeliveryProvider for GitHubCliDeliveryProvider { + fn name(&self) -> &'static str { + "github" + } + + async fn preflight(&self, repository: &Path) -> Result<(), String> { + Repository::open(repository).map_err(|error| format!("Git repository unavailable: {error}"))?; + checked_output("gh", &["auth", "status"], repository).await.map(|_| ()) + } + + async fn push(&self, repository: &Path, branch: &str) -> Result<(), String> { + validate_branch(branch)?; + checked_output("git", &["push", "--set-upstream", "origin", branch], repository) + .await + .map(|_| ()) + } + + async fn ensure_pull_request( + &self, + repository: &Path, + head: &str, + base: &str, + title: &str, + body: &str, + ) -> Result { + let existing: Value = serde_json::from_slice( + &checked_output( + "gh", + &[ + "pr", + "list", + "--head", + head, + "--base", + base, + "--state", + "open", + "--json", + "number,url,state,reviewDecision", + ], + repository, + ) + .await?, + ) + .map_err(|error| format!("cannot parse GitHub pull request list: {error}"))?; + if let Some(value) = existing.as_array().and_then(|values| values.first()) { + return parse_pull_request(value); + } + + checked_output( + "gh", + &[ + "pr", "create", "--base", base, "--head", head, "--title", title, "--body", body, + ], + repository, + ) + .await?; + let value: Value = serde_json::from_slice( + &checked_output( + "gh", + &["pr", "view", head, "--json", "number,url,state,reviewDecision"], + repository, + ) + .await?, + ) + .map_err(|error| format!("cannot parse created GitHub pull request: {error}"))?; + parse_pull_request(&value) + } + + async fn synchronize(&self, repository: &Path, number: i64) -> Result { + let number = number.to_string(); + let value: Value = serde_json::from_slice( + &checked_output( + "gh", + &[ + "pr", + "view", + &number, + "--json", + "number,url,state,reviewDecision,statusCheckRollup,comments,reviews", + ], + repository, + ) + .await?, + ) + .map_err(|error| format!("cannot parse GitHub pull request status: {error}"))?; + let pull_request = parse_pull_request(&value)?; + let checks = value + .get("statusCheckRollup") + .and_then(Value::as_array) + .into_iter() + .flatten() + .map(parse_ci_check) + .collect(); + Ok(DeliveryProviderSnapshot { + pull_request, + checks, + review_comments: parse_review_comments(&value), + }) + } + + async fn merge(&self, repository: &Path, number: i64) -> Result<(), String> { + checked_output("gh", &["pr", "merge", &number.to_string(), "--merge"], repository) + .await + .map(|_| ()) + } + + async fn ensure_tag(&self, repository: &Path, tag: &str, commit: &str) -> Result { + validate_tag_name(tag).map_err(|error| error.to_string())?; + { + let handle = Repository::open(repository).map_err(|error| error.to_string())?; + let object = handle.revparse_single(commit).map_err(|error| error.to_string())?; + if let Ok(existing) = handle.revparse_single(&format!("refs/tags/{tag}")) { + if existing.id() != object.id() { + return Err("tag already points to a different commit".into()); + } + } else { + handle + .tag_lightweight(tag, &object, false) + .map_err(|error| error.to_string())?; + } + } + checked_output("git", &["push", "origin", &format!("refs/tags/{tag}")], repository).await?; + Ok(ProviderTag { + name: tag.into(), + commit_sha: commit.into(), + remote_url: None, + }) + } +} + +async fn checked_output(program: &str, arguments: &[&str], directory: &Path) -> Result, String> { + let mut command = Builder::clean_cli(program); + command.args(arguments).current_dir(directory); + let output = command.output().await.map_err(|error| error.to_string())?; + if output.status.success() { + Ok(output.stdout) + } else { + Err(String::from_utf8_lossy(&output.stderr).trim().to_owned()) + } +} + +fn parse_pull_request(value: &Value) -> Result { + let number = value + .get("number") + .and_then(Value::as_i64) + .ok_or_else(|| "GitHub response has no pull request number".to_string())?; + Ok(ProviderPullRequest { + number, + url: value.get("url").and_then(Value::as_str).unwrap_or_default().into(), + status: value + .get("state") + .and_then(Value::as_str) + .unwrap_or("OPEN") + .to_ascii_lowercase(), + review_status: match value.get("reviewDecision").and_then(Value::as_str).unwrap_or_default() { + "APPROVED" => "approved", + "CHANGES_REQUESTED" => "changes_requested", + _ => "pending", + } + .into(), + }) +} + +fn parse_ci_check(value: &Value) -> ProviderCiCheck { + let name = value + .get("name") + .or_else(|| value.get("workflowName")) + .and_then(Value::as_str) + .unwrap_or("GitHub check") + .to_owned(); + let details_url = value + .get("detailsUrl") + .or_else(|| value.get("targetUrl")) + .and_then(Value::as_str) + .map(str::to_owned); + let raw_status = value + .get("conclusion") + .and_then(Value::as_str) + .filter(|status| !status.is_empty()) + .or_else(|| value.get("status").and_then(Value::as_str)) + .unwrap_or("QUEUED"); + let digest = Sha256::digest(format!("{name}:{}", details_url.as_deref().unwrap_or_default()).as_bytes()); + ProviderCiCheck { + id: format!("github-{}", hex_prefix(&digest, 24)), + name, + status: normalize_check_status(raw_status), + details_url, + summary: value.get("description").and_then(Value::as_str).map(str::to_owned), + } +} + +fn parse_review_comments(value: &Value) -> Vec { + let issue_comments = value.get("comments").and_then(Value::as_array).into_iter().flatten(); + let actionable_reviews = value + .get("reviews") + .and_then(Value::as_array) + .into_iter() + .flatten() + .filter(|review| { + matches!( + review.get("state").and_then(Value::as_str), + Some("CHANGES_REQUESTED" | "COMMENTED") + ) + }); + issue_comments + .chain(actionable_reviews) + .filter_map(|comment| { + let body = comment.get("body").and_then(Value::as_str)?.trim(); + if body.is_empty() { + return None; + } + let id = comment.get("id").and_then(|value| { + value + .as_str() + .map(str::to_owned) + .or_else(|| value.as_i64().map(|id| id.to_string())) + })?; + Some(ProviderReviewComment { + id, + body: body.into(), + url: comment.get("url").and_then(Value::as_str).map(str::to_owned), + author: comment + .get("author") + .and_then(|author| author.get("login")) + .and_then(Value::as_str) + .map(str::to_owned), + resolved: comment.get("isResolved").and_then(Value::as_bool).unwrap_or(false), + }) + }) + .collect() +} + +fn normalize_check_status(status: &str) -> String { + match status.to_ascii_lowercase().as_str() { + "success" | "passed" => "passed", + "failure" | "failed" | "error" | "timed_out" | "action_required" => "failed", + "cancelled" => "cancelled", + "skipped" | "neutral" => "skipped", + "in_progress" | "pending" => "in_progress", + _ => "queued", + } + .into() +} + +fn validate_branch(branch: &str) -> Result<(), String> { + if branch.is_empty() + || matches!(branch, "main" | "master") + || branch.contains("..") + || branch.chars().any(|value| value.is_whitespace() || value.is_control()) + { + return Err("unsafe delivery branch".into()); + } + Ok(()) +} + +fn hex_prefix(bytes: &[u8], length: usize) -> String { + bytes + .iter() + .flat_map(|byte| format!("{byte:02x}").chars().collect::>()) + .take(length) + .collect() +} + +#[cfg(test)] +mod tests { + use serde_json::json; + + use super::{parse_ci_check, parse_pull_request, parse_review_comments}; + + #[test] + fn parses_typed_github_delivery_snapshot() { + let value = json!({ + "number": 42, + "url": "https://github.example/pull/42", + "state": "OPEN", + "reviewDecision": "CHANGES_REQUESTED", + "comments": [{ + "id": "IC_1", + "body": "Please add a regression test", + "url": "https://github.example/pull/42#comment-1", + "author": {"login": "reviewer"} + }] + }); + let pull_request = parse_pull_request(&value).unwrap(); + assert_eq!(pull_request.number, 42); + assert_eq!(pull_request.review_status, "changes_requested"); + let comments = parse_review_comments(&value); + assert_eq!(comments.len(), 1); + assert!(!comments[0].resolved); + assert_eq!( + parse_ci_check(&json!({"name": "unit", "conclusion": "SUCCESS"})).status, + "passed" + ); + } + + #[test] + fn approved_review_body_is_not_an_unresolved_rework_comment() { + let value = json!({ + "reviews": [ + { + "id": "PRR_APPROVED", + "state": "APPROVED", + "body": "The candidate is ready to merge", + "author": {"login": "reviewer"} + }, + { + "id": "PRR_CHANGES", + "state": "CHANGES_REQUESTED", + "body": "Add a regression test", + "author": {"login": "reviewer"} + } + ] + }); + + let comments = parse_review_comments(&value); + assert_eq!(comments.len(), 1); + assert_eq!(comments[0].id, "PRR_CHANGES"); + } +} diff --git a/crates/aionui-development/src/providers/mod.rs b/crates/aionui-development/src/providers/mod.rs new file mode 100644 index 000000000..8d412ffcb --- /dev/null +++ b/crates/aionui-development/src/providers/mod.rs @@ -0,0 +1,3 @@ +mod github; + +pub use github::GitHubCliDeliveryProvider; diff --git a/crates/aionui-development/src/requirements.rs b/crates/aionui-development/src/requirements.rs new file mode 100644 index 000000000..44fc959c6 --- /dev/null +++ b/crates/aionui-development/src/requirements.rs @@ -0,0 +1,82 @@ +use std::collections::BTreeMap; + +use aionui_api_types::{ + AcceptanceCriterion, CriterionCoverage, PlanRevision, RequirementVersion, RequirementsSnapshot, +}; +use aionui_db::models::{ + AcceptanceCriterionRow, CompletionEvidenceRow, PlanRevisionRow, RequirementVersionRow, TaskCriterionRow, +}; + +pub(crate) fn build_snapshot( + run_id: &str, + versions: Vec, + criteria: Vec, + plans: Vec, + mappings: Vec, + evidence: Vec, +) -> RequirementsSnapshot { + let original_requirement = versions.first().map(|row| row.content.clone()).unwrap_or_default(); + let mut task_ids: BTreeMap<&str, Vec> = BTreeMap::new(); + for mapping in &mappings { + task_ids + .entry(mapping.criterion_id.as_str()) + .or_default() + .push(mapping.task_id.clone()); + } + let mut evidence_ids: BTreeMap<&str, Vec> = BTreeMap::new(); + let mut accepted: BTreeMap<&str, bool> = BTreeMap::new(); + for item in &evidence { + evidence_ids + .entry(item.criterion_id.as_str()) + .or_default() + .push(item.id.clone()); + if item.accepted { + accepted.insert(item.criterion_id.as_str(), true); + } + } + let coverage = criteria + .iter() + .map(|criterion| CriterionCoverage { + criterion_id: criterion.id.clone(), + statement: criterion.statement.clone(), + task_ids: task_ids.remove(criterion.id.as_str()).unwrap_or_default(), + evidence_ids: evidence_ids.remove(criterion.id.as_str()).unwrap_or_default(), + accepted: accepted.get(criterion.id.as_str()).copied().unwrap_or(false), + }) + .collect(); + RequirementsSnapshot { + run_id: run_id.into(), + original_requirement, + requirement_versions: versions + .into_iter() + .map(|row| RequirementVersion { + id: row.id, + version: row.version, + content: row.content, + change_summary: row.change_summary, + created_at: row.created_at, + }) + .collect(), + active_criteria: criteria + .into_iter() + .map(|row| AcceptanceCriterion { + id: row.id, + requirement_version_id: row.requirement_version_id, + ordinal: row.ordinal, + statement: row.statement, + required: row.required, + }) + .collect(), + plan_revisions: plans + .into_iter() + .map(|row| PlanRevision { + id: row.id, + revision: row.revision, + summary: row.summary, + content: row.content, + created_at: row.created_at, + }) + .collect(), + coverage, + } +} diff --git a/crates/aionui-development/src/resources.rs b/crates/aionui-development/src/resources.rs new file mode 100644 index 000000000..8c415fc2a --- /dev/null +++ b/crates/aionui-development/src/resources.rs @@ -0,0 +1,488 @@ +use std::sync::Arc; + +use aionui_common::now_ms; +use aionui_db::{ExecutionResourceLeaseRow, IDevelopmentOperationsRepository}; +use async_trait::async_trait; +use tracing::{info, warn}; + +use crate::DevelopmentError; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ResourceLeaseInput { + pub user_id: String, + pub project_id: String, + pub run_id: String, + pub task_id: Option, + pub turn_id: Option, + pub gate_id: Option, + pub environment_id: String, + pub environment_kind: String, + pub resource_kind: String, + pub resource_identifier: String, + pub cleanup_order: i64, + pub ttl_ms: i64, +} + +#[derive(Debug, Clone, Copy)] +pub struct CleanupTarget<'a> { + pub resource_kind: &'a str, + pub resource_identifier: &'a str, + pub environment_id: &'a str, +} + +#[async_trait] +pub trait DevelopmentResourceController: Send + Sync { + async fn signal_agent(&self, run_id: &str) -> Result<(), String>; + async fn cleanup(&self, target: CleanupTarget<'_>) -> Result<(), String>; +} + +#[derive(Debug, Default)] +pub struct SystemDevelopmentResourceController; + +#[async_trait] +impl DevelopmentResourceController for SystemDevelopmentResourceController { + async fn signal_agent(&self, _run_id: &str) -> Result<(), String> { + Ok(()) + } + + async fn cleanup(&self, target: CleanupTarget<'_>) -> Result<(), String> { + match target.resource_kind { + "process" => { + let pid = target + .resource_identifier + .parse::() + .map_err(|_| "invalid persisted process identifier".to_owned())?; + aionui_runtime::kill_process_tree_by_id(pid) + .await + .map_err(|error| error.to_string()) + } + "container" => { + let mut command = aionui_runtime::Builder::clean_cli("docker"); + command.args(["rm", "--force", target.resource_identifier]); + let output = command.output().await.map_err(|error| error.to_string())?; + if output.status.success() || String::from_utf8_lossy(&output.stderr).contains("No such container") { + Ok(()) + } else { + Err("container cleanup failed".into()) + } + } + "service" => cleanup_devcontainer_service(target.resource_identifier).await, + "port" | "lock" | "workspace" => Ok(()), + _ => Err("unsupported persisted resource kind".into()), + } + } +} + +async fn cleanup_devcontainer_service(workspace: &str) -> Result<(), String> { + let filter = format!("label=devcontainer.local_folder={workspace}"); + let mut list = aionui_runtime::Builder::clean_cli("docker"); + list.args(["ps", "--quiet", "--filter", &filter]); + let output = list.output().await.map_err(|error| error.to_string())?; + if !output.status.success() { + return Err("dev container discovery failed".into()); + } + for container_id in String::from_utf8_lossy(&output.stdout) + .lines() + .map(str::trim) + .filter(|value| !value.is_empty()) + { + let mut remove = aionui_runtime::Builder::clean_cli("docker"); + remove.args(["rm", "--force", container_id]); + let removed = remove.output().await.map_err(|error| error.to_string())?; + if !removed.status.success() && !String::from_utf8_lossy(&removed.stderr).contains("No such container") { + return Err("dev container cleanup failed".into()); + } + } + Ok(()) +} + +#[derive(Clone)] +pub struct ResourceLeaseCoordinator { + repo: Arc, + instance_id: String, +} + +impl ResourceLeaseCoordinator { + pub fn new(repo: Arc, instance_id: impl Into) -> Self { + Self { + repo, + instance_id: instance_id.into(), + } + } + + pub async fn create(&self, input: ResourceLeaseInput) -> Result { + validate_kind(&input.environment_kind, &input.resource_kind)?; + if input.ttl_ms <= 0 { + return Err(DevelopmentError::BadRequest( + "resource lease ttl must be positive".into(), + )); + } + let expected_cleanup_order = cleanup_order(&input.resource_kind); + if input.cleanup_order != expected_cleanup_order { + return Err(DevelopmentError::BadRequest(format!( + "{} resources require cleanup order {expected_cleanup_order}", + input.resource_kind + ))); + } + let now = now_ms(); + let row = ExecutionResourceLeaseRow { + id: uuid::Uuid::now_v7().to_string(), + user_id: input.user_id, + project_id: input.project_id, + run_id: input.run_id, + task_id: input.task_id, + turn_id: input.turn_id, + gate_id: input.gate_id, + environment_id: input.environment_id, + environment_kind: input.environment_kind, + cleanup_order: expected_cleanup_order, + resource_kind: input.resource_kind, + resource_identifier: input.resource_identifier, + status: "active".into(), + accepts_work: 1, + owner_instance_id: self.instance_id.clone(), + heartbeat_at: now, + expires_at: now.saturating_add(input.ttl_ms), + cleanup_status: None, + cleanup_result: None, + recovery_decision: None, + created_at: now, + updated_at: now, + terminal_at: None, + }; + self.repo.upsert_resource_lease(&row).await?; + info!( + lease_id = %row.id, + run_id = %row.run_id, + resource_kind = %row.resource_kind, + environment_id = %row.environment_id, + "execution resource lease created" + ); + Ok(row) + } + + pub async fn heartbeat( + &self, + lease: &mut ExecutionResourceLeaseRow, + ttl_ms: i64, + ) -> Result { + if lease.owner_instance_id != self.instance_id { + return Err(DevelopmentError::Conflict( + "resource lease is owned by another instance".into(), + )); + } + if lease.status != "active" || lease.accepts_work == 0 || lease.terminal_at.is_some() { + return Err(DevelopmentError::Conflict( + "resource lease no longer accepts work".into(), + )); + } + let now = now_ms(); + let updated = self + .repo + .heartbeat_resource_lease( + &lease.id, + &lease.owner_instance_id, + lease.updated_at, + now, + now.saturating_add(ttl_ms.max(1)), + ) + .await?; + let Some(current) = updated else { + return Err(DevelopmentError::Conflict( + "resource lease ownership or status changed during heartbeat".into(), + )); + }; + *lease = current.clone(); + Ok(current) + } + + pub async fn complete( + &self, + lease: &ExecutionResourceLeaseRow, + cleanup_result: &str, + ) -> Result { + if matches!(lease.status.as_str(), "released" | "cleanup_failed") { + return Ok(lease.clone()); + } + if lease.owner_instance_id != self.instance_id { + return Err(DevelopmentError::Conflict( + "resource lease is owned by another instance".into(), + )); + } + if lease.status != "active" || lease.accepts_work != 1 || lease.terminal_at.is_some() { + return Err(DevelopmentError::Conflict( + "resource lease no longer accepts normal completion".into(), + )); + } + let completed_at = now_ms(); + let updated = self + .repo + .complete_resource_lease( + &lease.id, + &lease.owner_instance_id, + lease.updated_at, + cleanup_result, + completed_at, + ) + .await?; + if !updated { + return Err(DevelopmentError::Conflict( + "resource lease ownership or status changed during completion".into(), + )); + } + self.require_lease(&lease.id).await + } + + pub async fn cancel_run( + &self, + user_id: &str, + run_id: &str, + controller: &dyn DevelopmentResourceController, + ) -> Result, DevelopmentError> { + let candidates = self.repo.list_resource_leases(user_id, run_id, true).await?; + let mut claimed = Vec::new(); + let mut claim_error = None; + for lease in candidates { + let mut current = lease; + let mut acquired = false; + for _ in 0..3 { + if !matches!(current.status.as_str(), "active" | "orphaned" | "cleanup_failed") { + break; + } + let claimed_at = now_ms(); + let updated = self + .repo + .claim_resource_cleanup( + ¤t.id, + ¤t.owner_instance_id, + ¤t.status, + current.updated_at, + &self.instance_id, + claimed_at, + ) + .await?; + if let Some(claimed_lease) = updated { + claimed.push(claimed_lease); + acquired = true; + break; + } + current = self.require_lease(¤t.id).await?; + } + if !acquired + && matches!( + current.status.as_str(), + "active" | "stopping" | "orphaned" | "cleanup_failed" + ) + { + claim_error.get_or_insert_with(|| { + format!( + "resource lease {} could not be fenced for cleanup from status {}", + current.id, current.status + ) + }); + } + } + if claimed.is_empty() { + if let Some(error) = claim_error { + return Err(DevelopmentError::Conflict(error)); + } + return Ok(Vec::new()); + } + + let mut first_error = claim_error; + if let Err(error) = controller.signal_agent(run_id).await { + first_error.get_or_insert(error); + } + let mut results = Vec::with_capacity(claimed.len()); + for lease in claimed { + let target = CleanupTarget { + resource_kind: &lease.resource_kind, + resource_identifier: &lease.resource_identifier, + environment_id: &lease.environment_id, + }; + let cleanup = controller.cleanup(target).await; + let (succeeded, cleanup_result) = match cleanup { + Ok(()) => (true, "ok"), + Err(error) => { + warn!( + lease_id = %lease.id, + run_id = %lease.run_id, + resource_kind = %lease.resource_kind, + "execution resource cleanup failed" + ); + first_error.get_or_insert(error); + (false, "controller_error") + } + }; + let finished = now_ms(); + let finalized = self + .repo + .finish_resource_cleanup( + &lease.id, + &self.instance_id, + lease.updated_at, + succeeded, + cleanup_result, + finished, + ) + .await?; + if !finalized { + first_error.get_or_insert_with(|| { + format!( + "resource lease {} changed owner or recovery epoch during cleanup", + lease.id + ) + }); + } + results.push(self.require_lease(&lease.id).await?); + } + info!( + run_id, + lease_count = results.len(), + "execution resource cleanup completed" + ); + if let Some(error) = first_error { + return Err(DevelopmentError::Internal(error)); + } + Ok(results) + } + + pub async fn reconcile_stale(&self, now: i64) -> Result, DevelopmentError> { + let candidates = self.repo.list_stale_resource_leases(now).await?; + self.reconcile_candidates(candidates, now).await + } + + pub async fn reconcile_stale_for_user( + &self, + user_id: &str, + now: i64, + ) -> Result, DevelopmentError> { + let candidates = self + .repo + .list_stale_resource_leases(now) + .await? + .into_iter() + .filter(|candidate| candidate.user_id == user_id) + .collect(); + self.reconcile_candidates(candidates, now).await + } + + async fn reconcile_candidates( + &self, + candidates: Vec, + now: i64, + ) -> Result, DevelopmentError> { + let mut rows = Vec::with_capacity(candidates.len()); + for candidate in candidates { + let orphaned = self + .repo + .orphan_resource_lease(&candidate.id, &candidate.owner_instance_id, candidate.expires_at, now) + .await?; + let Some(row) = orphaned else { + continue; + }; + warn!( + lease_id = %row.id, + run_id = %row.run_id, + resource_kind = %row.resource_kind, + environment_id = %row.environment_id, + "stale execution resource lease requires reconciliation" + ); + rows.push(row); + } + Ok(rows) + } + + pub async fn record_recovery_decision( + &self, + lease_id: &str, + decision: &str, + ) -> Result { + if !matches!(decision, "retry" | "rollback" | "takeover" | "terminate") { + return Err(DevelopmentError::BadRequest("unsupported recovery decision".into())); + } + let row = self.require_lease(lease_id).await?; + if decision == "takeover" { + if is_active_takeover_owner(&row, &self.instance_id) { + return Ok(row); + } + if row.status != "orphaned" || row.terminal_at.is_some() { + return Err(DevelopmentError::Conflict( + "only a non-terminal orphaned resource lease can be taken over".into(), + )); + } + } + if let Some(existing) = row.recovery_decision.as_deref() { + if existing != decision { + return Err(DevelopmentError::Conflict(format!( + "resource lease recovery is already decided as {existing}" + ))); + } + if decision != "takeover" { + return Ok(row); + } + } + let takeover_owner = (decision == "takeover").then_some(self.instance_id.as_str()); + let claimed = self + .repo + .claim_resource_recovery_decision(lease_id, decision, takeover_owner, now_ms()) + .await?; + if let Some(persisted) = claimed { + return Ok(persisted); + } + let persisted = self.require_lease(lease_id).await?; + let is_idempotent = if decision == "takeover" { + is_active_takeover_owner(&persisted, &self.instance_id) + } else { + persisted.recovery_decision.as_deref() == Some(decision) + }; + if !is_idempotent { + return Err(DevelopmentError::Conflict(format!( + "resource lease recovery is already decided as {} by {}", + persisted.recovery_decision.as_deref().unwrap_or("unknown"), + persisted.owner_instance_id + ))); + } + Ok(persisted) + } + + async fn require_lease(&self, lease_id: &str) -> Result { + self.repo + .get_resource_lease(lease_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("resource lease {lease_id}"))) + } +} + +fn is_active_takeover_owner(row: &ExecutionResourceLeaseRow, instance_id: &str) -> bool { + row.recovery_decision.as_deref() == Some("takeover") + && row.owner_instance_id == instance_id + && row.status == "active" + && row.accepts_work == 1 + && row.terminal_at.is_none() +} + +fn validate_kind(environment_kind: &str, resource_kind: &str) -> Result<(), DevelopmentError> { + if !matches!(environment_kind, "host" | "docker" | "devcontainer") { + return Err(DevelopmentError::BadRequest("unsupported execution environment".into())); + } + if !matches!( + resource_kind, + "process" | "container" | "service" | "port" | "lock" | "workspace" + ) { + return Err(DevelopmentError::BadRequest("unsupported resource kind".into())); + } + Ok(()) +} + +fn cleanup_order(resource_kind: &str) -> i64 { + match resource_kind { + "process" => 20, + "service" => 30, + "container" => 40, + "port" => 50, + "lock" => 55, + "workspace" => 60, + _ => i64::MAX, + } +} diff --git a/crates/aionui-development/src/retention.rs b/crates/aionui-development/src/retention.rs new file mode 100644 index 000000000..6de624949 --- /dev/null +++ b/crates/aionui-development/src/retention.rs @@ -0,0 +1,348 @@ +use aionui_api_types::{ + DevelopmentRetentionPolicy, RetentionCleanupReport, RetentionCleanupRequest, RetentionPolicyInput, +}; +use aionui_common::now_ms; +use aionui_db::SqlitePool; +use sqlx::{Row, Sqlite, Transaction}; +use uuid::Uuid; + +use crate::DevelopmentError; + +const DAY_MS: i64 = 24 * 60 * 60 * 1_000; +const DEFAULT_HISTORY_DAYS: i64 = 365; +const DEFAULT_ARTIFACT_DAYS: i64 = 90; +const DEFAULT_EVALUATION_DAYS: i64 = 365; +const MIN_RETENTION_DAYS: i64 = 1; +const MAX_RETENTION_DAYS: i64 = 3_650; + +#[derive(Clone)] +pub struct RetentionService { + pool: SqlitePool, +} + +impl RetentionService { + pub fn new(pool: SqlitePool) -> Self { + Self { pool } + } + + pub async fn get_policy( + &self, + user_id: &str, + project_id: &str, + ) -> Result { + self.require_project(user_id, project_id).await?; + let row = sqlx::query( + "SELECT user_id,project_id,conversation_history_days,artifact_days,evaluation_days,\ + immutable_audit_log,updated_at FROM development_retention_policies \ + WHERE user_id=? AND project_id=?", + ) + .bind(user_id) + .bind(project_id) + .fetch_optional(&self.pool) + .await + .map_err(internal)?; + match row { + Some(row) => policy_from_row(&row), + None => Ok(DevelopmentRetentionPolicy { + user_id: user_id.into(), + project_id: project_id.into(), + conversation_history_days: DEFAULT_HISTORY_DAYS, + artifact_days: DEFAULT_ARTIFACT_DAYS, + evaluation_days: DEFAULT_EVALUATION_DAYS, + immutable_audit_log: true, + updated_at: 0, + }), + } + } + + pub async fn update_policy( + &self, + user_id: &str, + project_id: &str, + input: RetentionPolicyInput, + ) -> Result { + self.require_project(user_id, project_id).await?; + validate_days(input.conversation_history_days)?; + validate_days(input.artifact_days)?; + validate_days(input.evaluation_days)?; + let updated_at = now_ms(); + sqlx::query( + "INSERT INTO development_retention_policies \ + (user_id,project_id,conversation_history_days,artifact_days,evaluation_days,immutable_audit_log,updated_at) \ + VALUES (?,?,?,?,?,1,?) ON CONFLICT(user_id,project_id) DO UPDATE SET \ + conversation_history_days=excluded.conversation_history_days,artifact_days=excluded.artifact_days,\ + evaluation_days=excluded.evaluation_days,updated_at=excluded.updated_at", + ) + .bind(user_id) + .bind(project_id) + .bind(input.conversation_history_days) + .bind(input.artifact_days) + .bind(input.evaluation_days) + .bind(updated_at) + .execute(&self.pool) + .await + .map_err(internal)?; + self.get_policy(user_id, project_id).await + } + + pub async fn cleanup( + &self, + user_id: &str, + project_id: &str, + request: RetentionCleanupRequest, + ) -> Result { + let policy = self.get_policy(user_id, project_id).await?; + let now = now_ms(); + let history_cutoff = cutoff(now, policy.conversation_history_days); + let artifact_cutoff = cutoff(now, policy.artifact_days); + let evaluation_cutoff = cutoff(now, policy.evaluation_days); + let counts = cleanup_counts( + &self.pool, + user_id, + project_id, + history_cutoff, + artifact_cutoff, + evaluation_cutoff, + ) + .await?; + if request.dry_run { + return Ok(report(None, project_id, true, counts, now)); + } + + let required_confirmations: i64 = sqlx::query_scalar( + "SELECT COALESCE(MAX(dangerous_confirmation_count),2) FROM development_policies \ + WHERE user_id=? AND project_id=?", + ) + .bind(user_id) + .bind(project_id) + .fetch_one(&self.pool) + .await + .map_err(internal)?; + if i64::from(request.confirmation_count) < required_confirmations.max(2) { + return Err(DevelopmentError::BadRequest(format!( + "retention cleanup requires {} confirmations", + required_confirmations.max(2) + ))); + } + + let execution_id = Uuid::now_v7().to_string(); + let mut transaction = self.pool.begin().await.map_err(internal)?; + let applied_counts = delete_expired( + &mut transaction, + user_id, + project_id, + history_cutoff, + artifact_cutoff, + evaluation_cutoff, + ) + .await?; + sqlx::query( + "INSERT INTO development_retention_executions \ + (id,user_id,project_id,message_count,artifact_count,evaluation_count,audit_events_retained,created_at) \ + VALUES (?,?,?,?,?,?,?,?)", + ) + .bind(&execution_id) + .bind(user_id) + .bind(project_id) + .bind(applied_counts.0) + .bind(applied_counts.1) + .bind(applied_counts.2) + .bind(applied_counts.3) + .bind(now) + .execute(&mut *transaction) + .await + .map_err(internal)?; + sqlx::query( + "INSERT INTO development_audit_events \ + (id,user_id,actor_type,actor_id,action,target_type,target_id,project_id,result,redacted_payload_json,created_at) \ + VALUES (? ,?,'user',?,'retention.cleanup','project',?,?,'success',?,?)", + ) + .bind(Uuid::now_v7().to_string()) + .bind(user_id) + .bind(user_id) + .bind(project_id) + .bind(project_id) + .bind( + serde_json::json!({ + "execution_id": execution_id, + "messages": applied_counts.0, + "artifacts": applied_counts.1, + "evaluations": applied_counts.2, + "immutable_audit_events_retained": applied_counts.3, + }) + .to_string(), + ) + .bind(now) + .execute(&mut *transaction) + .await + .map_err(internal)?; + transaction.commit().await.map_err(internal)?; + Ok(report(Some(execution_id), project_id, false, applied_counts, now)) + } + + async fn require_project(&self, user_id: &str, project_id: &str) -> Result<(), DevelopmentError> { + let exists: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM projects WHERE id=? AND user_id=?") + .bind(project_id) + .bind(user_id) + .fetch_one(&self.pool) + .await + .map_err(internal)?; + if exists == 1 { + Ok(()) + } else { + Err(DevelopmentError::NotFound(format!("project {project_id}"))) + } + } +} + +fn validate_days(days: i64) -> Result<(), DevelopmentError> { + if (MIN_RETENTION_DAYS..=MAX_RETENTION_DAYS).contains(&days) { + Ok(()) + } else { + Err(DevelopmentError::BadRequest(format!( + "retention days must be between {MIN_RETENTION_DAYS} and {MAX_RETENTION_DAYS}" + ))) + } +} + +fn cutoff(now: i64, days: i64) -> i64 { + now.saturating_sub(days.saturating_mul(DAY_MS)) +} + +fn policy_from_row(row: &sqlx::sqlite::SqliteRow) -> Result { + Ok(DevelopmentRetentionPolicy { + user_id: row.try_get("user_id").map_err(internal)?, + project_id: row.try_get("project_id").map_err(internal)?, + conversation_history_days: row.try_get("conversation_history_days").map_err(internal)?, + artifact_days: row.try_get("artifact_days").map_err(internal)?, + evaluation_days: row.try_get("evaluation_days").map_err(internal)?, + immutable_audit_log: row.try_get::("immutable_audit_log").map_err(internal)? != 0, + updated_at: row.try_get("updated_at").map_err(internal)?, + }) +} + +async fn cleanup_counts( + pool: &SqlitePool, + user_id: &str, + project_id: &str, + history_cutoff: i64, + artifact_cutoff: i64, + evaluation_cutoff: i64, +) -> Result<(i64, i64, i64, i64), DevelopmentError> { + let messages = sqlx::query_scalar( + "SELECT COUNT(*) FROM messages m JOIN project_resource_links l \ + ON l.resource_type='conversation' AND l.resource_id=m.conversation_id \ + WHERE l.user_id=? AND l.project_id=? AND m.created_at, + user_id: &str, + project_id: &str, + history_cutoff: i64, + artifact_cutoff: i64, + evaluation_cutoff: i64, +) -> Result<(i64, i64, i64, i64), DevelopmentError> { + let messages = sqlx::query( + "DELETE FROM messages WHERE created_at, + project_id: &str, + dry_run: bool, + counts: (i64, i64, i64, i64), + completed_at: i64, +) -> RetentionCleanupReport { + RetentionCleanupReport { + execution_id, + project_id: project_id.into(), + dry_run, + message_count: counts.0, + artifact_count: counts.1, + evaluation_count: counts.2, + audit_events_retained: counts.3, + completed_at, + } +} + +fn internal(error: impl std::fmt::Display) -> DevelopmentError { + DevelopmentError::Internal(error.to_string()) +} diff --git a/crates/aionui-development/src/routes.rs b/crates/aionui-development/src/routes.rs new file mode 100644 index 000000000..9e3658e64 --- /dev/null +++ b/crates/aionui-development/src/routes.rs @@ -0,0 +1,1654 @@ +#![allow(clippy::disallowed_types)] // HTTP boundary maps crate-owned errors to the shared API response. + +use std::sync::Arc; + +use aionui_api_types::{ + ApiResponse, DevelopmentConfirmationRequest, DevelopmentDeploymentRequest, DevelopmentEvaluation, + DevelopmentRetentionPolicy, DevelopmentRunControlRequest, DevelopmentRunControlState, DevelopmentRunTimeline, + DevelopmentTagRequest, DevelopmentTimelineEvent, EvaluationComparison, EvaluationComparisonRequest, + EvaluationRecordInput, ImportProjectBundleRequest, PlatformInstanceSummary, ProjectExportBundle, + ProjectImportReport, RetentionCleanupReport, RetentionCleanupRequest, RetentionPolicyInput, +}; +use aionui_auth::CurrentUser; +use aionui_common::ApiError; +use aionui_db::{IApprovalRepository, IDevelopmentOperationsRepository, IDevelopmentRepository}; +use axum::Router; +use axum::extract::rejection::JsonRejection; +use axum::extract::{Extension, Json, Path, Query, State}; +use axum::http::StatusCode; +use axum::routing::{get, post}; +use serde::Deserialize; +use serde_json::{Value, json}; +use std::collections::BTreeMap; + +use crate::delivery::{CreatePullRequestInput, CreateTagInput, DeliveryService, PrepareDeliveryInput}; +use crate::deployment::{DeploymentRequestInput, DeploymentService}; +use crate::error::DevelopmentError; +use crate::export::PortabilityService; +use crate::operations::{ + DevelopmentOperationsService, DevelopmentOperationsSnapshot, DevelopmentPolicyInput, RecoveryDecisionInput, +}; +use crate::pricing::PricingService; +use crate::retention::RetentionService; +use crate::secrets::{SecretCreateInput, SecretGrantInput, SecretService}; +use crate::service::{CompletionEvaluation, DevelopmentService}; +use crate::types::{ + AppendPlanRevisionInput, AppendRequirementRevisionInput, AssignDevelopmentRoleInput, CompletionEvidenceInput, + CreateArtifactInput, CreateDevelopmentRunInput, CreateDevelopmentTaskInput, ExecuteQualityGateInput, + ResolveFindingInput, SubmitReviewInput, TransitionDevelopmentTaskInput, +}; + +impl From for ApiError { + fn from(value: DevelopmentError) -> Self { + match value { + DevelopmentError::BadRequest(message) => Self::BadRequest(message), + DevelopmentError::NotFound(message) => Self::NotFound(message), + DevelopmentError::Conflict(message) => Self::Conflict(message), + DevelopmentError::Internal(_) => Self::Internal("Development operation failed".into()), + } + } +} + +#[derive(Clone)] +pub struct DevelopmentRouterState { + pub service: Arc, + pub delivery_service: Arc, + pub deployment_service: Arc, + pub operations_service: Arc, + pub secret_service: Arc, + pub pricing_service: Arc, + pub development_repo: Arc, + pub operations_repo: Arc, + pub approval_repo: Arc, + pub portability_service: Arc, + pub retention_service: Arc, +} + +#[derive(Debug, Default, Deserialize)] +struct RunListQuery { + project_id: Option, +} + +#[derive(Debug, Default, Deserialize)] +struct EvidenceQuery { + task_id: Option, +} + +#[derive(Debug, Default, Deserialize)] +struct OperationsQuery { + run_id: Option, +} + +#[derive(Debug, Deserialize)] +struct ReconcileInput { + #[serde(default = "default_stale_after_ms")] + stale_after_ms: i64, +} + +#[derive(Debug, Deserialize)] +struct RecoverDeploymentsInput { + #[serde(default = "default_stale_after_ms")] + stale_after_ms: i64, +} + +fn default_stale_after_ms() -> i64 { + 30 * 60 * 1000 +} + +#[derive(Debug, Deserialize)] +struct ConfirmedInput { + #[serde(default)] + confirmation_count: u8, +} + +pub fn development_routes(state: DevelopmentRouterState) -> Router { + Router::new() + .route("/api/development-runs", post(create_run).get(list_runs)) + .route("/api/development-runs/{run_id}", get(get_run)) + .route("/api/development-runs/{run_id}/timeline", get(get_timeline)) + .route("/api/development-runs/{run_id}/control", post(control_run)) + .route( + "/api/development-runs/{run_id}/requirements", + get(get_requirements).post(append_requirement_revision), + ) + .route("/api/development-runs/{run_id}/plans", post(append_plan_revision)) + .route( + "/api/development-runs/{run_id}/completion-evidence/{task_id}", + post(record_completion_evidence), + ) + .route("/api/development-runs/{run_id}/completion", post(complete_run)) + .route( + "/api/development-runs/{run_id}/workspace", + get(get_single_workspace).post(prepare_single_workspace), + ) + .route( + "/api/development-runs/{run_id}/workspace/cancel", + post(cancel_single_workspace), + ) + .route( + "/api/development-runs/{run_id}/roles", + post(assign_role).get(list_roles), + ) + .route( + "/api/development-runs/{run_id}/tasks", + post(create_task).get(list_tasks), + ) + .route( + "/api/development-runs/{run_id}/tasks/{task_id}/completion", + get(evaluate_completion).post(complete_task), + ) + .route( + "/api/development-runs/{run_id}/tasks/{task_id}/transition", + post(transition_task), + ) + .route( + "/api/development-runs/{run_id}/artifacts", + post(create_artifact).get(list_artifacts), + ) + .route( + "/api/development-runs/{run_id}/quality-gates", + post(execute_gate).get(list_gates), + ) + .route( + "/api/development-runs/{run_id}/reviews", + post(submit_review).get(list_findings), + ) + .route( + "/api/development-runs/{run_id}/findings/{finding_id}", + post(resolve_finding), + ) + .route("/api/development-runs/{run_id}/delivery", get(get_delivery)) + .route( + "/api/development-runs/{run_id}/delivery/prepare", + post(prepare_delivery), + ) + .route("/api/development-runs/{run_id}/delivery/push", post(push_delivery)) + .route( + "/api/development-runs/{run_id}/delivery/pull-request", + post(create_pull_request), + ) + .route("/api/development-runs/{run_id}/delivery/sync", post(sync_delivery)) + .route("/api/development-runs/{run_id}/delivery/merge", post(merge_delivery)) + .route("/api/development-runs/{run_id}/delivery/report", get(delivery_report)) + .route( + "/api/development-runs/{run_id}/delivery/tags", + get(list_delivery_tags).post(create_delivery_tag), + ) + .route( + "/api/development-runs/{run_id}/deployments", + get(list_deployments).post(request_deployment), + ) + .route( + "/api/development-runs/{run_id}/deployments/recover", + post(recover_deployments), + ) + .route( + "/api/development-runs/{run_id}/deployments/{deployment_id}/approve", + post(approve_deployment), + ) + .route( + "/api/development-runs/{run_id}/deployments/{deployment_id}/execute", + post(execute_deployment), + ) + .route( + "/api/development-runs/{run_id}/deployments/{deployment_id}/cancel", + post(cancel_deployment), + ) + .route( + "/api/development-projects/{project_id}/operations/policy", + get(get_operations_policy).put(update_operations_policy), + ) + .route( + "/api/development-projects/{project_id}/secrets", + get(list_secrets).post(create_secret), + ) + .route( + "/api/development-projects/{project_id}/secrets/{secret_id}/grants", + post(grant_secret), + ) + .route( + "/api/development-projects/{project_id}/secrets/{secret_id}/revoke", + post(revoke_secret), + ) + .route( + "/api/development-projects/{project_id}/operations", + get(get_operations_snapshot), + ) + .route( + "/api/development-projects/{project_id}/operations/alerts/{alert_id}/ack", + post(acknowledge_operations_alert), + ) + .route( + "/api/development-projects/{project_id}/export", + get(export_project_bundle), + ) + .route( + "/api/development-projects/{project_id}/retention", + get(get_retention_policy).put(update_retention_policy), + ) + .route( + "/api/development-projects/{project_id}/retention/cleanup", + post(cleanup_retained_data), + ) + .route("/api/development-projects/import", post(import_project_bundle)) + .route("/api/development-platform/instance", get(get_platform_instance)) + .route("/api/development-evaluations", post(record_evaluation)) + .route("/api/development-evaluations/compare", post(compare_evaluations)) + .route("/api/development-operations/reconcile", post(reconcile_operations)) + .route("/api/development-runs/{run_id}/recovery", post(decide_recovery)) + .with_state(state) +} + +async fn export_project_bundle( + State(state): State, + Extension(user): Extension, + Path(project_id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .portability_service + .export_project(&user.id, &project_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn get_retention_policy( + State(state): State, + Extension(user): Extension, + Path(project_id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .retention_service + .get_policy(&user.id, &project_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn update_retention_policy( + State(state): State, + Extension(user): Extension, + Path(project_id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .retention_service + .update_policy(&user.id, &project_id, input) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn cleanup_retained_data( + State(state): State, + Extension(user): Extension, + Path(project_id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .retention_service + .cleanup(&user.id, &project_id, input) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn import_project_bundle( + State(state): State, + Extension(user): Extension, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(request) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .portability_service + .import_project(&user.id, request) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn get_platform_instance( + State(state): State, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .portability_service + .platform_instance() + .await + .map_err(ApiError::from)?, + ))) +} + +async fn record_evaluation( + State(state): State, + Extension(user): Extension, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .portability_service + .record_evaluation(&user.id, input) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn compare_evaluations( + State(state): State, + Extension(user): Extension, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(request) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .portability_service + .compare_evaluations(&user.id, request) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn get_timeline( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result>, ApiError> { + let run = state.service.get_run(&user.id, &run_id).await.map_err(ApiError::from)?; + let tasks = state + .service + .list_tasks(&user.id, &run_id) + .await + .map_err(ApiError::from)?; + let mut events = vec![DevelopmentTimelineEvent { + id: format!("run:{}", run.id), + kind: "run".into(), + correlation_id: run.id.clone(), + task_id: None, + title: run.request_summary.clone(), + status: run.status.clone(), + actor_id: run.source_user_id.clone(), + occurred_at: run.created_at, + metadata: json!({"execution_mode": run.execution_mode}), + }]; + for task in &tasks { + events.push(timeline_event( + format!("task:{}", task.id), + "task", + &run.id, + Some(task.id.clone()), + task.subject.clone(), + task.status.clone(), + task.owner.clone(), + task.updated_at, + json!({"blocked_by": task.blocked_by, "risk_level": task.risk_level}), + )); + } + for artifact in state + .development_repo + .list_artifacts(&run_id, None) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)? + { + events.push(timeline_event( + format!("artifact:{}", artifact.id), + "file", + &run.id, + artifact.task_id, + artifact.artifact_type, + "recorded".into(), + artifact.producer_agent_id, + artifact.created_at, + json!({"path_or_uri": artifact.path_or_uri, "checksum": artifact.checksum}), + )); + } + for gate in state + .development_repo + .list_gates(&run_id, None) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)? + { + events.push(timeline_event( + format!("gate:{}", gate.id), + "gate", + &run.id, + gate.task_id, + gate.gate_type, + gate.status, + None, + gate.finished_at.or(gate.started_at).unwrap_or(gate.created_at), + json!({"required": gate.required, "duration_ms": gate.duration_ms}), + )); + } + for task in &tasks { + for finding in state + .development_repo + .list_findings(&run_id, &task.id) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)? + { + events.push(timeline_event( + format!("finding:{}", finding.id), + "finding", + &run.id, + Some(finding.task_id), + finding.reason, + finding.status, + Some(finding.reviewer_agent_id), + finding.updated_at, + json!({"severity": finding.severity, "file_path": finding.file_path, "line_number": finding.line_number}), + )); + } + } + for approval in state + .approval_repo + .list_for_user(&user.id, Some(&run_id)) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)? + { + events.push(timeline_event( + format!("approval:{}", approval.id), + "approval", + &run.id, + approval.task_id, + approval.action_type, + approval.status, + approval.approver_user_id.or(Some(approval.requester_user_id)), + approval.updated_at, + json!({"risk_level": approval.risk_level, "expires_at": approval.expires_at}), + )); + } + if let Some(delivery) = state + .development_repo + .get_delivery(&user.id, &run_id) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)? + { + events.push(timeline_event( + format!("commit:{}", delivery.id), + "commit", + &run.id, + None, + delivery.commit_sha.clone().unwrap_or_else(|| delivery.branch.clone()), + delivery.status.clone(), + None, + delivery.updated_at, + json!({"branch": delivery.branch, "base_branch": delivery.base_branch}), + )); + for check in state + .development_repo + .list_ci_checks(&delivery.id) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)? + { + events.push(timeline_event( + format!("ci:{}", check.id), + "ci", + &run.id, + None, + check.name, + check.status, + None, + check.completed_at.or(check.started_at).unwrap_or(check.created_at), + json!({"details_url": check.details_url, "rework_task_id": check.rework_task_id}), + )); + } + for tag in state + .development_repo + .list_delivery_tags(&user.id, &delivery.id) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)? + { + events.push(timeline_event( + format!("tag:{}", tag.id), + "commit", + &run.id, + None, + tag.name, + tag.status, + None, + tag.updated_at, + json!({"commit_sha": tag.commit_sha, "remote_url": tag.remote_url}), + )); + } + } + for deployment in state + .development_repo + .list_deployments(&user.id, &run_id) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)? + { + events.push(timeline_event( + format!("deployment:{}", deployment.id), + "deployment", + &run.id, + None, + deployment.environment, + deployment.status, + deployment.approved_by.or(Some(deployment.requested_by)), + deployment.updated_at, + json!({"commit_sha": deployment.commit_sha, "remote_id": deployment.remote_id}), + )); + } + for usage in state + .operations_repo + .list_usage(&user.id, &run.project_id, Some(&run_id), 200) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)? + { + events.push(timeline_event( + format!("usage:{}", usage.id), + "usage", + &run.id, + usage.task_id, + usage.usage_type, + usage.confidence, + Some(usage.source), + usage.created_at, + json!({"input_tokens": usage.input_tokens, "output_tokens": usage.output_tokens, "cost_microunits": usage.cost_microunits, "duration_ms": usage.duration_ms}), + )); + } + for audit in state + .operations_repo + .list_audit(&user.id, &run.project_id, Some(&run_id), 200) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)? + { + let kind = if audit.action.contains("turn") { + "turn" + } else if audit.action.contains("tool") || audit.action.contains("execute") { + "tool" + } else { + "audit" + }; + events.push(timeline_event( + format!("audit:{}", audit.id), + kind, + &run.id, + audit.task_id, + audit.action, + audit.result, + Some(audit.actor_id), + audit.created_at, + serde_json::from_str(&audit.redacted_payload_json).unwrap_or(Value::Null), + )); + } + for alert in state + .operations_repo + .list_alerts(&user.id, &run.project_id, Some(&run_id), false) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)? + { + events.push(timeline_event( + format!("alert:{}", alert.id), + "alert", + &run.id, + None, + alert.message, + alert.status, + None, + alert.updated_at, + json!({"alert_type": alert.alert_type, "severity": alert.severity}), + )); + } + for recovery in state + .operations_repo + .list_recovery(&user.id, &run.project_id, Some(&run_id), 200) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)? + { + events.push(timeline_event( + format!("recovery:{}", recovery.id), + "recovery", + &run.id, + None, + recovery.finding, + recovery.decision, + None, + recovery.created_at, + serde_json::from_str(&recovery.details_json).unwrap_or(Value::Null), + )); + } + events.sort_by(|left, right| { + left.occurred_at + .cmp(&right.occurred_at) + .then_with(|| left.id.cmp(&right.id)) + }); + Ok(Json(ApiResponse::ok(DevelopmentRunTimeline { + run_id: run.id.clone(), + controls: control_state(&run, &tasks), + events, + }))) +} + +async fn control_run( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + Json(input): Json, +) -> Result>, ApiError> { + let run = state.service.get_run(&user.id, &run_id).await.map_err(ApiError::from)?; + let tasks = state + .service + .list_tasks(&user.id, &run_id) + .await + .map_err(ApiError::from)?; + let controls = control_state(&run, &tasks); + if let Some(task_id) = input.task_id.as_deref() { + let allowed = controls.allowed_task_actions.get(task_id).cloned().unwrap_or_default(); + if !allowed.iter().any(|action| action == &input.action) { + return Err(ApiError::Conflict(format!( + "task action {} is not allowed", + input.action + ))); + } + let task = tasks + .iter() + .find(|task| task.id == task_id) + .ok_or_else(|| ApiError::NotFound(format!("task {task_id}")))?; + if input.action == "reassign" { + let target = input + .target_slot_id + .as_deref() + .filter(|value| !value.trim().is_empty()) + .ok_or_else(|| ApiError::BadRequest("target_slot_id is required".into()))?; + let roles = state + .service + .list_roles(&user.id, &run_id) + .await + .map_err(ApiError::from)?; + if !roles.iter().any(|role| role.slot_id == target) { + return Err(ApiError::BadRequest( + "target_slot_id is not assigned to this run".into(), + )); + } + state + .development_repo + .update_task_owner(&run_id, task_id, Some(target)) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)?; + } else { + let target = task_control_target(&input.action, &task.status) + .ok_or_else(|| ApiError::Conflict("task action has no valid target state".into()))?; + state + .development_repo + .update_task_state(&run_id, task_id, target, &task.review_status, &task.verification_status) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)?; + } + } else { + if !controls + .allowed_run_actions + .iter() + .any(|action| action == &input.action) + { + return Err(ApiError::Conflict(format!( + "run action {} is not allowed", + input.action + ))); + } + let (status, finished_at) = match input.action.as_str() { + "pause" => ("paused", None), + "cancel" => ("cancelled", Some(aionui_common::now_ms())), + "retry" | "takeover" => ("running", None), + _ => return Err(ApiError::BadRequest("unsupported run action".into())), + }; + let pending_recovery = state + .operations_repo + .list_recovery(&user.id, &run.project_id, Some(&run_id), 200) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)? + .into_iter() + .any(|record| { + record.status_after.is_none() + && serde_json::from_str::(&record.details_json) + .ok() + .and_then(|value| value.get("state").and_then(Value::as_str).map(str::to_owned)) + .as_deref() + == Some("pending") + }); + if pending_recovery { + return Err(ApiError::Conflict( + "run recovery is pending; use the recovery decision endpoint".into(), + )); + } + let updated = state + .development_repo + .update_run_status_if_current(&run_id, &user.id, &run.status, run.updated_at, status, finished_at) + .await + .map_err(DevelopmentError::from) + .map_err(ApiError::from)?; + if !updated { + return Err(ApiError::Conflict( + "run state changed while applying control action".into(), + )); + } + } + let updated_run = state.service.get_run(&user.id, &run_id).await.map_err(ApiError::from)?; + let updated_tasks = state + .service + .list_tasks(&user.id, &run_id) + .await + .map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok(control_state(&updated_run, &updated_tasks)))) +} + +#[allow( + clippy::too_many_arguments, + reason = "the helper mirrors the persisted timeline event schema so call sites keep every source field explicit" +)] +fn timeline_event( + id: String, + kind: &str, + correlation_id: &str, + task_id: Option, + title: String, + status: String, + actor_id: Option, + occurred_at: i64, + metadata: Value, +) -> DevelopmentTimelineEvent { + DevelopmentTimelineEvent { + id, + kind: kind.into(), + correlation_id: correlation_id.into(), + task_id, + title, + status, + actor_id, + occurred_at, + metadata, + } +} + +fn control_state( + run: &aionui_db::models::DevelopmentRunRow, + tasks: &[aionui_db::models::DevelopmentTaskRow], +) -> DevelopmentRunControlState { + let allowed_run_actions = match run.status.as_str() { + "running" => vec!["pause", "cancel"], + "paused" => vec!["retry", "takeover", "cancel"], + "failed" => vec!["retry", "takeover"], + _ => vec![], + } + .into_iter() + .map(str::to_owned) + .collect(); + let allowed_task_actions = tasks + .iter() + .map(|task| { + let actions: Vec<&str> = match task.status.as_str() { + "pending" | "ready" | "claimed" => vec!["advance", "reassign", "cancel"], + "in_progress" => vec!["pause", "reassign", "cancel"], + "waiting_approval" => vec!["retry", "reassign", "cancel"], + "verifying" | "review" => vec!["rework", "reassign", "cancel"], + "rework" | "failed" | "conflict" => vec!["retry", "rework", "reassign", "cancel"], + _ => vec![], + }; + (task.id.clone(), actions.into_iter().map(str::to_owned).collect()) + }) + .collect::>(); + DevelopmentRunControlState { + run_id: run.id.clone(), + run_status: run.status.clone(), + allowed_run_actions, + allowed_task_actions, + } +} + +fn task_control_target<'a>(action: &str, current: &'a str) -> Option<&'a str> { + match action { + "advance" => match current { + "pending" => Some("ready"), + "ready" => Some("claimed"), + "claimed" => Some("in_progress"), + _ => None, + }, + "pause" => Some("waiting_approval"), + "retry" => Some("in_progress"), + "rework" => Some("rework"), + "cancel" => Some("cancelled"), + _ => None, + } +} + +async fn list_secrets( + State(state): State, + Extension(user): Extension, + Path(project_id): Path, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .secret_service + .list(&user.id, &project_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn create_secret( + State(state): State, + Extension(user): Extension, + Path(project_id): Path, + body: Result, JsonRejection>, +) -> Result<(StatusCode, Json>), ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + let secret = state + .secret_service + .create( + &user.id, + &project_id, + SecretCreateInput { + name: input.name, + value: input.value, + expires_at: input.expires_at, + }, + ) + .await + .map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(secret)))) +} + +async fn grant_secret( + State(state): State, + Extension(user): Extension, + Path((project_id, secret_id)): Path<(String, String)>, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + if input.secret_id != secret_id { + return Err(ApiError::BadRequest("Secret ID does not match route".into())); + } + let secrets = state + .secret_service + .list(&user.id, &project_id) + .await + .map_err(ApiError::from)?; + if !secrets.iter().any(|secret| secret.id == secret_id) { + return Err(ApiError::NotFound("Secret".into())); + } + Ok(Json(ApiResponse::ok( + state + .secret_service + .grant( + &user.id, + SecretGrantInput { + secret_id, + scope_type: input.scope_type, + scope_id: input.scope_id, + environment_key: input.environment_key, + expires_at: input.expires_at, + }, + ) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn revoke_secret( + State(state): State, + Extension(user): Extension, + Path((project_id, secret_id)): Path<(String, String)>, +) -> Result>, ApiError> { + let secrets = state + .secret_service + .list(&user.id, &project_id) + .await + .map_err(ApiError::from)?; + if !secrets.iter().any(|secret| secret.id == secret_id) { + return Err(ApiError::NotFound("Secret".into())); + } + state + .secret_service + .revoke(&user.id, &secret_id) + .await + .map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok(serde_json::json!({"revoked": true})))) +} + +async fn get_operations_policy( + State(state): State, + Extension(user): Extension, + Path(project_id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .operations_service + .get_policy(&user.id, &project_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn update_operations_policy( + State(state): State, + Extension(user): Extension, + Path(project_id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .operations_service + .upsert_policy(&user.id, &project_id, input) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn get_operations_snapshot( + State(state): State, + Extension(user): Extension, + Path(project_id): Path, + Query(query): Query, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .operations_service + .snapshot(&user.id, &project_id, query.run_id.as_deref()) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn acknowledge_operations_alert( + State(state): State, + Extension(user): Extension, + Path((project_id, alert_id)): Path<(String, String)>, +) -> Result>, ApiError> { + state + .operations_service + .get_policy(&user.id, &project_id) + .await + .map_err(ApiError::from)?; + state + .operations_service + .acknowledge_alert(&user.id, &project_id, &alert_id) + .await + .map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok(serde_json::json!({"acknowledged": true})))) +} + +async fn reconcile_operations( + State(state): State, + Extension(user): Extension, + body: Result, JsonRejection>, +) -> Result>>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .operations_service + .reconcile_stale_runs_for_user(&user.id, input.stale_after_ms) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn decide_recovery( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .operations_service + .decide_recovery(&user.id, &run_id, input) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn get_delivery( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .delivery_service + .get(&user.id, &run_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn prepare_delivery( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .delivery_service + .prepare(&user.id, &run_id, input) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn push_delivery( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .delivery_service + .push(&user.id, &run_id, input.confirmation_count) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn create_pull_request( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .delivery_service + .create_pull_request(&user.id, &run_id, input) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn sync_delivery( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .delivery_service + .sync(&user.id, &run_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn merge_delivery( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .delivery_service + .merge(&user.id, &run_id, input.confirmation_count) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn delivery_report( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .delivery_service + .report(&user.id, &run_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn create_delivery_tag( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result< + ( + StatusCode, + Json>, + ), + ApiError, +> { + let Json(input) = body.map_err(ApiError::from)?; + let row = state + .delivery_service + .create_tag( + &user.id, + &run_id, + CreateTagInput { + name: input.name, + commit_sha: input.commit_sha, + confirmed: input.confirmed, + confirmation_count: input.confirmation_count, + }, + ) + .await + .map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(row)))) +} + +async fn list_delivery_tags( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .delivery_service + .list_tags(&user.id, &run_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn request_deployment( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result< + ( + StatusCode, + Json>, + ), + ApiError, +> { + let Json(input) = body.map_err(ApiError::from)?; + let row = state + .deployment_service + .request( + &user.id, + &run_id, + DeploymentRequestInput { + environment: input.environment, + deployment_key: input.deployment_key, + commit_sha: input.commit_sha, + }, + ) + .await + .map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(row)))) +} + +async fn list_deployments( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .deployment_service + .list(&user.id, &run_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn approve_deployment( + State(state): State, + Extension(user): Extension, + Path((run_id, deployment_id)): Path<(String, String)>, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .deployment_service + .approve(&user.id, &run_id, &deployment_id, input.confirmation_count) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn execute_deployment( + State(state): State, + Extension(user): Extension, + Path((run_id, deployment_id)): Path<(String, String)>, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .deployment_service + .execute(&user.id, &run_id, &deployment_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn cancel_deployment( + State(state): State, + Extension(user): Extension, + Path((run_id, deployment_id)): Path<(String, String)>, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .deployment_service + .cancel(&user.id, &run_id, &deployment_id, input.confirmed) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn recover_deployments( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result>>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .deployment_service + .recover_stale(&user.id, &run_id, input.stale_after_ms) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn assign_role( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result<(StatusCode, Json>), ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + let row = state + .service + .assign_role(&user.id, &run_id, &input.slot_id, &input.role) + .await + .map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(row)))) +} + +async fn list_roles( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .list_roles(&user.id, &run_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn create_run( + State(state): State, + Extension(user): Extension, + body: Result, JsonRejection>, +) -> Result<(StatusCode, Json>), ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + let row = state + .service + .create_run(&user.id, input) + .await + .map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(row)))) +} + +async fn list_runs( + State(state): State, + Extension(user): Extension, + Query(query): Query, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .list_runs(&user.id, query.project_id.as_deref()) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn get_run( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state.service.get_run(&user.id, &run_id).await.map_err(ApiError::from)?, + ))) +} + +async fn get_requirements( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .requirements_snapshot(&user.id, &run_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn append_requirement_revision( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result<(StatusCode, Json>), ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + let row = state + .service + .append_requirement_revision( + &user.id, + &run_id, + &input.content, + &input.change_summary, + input.acceptance_criteria, + ) + .await + .map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(row)))) +} + +async fn append_plan_revision( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result<(StatusCode, Json>), ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + let row = state + .service + .append_plan_revision(&user.id, &run_id, input) + .await + .map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(row)))) +} + +async fn record_completion_evidence( + State(state): State, + Extension(user): Extension, + Path((run_id, task_id)): Path<(String, String)>, + body: Result, JsonRejection>, +) -> Result<(StatusCode, Json>), ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + let row = state + .service + .record_completion_evidence(&user.id, &run_id, &task_id, input) + .await + .map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(row)))) +} + +async fn complete_run( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .complete_run(&user.id, &run_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn get_single_workspace( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .get_single_workspace(&user.id, &run_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn prepare_single_workspace( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result<(StatusCode, Json>), ApiError> { + let row = state + .service + .prepare_single_workspace(&user.id, &run_id) + .await + .map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(row)))) +} + +async fn cancel_single_workspace( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .cancel_single_workspace(&user.id, &run_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn create_task( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result<(StatusCode, Json>), ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + let row = state + .service + .create_task(&user.id, &run_id, input) + .await + .map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(row)))) +} + +async fn list_tasks( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .list_tasks(&user.id, &run_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn evaluate_completion( + State(state): State, + Extension(user): Extension, + Path((run_id, task_id)): Path<(String, String)>, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .evaluate_completion(&user.id, &run_id, &task_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn complete_task( + State(state): State, + Extension(user): Extension, + Path((run_id, task_id)): Path<(String, String)>, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .complete_task(&user.id, &run_id, &task_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn transition_task( + State(state): State, + Extension(user): Extension, + Path((run_id, task_id)): Path<(String, String)>, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .service + .transition_task(&user.id, &run_id, &task_id, &input.status) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn create_artifact( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result<(StatusCode, Json>), ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + let row = state + .service + .create_artifact(&user.id, &run_id, input) + .await + .map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(row)))) +} + +async fn list_artifacts( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + Query(query): Query, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .list_artifacts(&user.id, &run_id, query.task_id.as_deref()) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn execute_gate( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result<(StatusCode, Json>), ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + let row = state + .service + .execute_gate( + &user.id, + &run_id, + input.task_id.as_deref(), + &input.gate_type, + input.workspace_lease_id.as_deref(), + input.required, + ) + .await + .map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(row)))) +} + +async fn list_gates( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + Query(query): Query, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .list_gates(&user.id, &run_id, query.task_id.as_deref()) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn submit_review( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .service + .submit_review(&user.id, &run_id, input) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn list_findings( + State(state): State, + Extension(user): Extension, + Path(run_id): Path, + Query(query): Query, +) -> Result>>, ApiError> { + let task_id = query + .task_id + .ok_or_else(|| ApiError::BadRequest("task_id is required".into()))?; + Ok(Json(ApiResponse::ok( + state + .service + .list_findings(&user.id, &run_id, &task_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn resolve_finding( + State(state): State, + Extension(user): Extension, + Path((run_id, finding_id)): Path<(String, String)>, + body: Result, JsonRejection>, +) -> Result { + let Json(input) = body.map_err(ApiError::from)?; + state + .service + .resolve_finding(&user.id, &run_id, &finding_id, &input.status) + .await + .map_err(ApiError::from)?; + Ok(StatusCode::NO_CONTENT) +} diff --git a/crates/aionui-development/src/runner.rs b/crates/aionui-development/src/runner.rs new file mode 100644 index 000000000..92be0f924 --- /dev/null +++ b/crates/aionui-development/src/runner.rs @@ -0,0 +1,162 @@ +use std::sync::Arc; + +use aionui_common::now_ms; +use aionui_db::IDevelopmentOperationsRepository; + +use crate::DevelopmentError; +use crate::executor::{ + CommandExecutionInput, CommandExecutionOutput, ManagedExecutionContext, build_execution_plan, execute_plan, +}; +use crate::resources::{DevelopmentResourceController, ResourceLeaseCoordinator, ResourceLeaseInput}; +use crate::secrets::{SecretAccessContext, SecretReferenceRequest, SecretService}; +use zeroize::Zeroize; + +#[derive(Debug, Clone)] +pub struct RunnerContext { + pub user_id: String, + pub project_id: String, + pub run_id: String, + pub task_id: Option, + pub turn_id: Option, + pub gate_id: Option, +} + +#[derive(Clone)] +pub struct DevelopmentRunner { + repo: Arc, + resources: ResourceLeaseCoordinator, + controller: Arc, + secrets: Option, +} + +impl DevelopmentRunner { + pub fn new( + repo: Arc, + resources: ResourceLeaseCoordinator, + controller: Arc, + ) -> Self { + Self { + repo, + resources, + controller, + secrets: None, + } + } + + pub fn with_secrets(mut self, secrets: SecretService) -> Self { + self.secrets = Some(secrets); + self + } + + pub fn resources(&self) -> &ResourceLeaseCoordinator { + &self.resources + } + + pub async fn cleanup_run(&self, user_id: &str, run_id: &str) -> Result<(), DevelopmentError> { + self.resources + .cancel_run(user_id, run_id, self.controller.as_ref()) + .await?; + Ok(()) + } + + pub async fn execute( + &self, + mut input: CommandExecutionInput<'_>, + context: &RunnerContext, + ) -> Result { + let timeout_seconds = input.timeout_seconds; + let plan = build_execution_plan(&input)?; + input.environment.values_mut().for_each(Zeroize::zeroize); + self.bind_environment(context, &plan.environment_id, &plan.isolation_mode) + .await?; + let mut planned_leases = Vec::new(); + for resource in &plan.resources { + planned_leases.push( + self.resources + .create(ResourceLeaseInput { + user_id: context.user_id.clone(), + project_id: context.project_id.clone(), + run_id: context.run_id.clone(), + task_id: context.task_id.clone(), + turn_id: context.turn_id.clone(), + gate_id: context.gate_id.clone(), + environment_id: plan.environment_id.clone(), + environment_kind: plan.isolation_mode.clone(), + resource_kind: resource.resource_kind.clone(), + resource_identifier: resource.resource_identifier.clone(), + cleanup_order: resource.cleanup_order, + ttl_ms: timeout_seconds.max(1).saturating_mul(1000), + }) + .await?, + ); + } + let managed = ManagedExecutionContext { + user_id: &context.user_id, + project_id: &context.project_id, + run_id: &context.run_id, + task_id: context.task_id.as_deref(), + turn_id: context.turn_id.as_deref(), + gate_id: context.gate_id.as_deref(), + resources: &self.resources, + }; + let result = execute_plan(&plan, timeout_seconds, Some(&managed)).await; + let cleanup_result = match &result { + Ok(output) => output.status.as_str(), + Err(_) => "runner_error", + }; + for lease in planned_leases { + if lease.resource_kind != "service" { + self.resources.complete(&lease, cleanup_result).await?; + } + } + result + } + + pub async fn execute_with_secret_references( + &self, + mut input: CommandExecutionInput<'_>, + context: &RunnerContext, + access: &SecretAccessContext, + requests: &[SecretReferenceRequest], + ) -> Result { + let service = self + .secrets + .as_ref() + .ok_or_else(|| DevelopmentError::Conflict("Secret materialization is unavailable".into()))?; + let materialized = service.materialize(&context.user_id, access, requests).await?; + for (key, value) in materialized.values() { + if input.environment.insert(key.clone(), value.clone()).is_some() { + input.environment.values_mut().for_each(Zeroize::zeroize); + return Err(DevelopmentError::BadRequest( + "Secret environment key conflicts with an existing value".into(), + )); + } + } + self.execute(input, context).await + } + + async fn bind_environment( + &self, + context: &RunnerContext, + environment_id: &str, + environment_kind: &str, + ) -> Result<(), DevelopmentError> { + let mut entities = vec![("run", context.run_id.as_str())]; + if let Some(task_id) = context.task_id.as_deref() { + entities.push(("task", task_id)); + } + if let Some(turn_id) = context.turn_id.as_deref() { + entities.push(("turn", turn_id)); + } + if let Some(gate_id) = context.gate_id.as_deref() { + entities.push(("gate", gate_id)); + } + let now = now_ms(); + for (entity_type, entity_id) in entities { + self.repo + .bind_execution_environment(entity_type, entity_id, environment_id, environment_kind, now) + .await?; + } + Ok(()) + } +} diff --git a/crates/aionui-development/src/secrets.rs b/crates/aionui-development/src/secrets.rs new file mode 100644 index 000000000..8949f86d7 --- /dev/null +++ b/crates/aionui-development/src/secrets.rs @@ -0,0 +1,473 @@ +use std::collections::BTreeMap; +use std::fmt; +use std::sync::Arc; + +use aionui_common::{decrypt_string, encrypt_string, now_ms}; +use aionui_db::models::{DevelopmentAuditEventRow, DevelopmentSecretGrantRow, DevelopmentSecretRow}; +use aionui_db::{IDevelopmentOperationsRepository, IProjectRepository}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; +use zeroize::Zeroize; + +use crate::DevelopmentError; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct SecretCreateInput { + pub name: String, + pub value: String, + pub expires_at: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct SecretMetadata { + pub id: String, + pub project_id: String, + pub name: String, + pub status: String, + pub expires_at: Option, + pub created_at: i64, + pub updated_at: i64, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct SecretGrantInput { + pub secret_id: String, + pub scope_type: String, + pub scope_id: String, + pub environment_key: String, + pub expires_at: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct SecretGrantMetadata { + pub id: String, + pub secret_id: String, + pub scope_type: String, + pub scope_id: String, + pub environment_key: String, + pub status: String, + pub expires_at: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct SecretAccessContext { + pub project_id: String, + pub run_id: Option, + pub agent_id: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct SecretReferenceRequest { + pub secret_id: String, + pub environment_key: String, +} + +pub struct MaterializedSecretEnvironment { + values: BTreeMap, +} + +impl MaterializedSecretEnvironment { + pub fn get(&self, key: &str) -> Option<&str> { + self.values.get(key).map(String::as_str) + } + + pub(crate) fn values(&self) -> &BTreeMap { + &self.values + } +} + +impl fmt::Debug for MaterializedSecretEnvironment { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter + .debug_struct("MaterializedSecretEnvironment") + .field("keys", &self.values.keys().collect::>()) + .finish() + } +} + +impl Drop for MaterializedSecretEnvironment { + fn drop(&mut self) { + for value in self.values.values_mut() { + value.zeroize(); + } + self.values.clear(); + } +} + +#[derive(Clone)] +pub struct SecretService { + operations: Arc, + projects: Arc, + encryption_key: Arc<[u8; 32]>, +} + +impl SecretService { + pub fn new( + operations: Arc, + projects: Arc, + encryption_key: Arc<[u8; 32]>, + ) -> Self { + Self { + operations, + projects, + encryption_key, + } + } + + pub async fn create( + &self, + user_id: &str, + project_id: &str, + mut input: SecretCreateInput, + ) -> Result { + self.require_project(user_id, project_id).await?; + input.name = input.name.trim().to_owned(); + if input.name.is_empty() || input.name.len() > 120 || input.value.is_empty() { + input.value.zeroize(); + return Err(DevelopmentError::BadRequest( + "Secret name and value are required".into(), + )); + } + let encrypted_value = encrypt_string(&input.value, self.encryption_key.as_ref()) + .map_err(|_| DevelopmentError::Internal("Secret encryption failed".into()))?; + input.value.zeroize(); + let now = now_ms(); + let row = DevelopmentSecretRow { + id: uuid::Uuid::now_v7().to_string(), + user_id: user_id.into(), + project_id: project_id.into(), + name: input.name, + encrypted_value, + key_version: "application-v1".into(), + status: "active".into(), + expires_at: input.expires_at, + revoked_at: None, + created_at: now, + updated_at: now, + }; + self.operations.insert_secret(&row).await?; + self.append_audit( + user_id, + "secret.create", + "secret", + &row.id, + &row.project_id, + json!({"name": &row.name, "expires_at": row.expires_at, "key_version": &row.key_version}), + ) + .await?; + Ok(metadata(&row)) + } + + pub async fn list(&self, user_id: &str, project_id: &str) -> Result, DevelopmentError> { + self.require_project(user_id, project_id).await?; + Ok(self + .operations + .list_secrets(user_id, project_id) + .await? + .iter() + .map(metadata) + .collect()) + } + + pub async fn grant(&self, user_id: &str, input: SecretGrantInput) -> Result { + let secret = self.require_secret(user_id, &input.secret_id).await?; + if !matches!(input.scope_type.as_str(), "project" | "run" | "agent") + || input.scope_id.trim().is_empty() + || !valid_environment_key(&input.environment_key) + { + return Err(DevelopmentError::BadRequest("invalid Secret grant".into())); + } + if input.scope_type == "project" && input.scope_id != secret.project_id { + return Err(DevelopmentError::BadRequest( + "project Secret grant must target its owning project".into(), + )); + } + let now = now_ms(); + let row = DevelopmentSecretGrantRow { + id: uuid::Uuid::now_v7().to_string(), + user_id: user_id.into(), + project_id: secret.project_id, + secret_id: secret.id, + scope_type: input.scope_type, + scope_id: input.scope_id, + environment_key: input.environment_key, + status: "active".into(), + expires_at: input.expires_at, + revoked_at: None, + created_at: now, + updated_at: now, + }; + self.operations.upsert_secret_grant(&row).await?; + self.append_audit( + user_id, + "secret.grant", + "secret_grant", + &row.id, + &row.project_id, + json!({ + "secret_id": &row.secret_id, + "scope_type": &row.scope_type, + "scope_id": &row.scope_id, + "environment_key": &row.environment_key, + "expires_at": row.expires_at, + }), + ) + .await?; + Ok(grant_metadata(&row)) + } + + pub async fn revoke(&self, user_id: &str, secret_id: &str) -> Result<(), DevelopmentError> { + let secret = self.require_secret(user_id, secret_id).await?; + if !self.operations.revoke_secret(user_id, secret_id, now_ms()).await? { + return Err(DevelopmentError::NotFound("Secret".into())); + } + self.append_audit( + user_id, + "secret.revoke", + "secret", + secret_id, + &secret.project_id, + json!({"secret_id": secret_id}), + ) + .await?; + Ok(()) + } + + pub async fn materialize( + &self, + user_id: &str, + context: &SecretAccessContext, + requests: &[SecretReferenceRequest], + ) -> Result { + self.require_project(user_id, &context.project_id).await?; + let now = now_ms(); + let mut values = BTreeMap::new(); + for request in requests { + if !valid_environment_key(&request.environment_key) || values.contains_key(&request.environment_key) { + return Err(DevelopmentError::BadRequest( + "invalid or duplicate Secret environment key".into(), + )); + } + let secret = self.require_secret(user_id, &request.secret_id).await?; + if secret.project_id != context.project_id + || secret.status != "active" + || secret.expires_at.is_some_and(|expires| expires <= now) + { + return Err(DevelopmentError::NotFound("active Secret grant".into())); + } + let grants = self.operations.list_secret_grants(user_id, &secret.id).await?; + let authorized = grants.iter().any(|grant| { + grant.status == "active" + && grant.environment_key == request.environment_key + && grant.expires_at.is_none_or(|expires| expires > now) + && match grant.scope_type.as_str() { + "project" => grant.scope_id == context.project_id, + "run" => context.run_id.as_deref() == Some(grant.scope_id.as_str()), + "agent" => context.agent_id.as_deref() == Some(grant.scope_id.as_str()), + _ => false, + } + }); + if !authorized { + return Err(DevelopmentError::NotFound("active Secret grant".into())); + } + let plaintext = decrypt_string(&secret.encrypted_value, self.encryption_key.as_ref()) + .map_err(|_| DevelopmentError::Internal("Secret decryption failed".into()))?; + values.insert(request.environment_key.clone(), plaintext); + } + self.append_audit( + user_id, + "secret.materialize", + "secret_access", + context + .run_id + .as_deref() + .or(context.agent_id.as_deref()) + .unwrap_or(&context.project_id), + &context.project_id, + json!({ + "run_id": context.run_id.as_deref(), + "agent_id": context.agent_id.as_deref(), + "secret_ids": requests.iter().map(|request| &request.secret_id).collect::>(), + "environment_keys": requests.iter().map(|request| &request.environment_key).collect::>(), + }), + ) + .await?; + Ok(MaterializedSecretEnvironment { values }) + } + + async fn require_project(&self, user_id: &str, project_id: &str) -> Result<(), DevelopmentError> { + if self.projects.get_for_user(project_id, user_id).await?.is_none() { + return Err(DevelopmentError::NotFound("Project".into())); + } + Ok(()) + } + + async fn require_secret(&self, user_id: &str, secret_id: &str) -> Result { + self.operations + .get_secret(user_id, secret_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound("Secret".into())) + } + + async fn append_audit( + &self, + user_id: &str, + action: &str, + target_type: &str, + target_id: &str, + project_id: &str, + payload: Value, + ) -> Result<(), DevelopmentError> { + let payload = serde_json::to_string(&payload).map_err(|error| DevelopmentError::Internal(error.to_string()))?; + self.operations + .append_audit(&DevelopmentAuditEventRow { + id: uuid::Uuid::now_v7().to_string(), + user_id: user_id.into(), + actor_type: "user".into(), + actor_id: user_id.into(), + action: action.into(), + target_type: target_type.into(), + target_id: target_id.into(), + project_id: project_id.into(), + run_id: None, + task_id: None, + result: "success".into(), + redacted_payload_json: redact_text(&payload, &[]), + created_at: now_ms(), + }) + .await?; + Ok(()) + } +} + +fn metadata(row: &DevelopmentSecretRow) -> SecretMetadata { + SecretMetadata { + id: row.id.clone(), + project_id: row.project_id.clone(), + name: row.name.clone(), + status: row.status.clone(), + expires_at: row.expires_at, + created_at: row.created_at, + updated_at: row.updated_at, + } +} + +fn grant_metadata(row: &DevelopmentSecretGrantRow) -> SecretGrantMetadata { + SecretGrantMetadata { + id: row.id.clone(), + secret_id: row.secret_id.clone(), + scope_type: row.scope_type.clone(), + scope_id: row.scope_id.clone(), + environment_key: row.environment_key.clone(), + status: row.status.clone(), + expires_at: row.expires_at, + } +} + +fn valid_environment_key(value: &str) -> bool { + let mut characters = value.chars(); + characters + .next() + .is_some_and(|character| character == '_' || character.is_ascii_uppercase()) + && characters.all(|character| character == '_' || character.is_ascii_uppercase() || character.is_ascii_digit()) +} + +#[derive(Clone)] +pub struct SecretRedactor { + values: Vec, +} + +impl SecretRedactor { + pub fn new(values: impl IntoIterator) -> Self { + let mut values = values.into_iter().filter(|value| !value.is_empty()).collect::>(); + values.sort_by_key(|value| std::cmp::Reverse(value.len())); + values.dedup(); + Self { values } + } + + pub fn redact_text(&self, value: &str) -> String { + redact_text(value, &self.values) + } +} + +pub fn redact_text(value: &str, secret_values: &[String]) -> String { + let mut redacted = value.to_owned(); + let mut secrets = secret_values + .iter() + .filter(|secret| !secret.is_empty()) + .collect::>(); + secrets.sort_by_key(|secret| std::cmp::Reverse(secret.len())); + for secret in secrets { + redacted = redacted.replace(secret, "[REDACTED]"); + } + let mut authorization_parts = 0_u8; + redacted + .split_whitespace() + .map(|token| { + let lower = token.to_ascii_lowercase(); + let is_authorization_header = + lower.trim_matches(|character: char| !character.is_ascii_alphanumeric()) == "authorization"; + if is_authorization_header { + authorization_parts = 2; + return token.to_owned(); + } + if authorization_parts > 0 { + authorization_parts -= 1; + return preserve_punctuation(token, "[REDACTED]"); + } + if lower.contains("ghp_") || lower.contains("github_pat_") { + return preserve_punctuation(token, "[REDACTED]"); + } + if let Some((key, _)) = token.split_once('=') + && [ + "token", + "secret", + "password", + "passwd", + "api_key", + "apikey", + "authorization", + ] + .iter() + .any(|marker| key.to_ascii_lowercase().contains(marker)) + { + return format!("{key}=[REDACTED]"); + } + redact_url_userinfo(token) + }) + .collect::>() + .join(" ") +} + +fn preserve_punctuation(original: &str, replacement: &str) -> String { + let suffix = original + .chars() + .rev() + .take_while(|character| matches!(character, ',' | ';' | ')' | ']' | '}' | '"')) + .collect::() + .chars() + .rev() + .collect::(); + format!("{replacement}{suffix}") +} + +fn redact_url_userinfo(token: &str) -> String { + let Some(scheme) = token.find("://") else { + return token.into(); + }; + let authority_start = scheme + 3; + let authority_end = token[authority_start..] + .find(['/', '?', '#']) + .map(|offset| authority_start + offset) + .unwrap_or(token.len()); + let authority = &token[authority_start..authority_end]; + let Some(at) = authority.rfind('@') else { + return token.into(); + }; + format!( + "{}[REDACTED]@{}{}", + &token[..authority_start], + &authority[at + 1..], + &token[authority_end..] + ) +} diff --git a/crates/aionui-development/src/service.rs b/crates/aionui-development/src/service.rs new file mode 100644 index 000000000..f9f8b722c --- /dev/null +++ b/crates/aionui-development/src/service.rs @@ -0,0 +1,1549 @@ +use std::collections::BTreeMap; +use std::collections::HashMap; +use std::path::{Path, PathBuf}; +use std::sync::Arc; +use std::time::Instant; + +use aionui_common::now_ms; +use aionui_db::models::{ + AcceptanceCriterionRow, CompletionEvidenceRow, DevelopmentRunRoleRow, DevelopmentRunRow, DevelopmentTaskRow, + DevelopmentUsageEventRow, PlanRevisionRow, ProjectCommandProfileRow, QualityGateRunRow, RequirementVersionRow, + ReviewFindingRow, SingleRunWorkspaceRow, TaskArtifactRow, TaskCriterionRow, +}; +use aionui_db::{IAgentWorkspaceLeaseRepository, IDevelopmentRepository, IProjectRepository}; +use serde::{Deserialize, Serialize}; +use sha2::{Digest, Sha256}; +use tokio::io::AsyncReadExt; + +use crate::error::DevelopmentError; +use crate::executor::{CommandExecutionInput, execute_command}; +use crate::operations::{DevelopmentOperationsService, default_policy}; +use crate::requirements::build_snapshot; +use crate::runner::{DevelopmentRunner, RunnerContext}; +use crate::types::{ + AppendPlanRevisionInput, CompletionEvidenceInput, CreateArtifactInput, CreateDevelopmentRunInput, + CreateDevelopmentTaskInput, ReviewFindingInput, SubmitReviewInput, +}; +use crate::workspace::{DevelopmentWorkspacePort, PrepareDevelopmentWorkspace}; + +const MAX_GATE_OUTPUT_BYTES: usize = 1024 * 1024; + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct CompletionEvaluation { + pub allowed: bool, + pub reasons: Vec, +} + +#[derive(Clone)] +pub struct DevelopmentService { + development_repo: Arc, + project_repo: Arc, + lease_repo: Arc, + artifact_root: PathBuf, + operations: Option>, + workspace: Option>, + runner: Option>, +} + +impl DevelopmentService { + pub fn new( + development_repo: Arc, + project_repo: Arc, + lease_repo: Arc, + artifact_root: PathBuf, + ) -> Self { + Self { + development_repo, + project_repo, + lease_repo, + artifact_root, + operations: None, + workspace: None, + runner: None, + } + } + + pub fn with_operations(mut self, operations: Arc) -> Self { + self.operations = Some(operations); + self + } + + pub fn with_workspace(mut self, workspace: Arc) -> Self { + self.workspace = Some(workspace); + self + } + + pub fn with_runner(mut self, runner: Arc) -> Self { + self.runner = Some(runner); + self + } + + pub async fn create_run( + &self, + user_id: &str, + input: CreateDevelopmentRunInput, + ) -> Result { + if !matches!(input.execution_mode.as_str(), "single" | "team") { + return Err(DevelopmentError::BadRequest( + "execution_mode must be single or team".into(), + )); + } + if input.execution_mode == "team" && input.team_id.is_none() { + return Err(DevelopmentError::BadRequest("team execution requires team_id".into())); + } + let summary = required_text(input.request_summary, "request_summary")?; + let criteria = clean_criteria(input.acceptance_criteria)?; + let project = self + .project_repo + .get_for_user(&input.project_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("project {}", input.project_id)))?; + let baseline_commit = git2::Repository::discover(&project.local_path).ok().and_then(|repo| { + repo.head() + .ok() + .and_then(|head| head.target()) + .map(|oid| oid.to_string()) + }); + let id = uuid::Uuid::now_v7().to_string(); + let short_id = id.split('-').next().unwrap_or(&id).to_owned(); + let now = now_ms(); + let row = DevelopmentRunRow { + id, + user_id: user_id.into(), + project_id: project.id, + team_id: input.team_id, + source_channel: input.source_channel, + source_user_id: input.source_user_id, + execution_mode: input.execution_mode, + status: "running".into(), + request_summary: summary, + acceptance_criteria: serde_json::to_string(&criteria) + .map_err(|error| DevelopmentError::Internal(error.to_string()))?, + baseline_commit, + integration_branch: Some(format!("aion/run/{short_id}/integration")), + started_at: Some(now), + finished_at: None, + created_at: now, + updated_at: now, + }; + self.development_repo.create_run(&row).await?; + self.append_requirement_version(user_id, &row.id, &row.request_summary, None, &criteria) + .await?; + if let Some(operations) = &self.operations { + operations + .audit( + user_id, + "user", + user_id, + "development_run.create", + "development_run", + &row.id, + &row.project_id, + Some(&row.id), + None, + "success", + serde_json::json!({"execution_mode": row.execution_mode}), + &[], + ) + .await?; + } + Ok(row) + } + + pub async fn get_run(&self, user_id: &str, run_id: &str) -> Result { + self.development_repo + .get_run(run_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("run {run_id}"))) + } + + pub async fn list_runs( + &self, + user_id: &str, + project_id: Option<&str>, + ) -> Result, DevelopmentError> { + Ok(self.development_repo.list_runs(user_id, project_id).await?) + } + + async fn append_requirement_version( + &self, + user_id: &str, + run_id: &str, + content: &str, + change_summary: Option, + criteria: &[String], + ) -> Result { + let versions = self.development_repo.list_requirement_versions(run_id).await?; + let now = now_ms(); + let row = RequirementVersionRow { + id: uuid::Uuid::now_v7().to_string(), + run_id: run_id.into(), + version: versions.last().map_or(1, |version| version.version + 1), + content: required_text(content.into(), "requirement content")?, + change_summary: change_summary.and_then(clean_optional), + created_by: user_id.into(), + created_at: now, + }; + let criteria = criteria + .iter() + .enumerate() + .map(|(ordinal, statement)| AcceptanceCriterionRow { + id: uuid::Uuid::now_v7().to_string(), + run_id: run_id.into(), + requirement_version_id: row.id.clone(), + ordinal: ordinal as i64, + statement: statement.clone(), + required: true, + created_at: now, + }) + .collect::>(); + self.development_repo + .append_requirement_version(&row, &criteria) + .await?; + Ok(row) + } + + pub async fn append_requirement_revision( + &self, + user_id: &str, + run_id: &str, + content: &str, + change_summary: &str, + criteria: Vec, + ) -> Result { + let run = self.get_run(user_id, run_id).await?; + if matches!(run.status.as_str(), "succeeded" | "failed" | "cancelled") { + return Err(DevelopmentError::Conflict( + "terminal run requirements cannot be revised".into(), + )); + } + let criteria = clean_criteria(criteria)?; + let summary = required_text(change_summary.into(), "change_summary")?; + let row = self + .append_requirement_version(user_id, run_id, content, Some(summary), &criteria) + .await?; + Ok(aionui_api_types::RequirementVersion { + id: row.id, + version: row.version, + content: row.content, + change_summary: row.change_summary, + created_at: row.created_at, + }) + } + + pub async fn append_plan_revision( + &self, + user_id: &str, + run_id: &str, + input: AppendPlanRevisionInput, + ) -> Result { + let run = self.get_run(user_id, run_id).await?; + if matches!(run.status.as_str(), "succeeded" | "failed" | "cancelled") { + return Err(DevelopmentError::Conflict( + "terminal run plans cannot be revised".into(), + )); + } + let existing = self.development_repo.list_plan_revisions(run_id).await?; + let row = PlanRevisionRow { + id: uuid::Uuid::now_v7().to_string(), + run_id: run_id.into(), + revision: existing.last().map_or(1, |revision| revision.revision + 1), + summary: required_text(input.summary, "plan summary")?, + content: required_text(input.content, "plan content")?, + created_by: user_id.into(), + created_at: now_ms(), + }; + self.development_repo.append_plan_revision(&row).await?; + Ok(aionui_api_types::PlanRevision { + id: row.id, + revision: row.revision, + summary: row.summary, + content: row.content, + created_at: row.created_at, + }) + } + + pub async fn requirements_snapshot( + &self, + user_id: &str, + run_id: &str, + ) -> Result { + self.get_run(user_id, run_id).await?; + Ok(build_snapshot( + run_id, + self.development_repo.list_requirement_versions(run_id).await?, + self.development_repo.list_active_criteria(run_id).await?, + self.development_repo.list_plan_revisions(run_id).await?, + self.development_repo.list_task_criteria(run_id).await?, + self.development_repo.list_completion_evidence(run_id).await?, + )) + } + + pub async fn record_completion_evidence( + &self, + user_id: &str, + run_id: &str, + task_id: &str, + input: CompletionEvidenceInput, + ) -> Result { + self.get_run(user_id, run_id).await?; + if !matches!(input.evidence_type.as_str(), "code" | "test" | "no_change") { + return Err(DevelopmentError::BadRequest( + "evidence_type must be code, test, or no_change".into(), + )); + } + let task = self + .development_repo + .get_task(run_id, task_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("task {task_id}")))?; + let mappings = self.development_repo.list_task_criteria(run_id).await?; + if !mappings + .iter() + .any(|mapping| mapping.task_id == task.id && mapping.criterion_id == input.criterion_id) + { + return Err(DevelopmentError::BadRequest( + "completion evidence must reference a criterion owned by this task".into(), + )); + } + if let Some(artifact_id) = input.artifact_id.as_deref() + && !self + .development_repo + .list_artifacts(run_id, Some(task_id)) + .await? + .iter() + .any(|artifact| artifact.id == artifact_id) + { + return Err(DevelopmentError::BadRequest( + "evidence artifact is not owned by this task".into(), + )); + } + let row = CompletionEvidenceRow { + id: uuid::Uuid::now_v7().to_string(), + run_id: run_id.into(), + task_id: task_id.into(), + criterion_id: input.criterion_id, + evidence_type: input.evidence_type, + artifact_id: input.artifact_id, + reference: required_text(input.reference, "evidence reference")?, + accepted: input.accepted, + reviewer_id: input.reviewer_id.and_then(clean_optional), + created_at: now_ms(), + }; + if row.accepted && row.reviewer_id.is_none() { + return Err(DevelopmentError::BadRequest( + "accepted evidence requires reviewer_id".into(), + )); + } + self.development_repo.create_completion_evidence(&row).await?; + Ok(row) + } + + pub async fn complete_run(&self, user_id: &str, run_id: &str) -> Result { + let run = self.get_run(user_id, run_id).await?; + if !matches!(run.status.as_str(), "running" | "verifying" | "reviewing" | "rework") { + return Err(DevelopmentError::Conflict(format!( + "run {} cannot complete from status {}", + run.id, run.status + ))); + } + let snapshot = self.requirements_snapshot(user_id, run_id).await?; + let missing: Vec<_> = snapshot + .coverage + .iter() + .filter(|item| !item.accepted || item.task_ids.is_empty()) + .map(|item| item.statement.clone()) + .collect(); + if !missing.is_empty() { + return Err(DevelopmentError::Conflict(format!( + "required acceptance evidence is missing: {}", + missing.join(", ") + ))); + } + let gates = self.development_repo.list_gates(run_id, None).await?; + let mut required = HashMap::new(); + for gate in gates.iter().filter(|gate| gate.required) { + required.insert((gate.task_id.as_deref(), gate.gate_type.as_str()), gate); + } + if required.values().any(|gate| gate.status != "passed") { + return Err(DevelopmentError::Conflict( + "one or more required quality gates have not passed".into(), + )); + } + if !self + .development_repo + .update_run_status_if_current(run_id, user_id, &run.status, run.updated_at, "integrating", None) + .await? + { + return Err(DevelopmentError::Conflict( + "run state changed before completion could be finalized".into(), + )); + } + let completing_run = self.get_run(user_id, run_id).await?; + if let Some(runner) = &self.runner { + runner.cleanup_run(user_id, run_id).await?; + } + if !self + .development_repo + .update_run_status_if_current( + run_id, + user_id, + &completing_run.status, + completing_run.updated_at, + "succeeded", + Some(now_ms()), + ) + .await? + { + return Err(DevelopmentError::Conflict( + "run state changed while completion was being finalized".into(), + )); + } + self.get_run(user_id, run_id).await + } + + pub async fn assign_role( + &self, + user_id: &str, + run_id: &str, + slot_id: &str, + role: &str, + ) -> Result { + self.get_run(user_id, run_id).await?; + if let Some(operations) = &self.operations { + operations.require_budget(user_id, run_id, "assign_role", 0).await?; + } + if !matches!(role, "implementer" | "tester" | "reviewer" | "integrator") { + return Err(DevelopmentError::BadRequest(format!( + "unsupported development role: {role}" + ))); + } + let row = DevelopmentRunRoleRow { + run_id: run_id.into(), + slot_id: required_text(slot_id.into(), "slot_id")?, + role: role.into(), + assigned_at: now_ms(), + }; + self.development_repo.assign_role(&row).await?; + Ok(row) + } + + pub async fn list_roles( + &self, + user_id: &str, + run_id: &str, + ) -> Result, DevelopmentError> { + self.get_run(user_id, run_id).await?; + Ok(self.development_repo.list_roles(run_id).await?) + } + + pub async fn create_task( + &self, + user_id: &str, + run_id: &str, + input: CreateDevelopmentTaskInput, + ) -> Result { + let run = self.get_run(user_id, run_id).await?; + let subject = required_text(input.subject, "subject")?; + let criteria = clean_criteria(input.acceptance_criteria)?; + let owned_criteria = self.development_repo.list_active_criteria(run_id).await?; + let mapped_criteria: Vec<_> = criteria + .iter() + .filter_map(|statement| { + owned_criteria + .iter() + .find(|criterion| criterion.statement == *statement) + }) + .cloned() + .collect(); + if mapped_criteria.len() != criteria.len() || mapped_criteria.is_empty() { + return Err(DevelopmentError::BadRequest( + "every task acceptance criterion must belong to the active run requirement version".into(), + )); + } + if !matches!(input.risk_level.as_str(), "low" | "medium" | "high" | "critical") { + return Err(DevelopmentError::BadRequest("unsupported risk_level".into())); + } + let existing = self.development_repo.list_tasks(run_id).await?; + for dependency in &input.blocked_by { + if !existing.iter().any(|task| &task.id == dependency) { + return Err(DevelopmentError::BadRequest(format!( + "dependency {dependency} is not in this run" + ))); + } + } + if let Some(lease_id) = input.assigned_workspace_lease_id.as_deref() { + self.validate_lease(user_id, &run, lease_id).await?; + } + let now = now_ms(); + let row = DevelopmentTaskRow { + id: uuid::Uuid::now_v7().to_string(), + team_id: run.team_id.clone().unwrap_or_else(|| format!("run:{run_id}")), + run_id: Some(run_id.into()), + subject, + description: input.description.and_then(clean_optional), + status: if input.blocked_by.is_empty() { + "ready" + } else { + "pending" + } + .into(), + owner: input.owner.and_then(clean_optional), + blocked_by: serde_json::to_string(&input.blocked_by) + .map_err(|error| DevelopmentError::Internal(error.to_string()))?, + blocks: "[]".into(), + metadata: None, + acceptance_criteria: serde_json::to_string(&criteria) + .map_err(|error| DevelopmentError::Internal(error.to_string()))?, + task_type: required_text(input.task_type, "task_type")?, + risk_level: input.risk_level, + assigned_workspace_lease_id: input.assigned_workspace_lease_id, + review_status: "pending".into(), + verification_status: "pending".into(), + created_at: now, + updated_at: now, + }; + self.development_repo.create_task(&row).await?; + self.development_repo + .map_task_criteria( + &mapped_criteria + .into_iter() + .map(|criterion| TaskCriterionRow { + run_id: run_id.into(), + task_id: row.id.clone(), + criterion_id: criterion.id, + mapped_at: now, + }) + .collect::>(), + ) + .await?; + Ok(row) + } + + pub async fn list_tasks(&self, user_id: &str, run_id: &str) -> Result, DevelopmentError> { + self.get_run(user_id, run_id).await?; + Ok(self.development_repo.list_tasks(run_id).await?) + } + + pub async fn transition_task( + &self, + user_id: &str, + run_id: &str, + task_id: &str, + target: &str, + ) -> Result { + self.get_run(user_id, run_id).await?; + let task = self + .development_repo + .get_task(run_id, task_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("task {task_id}")))?; + if target == "completed" { + return Err(DevelopmentError::BadRequest( + "use the completion endpoint so quality evidence can be verified".into(), + )); + } + if !valid_task_transition(&task.status, target) { + return Err(DevelopmentError::Conflict(format!( + "task cannot transition from {} to {target}", + task.status + ))); + } + if matches!(target, "ready" | "claimed" | "in_progress") { + let dependencies: Vec = serde_json::from_str(&task.blocked_by) + .map_err(|error| DevelopmentError::Internal(error.to_string()))?; + let all_tasks = self.development_repo.list_tasks(run_id).await?; + if dependencies.iter().any(|dependency| { + !all_tasks + .iter() + .any(|candidate| candidate.id == *dependency && candidate.status == "completed") + }) { + return Err(DevelopmentError::Conflict( + "task still has incomplete dependencies".into(), + )); + } + } + self.development_repo + .update_task_state(run_id, task_id, target, &task.review_status, &task.verification_status) + .await?; + self.development_repo + .get_task(run_id, task_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("task {task_id}"))) + } + + pub async fn create_artifact( + &self, + user_id: &str, + run_id: &str, + input: CreateArtifactInput, + ) -> Result { + let run = self.get_run(user_id, run_id).await?; + validate_artifact_type(&input.artifact_type)?; + let task = match input.task_id.as_deref() { + Some(task_id) => Some( + self.development_repo + .get_task(run_id, task_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("task {task_id}")))?, + ), + None => None, + }; + let mut path_or_uri = required_text(input.path_or_uri, "path_or_uri")?; + let checksum = required_text(input.checksum, "checksum")?; + if input.artifact_type == "commit" { + if !(7..=64).contains(&path_or_uri.len()) || !path_or_uri.chars().all(|value| value.is_ascii_hexdigit()) { + return Err(DevelopmentError::BadRequest( + "commit artifact must contain a Git object id".into(), + )); + } + } else if input.artifact_type != "no_code_change" { + let project = self + .project_repo + .get_for_user(&run.project_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("project {}", run.project_id)))?; + let canonical = Path::new(&path_or_uri) + .canonicalize() + .map_err(|error| DevelopmentError::BadRequest(format!("artifact file cannot be resolved: {error}")))?; + if !canonical.is_file() { + return Err(DevelopmentError::BadRequest("artifact path is not a file".into())); + } + let mut allowed_roots = vec![PathBuf::from(project.local_path)]; + if let Some(lease_id) = task + .as_ref() + .and_then(|task| task.assigned_workspace_lease_id.as_deref()) + { + allowed_roots.push(PathBuf::from( + self.validate_lease(user_id, &run, lease_id).await?.worktree_path, + )); + } + if self.artifact_root.exists() { + allowed_roots.push(self.artifact_root.clone()); + } + let allowed = allowed_roots + .iter() + .filter_map(|root| root.canonicalize().ok()) + .any(|root| canonical == root || canonical.starts_with(&root)); + if !allowed { + return Err(DevelopmentError::BadRequest( + "artifact file is outside the project, assigned workspace, and managed artifact directory".into(), + )); + } + let actual = checksum_file(&canonical).await?; + if checksum != actual { + return Err(DevelopmentError::BadRequest( + "artifact checksum does not match file content".into(), + )); + } + path_or_uri = canonical.to_string_lossy().into_owned(); + } + let row = TaskArtifactRow { + id: uuid::Uuid::now_v7().to_string(), + run_id: run_id.into(), + task_id: input.task_id, + artifact_type: input.artifact_type, + path_or_uri, + checksum, + producer_agent_id: input.producer_agent_id, + metadata: input.metadata.map(|value| value.to_string()), + created_at: now_ms(), + }; + self.development_repo.create_artifact(&row).await?; + Ok(row) + } + + pub async fn execute_gate( + &self, + user_id: &str, + run_id: &str, + task_id: Option<&str>, + gate_type: &str, + workspace_lease_id: Option<&str>, + required: bool, + ) -> Result { + let run = self.get_run(user_id, run_id).await?; + if let Some(task_id) = task_id + && self.development_repo.get_task(run_id, task_id).await?.is_none() + { + return Err(DevelopmentError::NotFound(format!("task {task_id}"))); + } + let project = self + .project_repo + .get_for_user(&run.project_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("project {}", run.project_id)))?; + let profile = self + .project_repo + .get_command_profile(&run.project_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::BadRequest("project command profile is not configured".into()))?; + let command = command_for_gate(&profile, gate_type) + .ok_or_else(|| DevelopmentError::BadRequest(format!("gate {gate_type} has no configured command")))?; + let previous_attempts = self + .development_repo + .list_gates(run_id, task_id) + .await? + .into_iter() + .filter(|gate| gate.gate_type == gate_type) + .count() as i64; + if let Some(operations) = &self.operations { + operations + .require_budget(user_id, run_id, "quality_gate", previous_attempts) + .await?; + } + let lease = match workspace_lease_id { + Some(lease_id) => Some(self.validate_lease(user_id, &run, lease_id).await?), + None if run.execution_mode == "team" => { + return Err(DevelopmentError::BadRequest( + "team quality gates require an assigned workspace lease".into(), + )); + } + None => None, + }; + let working_directory = lease + .as_ref() + .map(|lease| lease.worktree_path.clone()) + .unwrap_or(project.local_path); + if let Some(lease) = lease.as_ref() { + let roles = self.development_repo.list_roles(run_id).await?; + if !roles.is_empty() { + let allowed_roles: &[&str] = if task_id.is_some() { + &["implementer", "tester"] + } else { + &["integrator"] + }; + if !roles + .iter() + .any(|role| role.slot_id == lease.slot_id && allowed_roles.contains(&role.role.as_str())) + { + return Err(DevelopmentError::BadRequest(format!( + "slot {} is not assigned an allowed quality role", + lease.slot_id + ))); + } + } + } + let started_at = now_ms(); + let started = Instant::now(); + let gate_id = uuid::Uuid::now_v7().to_string(); + let policy = match &self.operations { + Some(operations) => operations.get_policy(user_id, &run.project_id).await?, + None => default_policy(user_id, &run.project_id), + }; + let runtime_profile = self.project_repo.get_runtime_profile(&run.project_id, user_id).await?; + let environment = runtime_environment(runtime_profile.as_ref())?; + let mut row = QualityGateRunRow { + id: gate_id.clone(), + run_id: run_id.into(), + task_id: task_id.map(str::to_owned), + gate_type: gate_type.into(), + command: command.into(), + working_directory: working_directory.clone(), + exit_code: None, + status: "running".into(), + stdout_artifact_id: None, + stderr_artifact_id: None, + duration_ms: None, + isolation_mode: policy.isolation_mode.clone(), + execution_id: Some(gate_id.clone()), + required, + started_at: Some(started_at), + finished_at: None, + created_at: started_at, + }; + self.development_repo.create_gate(&row).await?; + let command_input = CommandExecutionInput { + execution_id: &gate_id, + run_id, + command, + working_directory: Path::new(&working_directory), + timeout_seconds: profile.command_timeout_seconds, + policy: &policy, + runtime_profile: runtime_profile.as_ref(), + environment, + }; + let output_result = match &self.runner { + Some(runner) => { + runner + .execute( + command_input, + &RunnerContext { + user_id: user_id.into(), + project_id: run.project_id.clone(), + run_id: run_id.into(), + task_id: task_id.map(str::to_owned), + turn_id: None, + gate_id: Some(gate_id.clone()), + }, + ) + .await + } + None => execute_command(command_input).await, + }; + let output = match output_result { + Ok(output) => output, + Err(error) => { + row.status = "failed".into(); + row.duration_ms = Some(started.elapsed().as_millis().min(i64::MAX as u128) as i64); + row.finished_at = Some(now_ms()); + self.development_repo.update_gate(&row).await?; + if let Some(operations) = &self.operations { + operations + .audit( + user_id, + "system", + "development-command-executor", + "quality_gate.execute", + "quality_gate", + &row.id, + &run.project_id, + Some(run_id), + task_id, + "failed", + serde_json::json!({ + "gate_type": gate_type, + "isolation_mode": row.isolation_mode, + "error": error.to_string(), + }), + &[], + ) + .await?; + } + return Err(error); + } + }; + let stdout = self + .persist_gate_output(run_id, task_id, &gate_id, "stdout", output.stdout.as_bytes()) + .await?; + let stderr = self + .persist_gate_output(run_id, task_id, &gate_id, "stderr", output.stderr.as_bytes()) + .await?; + row.exit_code = output.exit_code; + row.status = output.status; + row.stdout_artifact_id = Some(stdout.id); + row.stderr_artifact_id = Some(stderr.id); + row.duration_ms = Some(started.elapsed().as_millis().min(i64::MAX as u128) as i64); + row.isolation_mode = output.isolation_mode; + row.execution_id = Some(output.execution_id); + row.finished_at = Some(now_ms()); + self.development_repo.update_gate(&row).await?; + if let Some(operations) = &self.operations { + operations + .record_usage(DevelopmentUsageEventRow { + id: format!("gate:{}", row.id), + user_id: user_id.into(), + project_id: run.project_id.clone(), + run_id: Some(run_id.into()), + task_id: task_id.map(str::to_owned), + usage_type: "quality_gate".into(), + source: "platform".into(), + confidence: "measured".into(), + input_tokens: 0, + output_tokens: 0, + cost_microunits: 0, + duration_ms: row.duration_ms.unwrap_or_default().max(0), + retry_count: i64::from(previous_attempts > 0), + metadata_json: serde_json::json!({ + "gate_type": gate_type, + "status": row.status, + }) + .to_string(), + created_at: now_ms(), + }) + .await?; + operations + .audit( + user_id, + "system", + "development-command-executor", + "quality_gate.execute", + "quality_gate", + &row.id, + &run.project_id, + Some(run_id), + task_id, + if row.status == "passed" { "success" } else { "failed" }, + serde_json::json!({ + "gate_type": gate_type, + "status": row.status, + "isolation_mode": row.isolation_mode, + "duration_ms": row.duration_ms, + }), + &[], + ) + .await?; + } + if let Some(task_id) = task_id { + let task = self + .development_repo + .get_task(run_id, task_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("task {task_id}")))?; + let verification = if row.status == "passed" { "passed" } else { "failed" }; + self.development_repo + .update_task_state(run_id, task_id, &task.status, &task.review_status, verification) + .await?; + } + Ok(row) + } + + pub async fn submit_review( + &self, + user_id: &str, + run_id: &str, + input: SubmitReviewInput, + ) -> Result { + self.get_run(user_id, run_id).await?; + let task = self + .development_repo + .get_task(run_id, &input.task_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("task {}", input.task_id)))?; + if task.owner.as_deref() == Some(input.reviewer_agent_id.as_str()) { + return Err(DevelopmentError::BadRequest( + "reviewer must be different from the task implementer".into(), + )); + } + let roles = self.development_repo.list_roles(run_id).await?; + if !roles.is_empty() + && !roles + .iter() + .any(|role| role.slot_id == input.reviewer_agent_id && role.role == "reviewer") + { + return Err(DevelopmentError::BadRequest(format!( + "slot {} is not assigned the reviewer role", + input.reviewer_agent_id + ))); + } + let reviewer_agent_id = input.reviewer_agent_id.clone(); + let producer_agent_id = input.producer_agent_id.clone(); + for finding in input.findings { + self.create_finding( + run_id, + &input.task_id, + &reviewer_agent_id, + producer_agent_id.as_deref(), + finding, + ) + .await?; + } + let review_status = if input.approved { + "approved" + } else { + "changes_requested" + }; + let status = if input.approved { "review" } else { "rework" }; + self.development_repo + .update_task_state(run_id, &input.task_id, status, review_status, &task.verification_status) + .await?; + self.development_repo + .get_task(run_id, &input.task_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("task {}", input.task_id))) + } + + async fn create_finding( + &self, + run_id: &str, + task_id: &str, + reviewer_agent_id: &str, + producer_agent_id: Option<&str>, + finding: ReviewFindingInput, + ) -> Result<(), DevelopmentError> { + if !matches!( + finding.severity.as_str(), + "info" | "warning" | "major" | "critical" | "blocker" + ) { + return Err(DevelopmentError::BadRequest("unsupported finding severity".into())); + } + let now = now_ms(); + self.development_repo + .create_finding(&ReviewFindingRow { + id: uuid::Uuid::now_v7().to_string(), + run_id: run_id.into(), + task_id: task_id.into(), + reviewer_agent_id: reviewer_agent_id.into(), + producer_agent_id: producer_agent_id.map(str::to_owned), + severity: finding.severity, + file_path: finding.file_path, + line_number: finding.line_number, + reason: required_text(finding.reason, "finding reason")?, + suggestion: finding.suggestion, + status: "open".into(), + created_at: now, + updated_at: now, + }) + .await?; + Ok(()) + } + + pub async fn evaluate_completion( + &self, + user_id: &str, + run_id: &str, + task_id: &str, + ) -> Result { + self.get_run(user_id, run_id).await?; + let task = self + .development_repo + .get_task(run_id, task_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("task {task_id}")))?; + let artifacts = self.development_repo.list_artifacts(run_id, Some(task_id)).await?; + let gates = self.development_repo.list_gates(run_id, Some(task_id)).await?; + let findings = self.development_repo.list_findings(run_id, task_id).await?; + let mut reasons = Vec::new(); + let criteria: Vec = serde_json::from_str(&task.acceptance_criteria) + .map_err(|error| DevelopmentError::Internal(error.to_string()))?; + if criteria.is_empty() + || !artifacts + .iter() + .any(|artifact| matches!(artifact.artifact_type.as_str(), "test" | "report" | "review")) + { + reasons.push("acceptance criteria require a test, report, or review artifact".into()); + } + let mut latest_required = HashMap::new(); + for gate in gates.iter().filter(|gate| gate.required) { + latest_required.insert(gate.gate_type.as_str(), gate); + } + if latest_required.is_empty() { + reasons.push("no required quality gate has passed".into()); + } else if latest_required.values().any(|gate| gate.status != "passed") { + reasons.push("one or more required quality gates have not passed".into()); + } + if findings + .iter() + .any(|finding| finding.status == "open" && matches!(finding.severity.as_str(), "critical" | "blocker")) + { + reasons.push("critical or blocker review findings remain open".into()); + } + if !matches!(task.review_status.as_str(), "approved" | "not_required") { + reasons.push("review has not been approved".into()); + } + let has_commit = artifacts.iter().any(|artifact| artifact.artifact_type == "commit"); + let has_accepted_no_code = artifacts + .iter() + .any(|artifact| artifact.artifact_type == "no_code_change") + && task.review_status == "approved"; + if !has_commit && !has_accepted_no_code { + reasons.push("a commit or reviewer-approved no-code artifact is required".into()); + } + if artifacts.iter().any(|artifact| artifact.checksum.trim().is_empty()) { + reasons.push("one or more artifacts have no checksum".into()); + } + for artifact in artifacts + .iter() + .filter(|artifact| !matches!(artifact.artifact_type.as_str(), "commit" | "no_code_change")) + { + match checksum_file(Path::new(&artifact.path_or_uri)).await { + Ok(checksum) if checksum == artifact.checksum => {} + _ => reasons.push(format!( + "artifact {} is missing or its checksum is invalid", + artifact.id + )), + } + } + Ok(CompletionEvaluation { + allowed: reasons.is_empty(), + reasons, + }) + } + + pub async fn complete_task( + &self, + user_id: &str, + run_id: &str, + task_id: &str, + ) -> Result { + let evaluation = self.evaluate_completion(user_id, run_id, task_id).await?; + if !evaluation.allowed { + return Err(DevelopmentError::Conflict(evaluation.reasons.join("; "))); + } + self.development_repo + .update_task_state(run_id, task_id, "completed", "approved", "passed") + .await?; + self.development_repo + .get_task(run_id, task_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("task {task_id}"))) + } + + pub async fn list_artifacts( + &self, + user_id: &str, + run_id: &str, + task_id: Option<&str>, + ) -> Result, DevelopmentError> { + self.get_run(user_id, run_id).await?; + Ok(self.development_repo.list_artifacts(run_id, task_id).await?) + } + + pub async fn list_gates( + &self, + user_id: &str, + run_id: &str, + task_id: Option<&str>, + ) -> Result, DevelopmentError> { + self.get_run(user_id, run_id).await?; + Ok(self.development_repo.list_gates(run_id, task_id).await?) + } + + pub async fn list_findings( + &self, + user_id: &str, + run_id: &str, + task_id: &str, + ) -> Result, DevelopmentError> { + self.get_run(user_id, run_id).await?; + Ok(self.development_repo.list_findings(run_id, task_id).await?) + } + + pub async fn resolve_finding( + &self, + user_id: &str, + run_id: &str, + finding_id: &str, + status: &str, + ) -> Result<(), DevelopmentError> { + self.get_run(user_id, run_id).await?; + if !matches!(status, "resolved" | "dismissed") { + return Err(DevelopmentError::BadRequest( + "finding status must be resolved or dismissed".into(), + )); + } + if !self + .development_repo + .update_finding_status(run_id, finding_id, status) + .await? + { + return Err(DevelopmentError::NotFound(format!("finding {finding_id}"))); + } + Ok(()) + } + + pub async fn prepare_single_workspace( + &self, + user_id: &str, + run_id: &str, + ) -> Result { + let run = self.get_run(user_id, run_id).await?; + if run.execution_mode != "single" { + return Err(DevelopmentError::BadRequest( + "only single-Agent runs use a single workspace".into(), + )); + } + if let Some(existing) = self.development_repo.get_single_run_workspace(run_id, user_id).await? { + return Ok(single_workspace_dto(existing)); + } + let project = self + .project_repo + .get_for_user(&run.project_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("project {}", run.project_id)))?; + let repository = git2::Repository::discover(&project.local_path) + .map_err(|error| DevelopmentError::BadRequest(format!("project repository is unavailable: {error}")))?; + let baseline_commit = repository + .head() + .ok() + .and_then(|head| head.target()) + .map(|oid| oid.to_string()) + .ok_or_else(|| DevelopmentError::BadRequest("project repository has no baseline commit".into()))?; + let snapshot = initial_user_diff(&repository)?; + let checksum = format!("sha256:{:x}", Sha256::digest(&snapshot)); + let directory = self.artifact_root.join(run_id).join("workspace"); + tokio::fs::create_dir_all(&directory).await?; + let snapshot_path = directory.join("initial-user.diff"); + tokio::fs::write(&snapshot_path, &snapshot).await?; + let workspace = self + .workspace + .as_ref() + .ok_or_else(|| DevelopmentError::Conflict("development workspace provider is unavailable".into()))? + .prepare(PrepareDevelopmentWorkspace { + user_id: user_id.into(), + run_id: run_id.into(), + repository_path: repository + .workdir() + .unwrap_or_else(|| Path::new(&project.local_path)) + .to_string_lossy() + .into_owned(), + baseline_commit: baseline_commit.clone(), + }) + .await + .map_err(DevelopmentError::Conflict)?; + let now = now_ms(); + let row = SingleRunWorkspaceRow { + run_id: run_id.into(), + user_id: user_id.into(), + project_id: run.project_id, + baseline_commit, + initial_diff_checksum: checksum, + initial_diff_path: snapshot_path.to_string_lossy().into_owned(), + workspace_lease_id: Some(workspace.lease_id), + workspace_path: Some(workspace.workspace_path), + branch: Some(workspace.branch), + candidate_commit: None, + safe_point: workspace.safe_point, + cleanup_status: "active".into(), + created_at: now, + updated_at: now, + }; + self.development_repo.create_single_run_workspace(&row).await?; + Ok(single_workspace_dto(row)) + } + + pub async fn get_single_workspace( + &self, + user_id: &str, + run_id: &str, + ) -> Result, DevelopmentError> { + self.get_run(user_id, run_id).await?; + Ok(self + .development_repo + .get_single_run_workspace(run_id, user_id) + .await? + .map(single_workspace_dto)) + } + + pub async fn cancel_single_workspace( + &self, + user_id: &str, + run_id: &str, + ) -> Result { + let run = self.get_run(user_id, run_id).await?; + self.ensure_no_pending_recovery(&run).await?; + ensure_run_is_cancellable(&run)?; + let row = self + .development_repo + .get_single_run_workspace(run_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("single workspace for run {run_id}")))?; + if !self + .development_repo + .update_run_status_if_current(run_id, user_id, &run.status, run.updated_at, "integrating", None) + .await? + { + return Err(DevelopmentError::Conflict( + "run state changed before cancellation could begin".into(), + )); + } + let cancelling_run = self.get_run(user_id, run_id).await?; + if let Some(runner) = &self.runner { + runner.cleanup_run(user_id, run_id).await?; + } + let lease_id = row + .workspace_lease_id + .as_deref() + .ok_or_else(|| DevelopmentError::Conflict("single workspace has no active lease".into()))?; + let cleanup = self + .workspace + .as_ref() + .ok_or_else(|| DevelopmentError::Conflict("development workspace provider is unavailable".into()))? + .restore(lease_id, &row.safe_point) + .await + .map_err(DevelopmentError::Conflict)?; + self.development_repo + .update_single_run_workspace(run_id, user_id, None, &cleanup) + .await?; + if !self + .development_repo + .update_run_status_if_current( + run_id, + user_id, + &cancelling_run.status, + cancelling_run.updated_at, + "cancelled", + Some(now_ms()), + ) + .await? + { + return Err(DevelopmentError::Conflict( + "run state changed while cancellation was being finalized".into(), + )); + } + let updated = self + .development_repo + .get_single_run_workspace(run_id, user_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("single workspace for run {run_id}")))?; + Ok(single_workspace_dto(updated)) + } + + pub async fn cancel_run(&self, user_id: &str, run_id: &str) -> Result { + let run = self.get_run(user_id, run_id).await?; + self.ensure_no_pending_recovery(&run).await?; + ensure_run_is_cancellable(&run)?; + if !self + .development_repo + .update_run_status_if_current(run_id, user_id, &run.status, run.updated_at, "integrating", None) + .await? + { + return Err(DevelopmentError::Conflict( + "run state changed before cancellation could begin".into(), + )); + } + let cancelling_run = self.get_run(user_id, run_id).await?; + if let Some(runner) = &self.runner { + runner.cleanup_run(user_id, run_id).await?; + } + if !self + .development_repo + .update_run_status_if_current( + run_id, + user_id, + &cancelling_run.status, + cancelling_run.updated_at, + "cancelled", + Some(now_ms()), + ) + .await? + { + return Err(DevelopmentError::Conflict( + "run state changed while cancellation was being finalized".into(), + )); + } + self.get_run(user_id, run_id).await + } + + async fn ensure_no_pending_recovery(&self, run: &DevelopmentRunRow) -> Result<(), DevelopmentError> { + let Some(operations) = &self.operations else { + return Ok(()); + }; + let pending = operations + .snapshot(&run.user_id, &run.project_id, Some(&run.id)) + .await? + .recovery + .into_iter() + .any(|record| { + record.status_after.is_none() + && serde_json::from_str::(&record.details_json) + .ok() + .and_then(|value| { + value + .get("state") + .and_then(serde_json::Value::as_str) + .map(str::to_owned) + }) + .as_deref() + == Some("pending") + }); + if pending { + return Err(DevelopmentError::Conflict( + "run recovery is pending; complete recovery before changing run state".into(), + )); + } + Ok(()) + } + + async fn validate_lease( + &self, + user_id: &str, + run: &DevelopmentRunRow, + lease_id: &str, + ) -> Result { + let lease = self + .lease_repo + .get(lease_id) + .await? + .ok_or_else(|| DevelopmentError::NotFound(format!("workspace lease {lease_id}")))?; + let expected_namespace = run.team_id.clone().unwrap_or_else(|| format!("run:{}", run.id)); + if lease.user_id != user_id || lease.team_id != expected_namespace { + return Err(DevelopmentError::NotFound(format!("workspace lease {lease_id}"))); + } + if lease.lease_status != "active" { + return Err(DevelopmentError::Conflict(format!( + "workspace lease {lease_id} is not active" + ))); + } + Ok(lease) + } + + async fn persist_gate_output( + &self, + run_id: &str, + task_id: Option<&str>, + gate_id: &str, + stream: &str, + bytes: &[u8], + ) -> Result { + let directory = self.artifact_root.join(run_id).join("quality-gates"); + tokio::fs::create_dir_all(&directory).await?; + let filename = format!("{gate_id}-{stream}.log"); + let path = directory.join(&filename); + tokio::fs::write(&path, bytes).await?; + let checksum = format!("sha256:{:x}", Sha256::digest(bytes)); + let row = TaskArtifactRow { + id: uuid::Uuid::now_v7().to_string(), + run_id: run_id.into(), + task_id: task_id.map(str::to_owned), + artifact_type: "log".into(), + path_or_uri: path.to_string_lossy().into_owned(), + checksum, + producer_agent_id: None, + metadata: Some(serde_json::json!({ "stream": stream, "truncated_at": MAX_GATE_OUTPUT_BYTES }).to_string()), + created_at: now_ms(), + }; + self.development_repo.create_artifact(&row).await?; + Ok(row) + } +} + +fn ensure_run_is_cancellable(run: &DevelopmentRunRow) -> Result<(), DevelopmentError> { + if matches!( + run.status.as_str(), + "integrating" | "succeeded" | "failed" | "cancelled" + ) { + return Err(DevelopmentError::Conflict(format!( + "run {} cannot be cancelled from status {}", + run.id, run.status + ))); + } + Ok(()) +} + +fn required_text(value: String, field: &str) -> Result { + let value = value.trim().to_owned(); + if value.is_empty() { + Err(DevelopmentError::BadRequest(format!("{field} must not be empty"))) + } else { + Ok(value) + } +} + +fn clean_optional(value: String) -> Option { + let value = value.trim().to_owned(); + (!value.is_empty()).then_some(value) +} + +fn clean_criteria(values: Vec) -> Result, DevelopmentError> { + let values: Vec<_> = values.into_iter().filter_map(clean_optional).collect(); + if values.is_empty() { + Err(DevelopmentError::BadRequest( + "at least one acceptance criterion is required".into(), + )) + } else { + Ok(values) + } +} + +fn validate_artifact_type(value: &str) -> Result<(), DevelopmentError> { + if matches!( + value, + "diff" | "test" | "log" | "report" | "commit" | "review" | "no_code_change" + ) { + Ok(()) + } else { + Err(DevelopmentError::BadRequest(format!( + "unsupported artifact type: {value}" + ))) + } +} + +fn valid_task_transition(current: &str, target: &str) -> bool { + matches!( + (current, target), + ("pending", "ready") + | ("pending", "cancelled") + | ("ready", "claimed") + | ("ready", "cancelled") + | ("claimed", "in_progress") + | ("claimed", "cancelled") + | ("in_progress", "waiting_approval") + | ("in_progress", "verifying") + | ("in_progress", "review") + | ("in_progress", "failed") + | ("in_progress", "cancelled") + | ("waiting_approval", "in_progress") + | ("waiting_approval", "cancelled") + | ("verifying", "review") + | ("verifying", "rework") + | ("verifying", "failed") + | ("review", "rework") + | ("review", "cancelled") + | ("rework", "claimed") + | ("rework", "in_progress") + | ("rework", "cancelled") + ) +} + +fn single_workspace_dto(row: SingleRunWorkspaceRow) -> aionui_api_types::SingleRunWorkspace { + aionui_api_types::SingleRunWorkspace { + run_id: row.run_id, + baseline_commit: row.baseline_commit, + initial_diff_checksum: row.initial_diff_checksum, + initial_diff_path: row.initial_diff_path, + workspace_lease_id: row.workspace_lease_id, + workspace_path: row.workspace_path, + branch: row.branch, + candidate_commit: row.candidate_commit, + safe_point: row.safe_point, + cleanup_status: row.cleanup_status, + created_at: row.created_at, + updated_at: row.updated_at, + } +} + +fn initial_user_diff(repository: &git2::Repository) -> Result, DevelopmentError> { + let head = repository + .head() + .and_then(|head| head.peel_to_tree()) + .map_err(|error| DevelopmentError::BadRequest(format!("cannot read baseline tree: {error}")))?; + let mut options = git2::DiffOptions::new(); + options + .include_untracked(true) + .recurse_untracked_dirs(true) + .show_untracked_content(true); + let diff = repository + .diff_tree_to_workdir_with_index(Some(&head), Some(&mut options)) + .map_err(|error| DevelopmentError::Internal(format!("cannot capture initial diff: {error}")))?; + let mut bytes = Vec::new(); + diff.print(git2::DiffFormat::Patch, |_delta, _hunk, line| { + bytes.extend_from_slice(line.content()); + true + }) + .map_err(|error| DevelopmentError::Internal(format!("cannot serialize initial diff: {error}")))?; + Ok(bytes) +} + +fn command_for_gate<'a>(profile: &'a ProjectCommandProfileRow, gate_type: &str) -> Option<&'a str> { + match gate_type { + "install" => profile.install_command.as_deref(), + "format" => profile.format_command.as_deref(), + "lint" => profile.lint_command.as_deref(), + "typecheck" => profile.typecheck_command.as_deref(), + "unit_test" => profile.unit_test_command.as_deref(), + "integration_test" => profile.integration_test_command.as_deref(), + "e2e" => profile.e2e_command.as_deref(), + "build" => profile.build_command.as_deref(), + "security_scan" => profile.security_scan_command.as_deref(), + _ => None, + } +} + +fn runtime_environment( + profile: Option<&aionui_db::models::ProjectRuntimeProfileRow>, +) -> Result, DevelopmentError> { + let keys: Vec = match profile { + Some(profile) => serde_json::from_str(&profile.env_keys) + .map_err(|error| DevelopmentError::BadRequest(format!("invalid runtime env keys: {error}")))?, + None => Vec::new(), + }; + Ok(keys + .into_iter() + .filter_map(|key| std::env::var(&key).ok().map(|value| (key, value))) + .collect()) +} + +async fn checksum_file(path: &Path) -> Result { + let mut file = tokio::fs::File::open(path).await?; + let mut digest = Sha256::new(); + let mut chunk = [0_u8; 16 * 1024]; + loop { + let count = file.read(&mut chunk).await?; + if count == 0 { + break; + } + digest.update(&chunk[..count]); + } + Ok(format!("sha256:{:x}", digest.finalize())) +} diff --git a/crates/aionui-development/src/types.rs b/crates/aionui-development/src/types.rs new file mode 100644 index 000000000..f86b0e814 --- /dev/null +++ b/crates/aionui-development/src/types.rs @@ -0,0 +1,118 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct CreateDevelopmentRunInput { + pub project_id: String, + pub team_id: Option, + pub source_channel: Option, + pub source_user_id: Option, + pub execution_mode: String, + pub request_summary: String, + #[serde(default)] + pub acceptance_criteria: Vec, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct CreateDevelopmentTaskInput { + pub subject: String, + pub description: Option, + pub owner: Option, + #[serde(default)] + pub blocked_by: Vec, + #[serde(default)] + pub acceptance_criteria: Vec, + #[serde(default = "default_task_type")] + pub task_type: String, + #[serde(default = "default_risk_level")] + pub risk_level: String, + pub assigned_workspace_lease_id: Option, +} + +fn default_task_type() -> String { + "implementation".into() +} + +fn default_risk_level() -> String { + "medium".into() +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ExecuteQualityGateInput { + pub task_id: Option, + pub gate_type: String, + pub workspace_lease_id: Option, + #[serde(default = "default_required")] + pub required: bool, +} + +fn default_required() -> bool { + true +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct CreateArtifactInput { + pub task_id: Option, + pub artifact_type: String, + pub path_or_uri: String, + pub checksum: String, + pub producer_agent_id: Option, + pub metadata: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct SubmitReviewInput { + pub task_id: String, + pub reviewer_agent_id: String, + pub producer_agent_id: Option, + #[serde(default)] + pub findings: Vec, + pub approved: bool, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ReviewFindingInput { + pub severity: String, + pub file_path: Option, + pub line_number: Option, + pub reason: String, + pub suggestion: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ResolveFindingInput { + pub status: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct AssignDevelopmentRoleInput { + pub slot_id: String, + pub role: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct TransitionDevelopmentTaskInput { + pub status: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct AppendRequirementRevisionInput { + pub content: String, + pub change_summary: String, + pub acceptance_criteria: Vec, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct AppendPlanRevisionInput { + pub summary: String, + pub content: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct CompletionEvidenceInput { + pub criterion_id: String, + pub evidence_type: String, + pub artifact_id: Option, + pub reference: String, + pub accepted: bool, + pub reviewer_id: Option, +} diff --git a/crates/aionui-development/src/workspace.rs b/crates/aionui-development/src/workspace.rs new file mode 100644 index 000000000..d4f346178 --- /dev/null +++ b/crates/aionui-development/src/workspace.rs @@ -0,0 +1,24 @@ +use async_trait::async_trait; +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct PrepareDevelopmentWorkspace { + pub user_id: String, + pub run_id: String, + pub repository_path: String, + pub baseline_commit: String, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct PreparedDevelopmentWorkspace { + pub lease_id: String, + pub workspace_path: String, + pub branch: String, + pub safe_point: String, +} + +#[async_trait] +pub trait DevelopmentWorkspacePort: Send + Sync { + async fn prepare(&self, input: PrepareDevelopmentWorkspace) -> Result; + async fn restore(&self, lease_id: &str, safe_point: &str) -> Result; +} diff --git a/crates/aionui-development/tests/approval_service.rs b/crates/aionui-development/tests/approval_service.rs new file mode 100644 index 000000000..09bb91eb3 --- /dev/null +++ b/crates/aionui-development/tests/approval_service.rs @@ -0,0 +1,286 @@ +use std::sync::{Arc, Mutex}; + +use aionui_auth::CurrentUser; +use aionui_db::{SqliteApprovalRepository, init_database_memory}; +use aionui_development::{ + ApprovalError, ApprovalOption, ApprovalRequestInput, ApprovalResolver, ApprovalRouterState, ApprovalService, + ApprovalSource, ResolveApprovalContext, approval_routes, +}; +use async_trait::async_trait; +use axum::Extension; +use axum::body::Body; +use axum::http::{Request, StatusCode}; +use http_body_util::BodyExt; +use serde_json::{Value, json}; +use tower::ServiceExt; + +#[derive(Default)] +struct RecordingResolver { + calls: Mutex>, + fail: bool, +} + +#[async_trait] +impl ApprovalResolver for RecordingResolver { + async fn resolve( + &self, + conversation_id: &str, + call_id: &str, + value: Value, + always_allow: bool, + ) -> Result<(), String> { + if self.fail { + return Err("agent stopped".into()); + } + self.calls + .lock() + .unwrap() + .push((conversation_id.into(), call_id.into(), value, always_allow)); + Ok(()) + } +} + +async fn setup(resolver: Arc) -> (ApprovalService, aionui_db::Database) { + let db = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO conversations \ + (id, user_id, name, type, extra, pinned, created_at, updated_at) \ + VALUES ('conversation-1', 'system_default_user', 'Approval test', 'acp', '{}', 0, 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + let service = ApprovalService::new(Arc::new(SqliteApprovalRepository::new(db.pool().clone())), resolver); + (service, db) +} + +fn request() -> ApprovalRequestInput { + ApprovalRequestInput { + requester_user_id: "system_default_user".into(), + project_id: None, + run_id: None, + task_id: None, + conversation_id: "conversation-1".into(), + agent_id: Some("claude-code".into()), + call_id: "call-1".into(), + action_type: "execute".into(), + command: Some("TOKEN=super-secret cargo test".into()), + working_directory: Some("/tmp/project".into()), + risk_level: "high".into(), + options: vec![ + ApprovalOption { + label: "Allow once".into(), + value: json!("allow_once"), + params: None, + }, + ApprovalOption { + label: "Always allow".into(), + value: json!("allow_always"), + params: Some(json!({"always_allow": true})), + }, + ApprovalOption { + label: "Reject".into(), + value: json!("reject"), + params: Some(json!({"decision": "reject"})), + }, + ], + source: Some(ApprovalSource { + channel: "telegram".into(), + user_id: "telegram-user-1".into(), + chat_id: "-1003977604085".into(), + thread_id: Some(5), + }), + } +} + +#[tokio::test] +async fn create_is_idempotent_short_lived_and_redacts_secrets() { + let (service, _db) = setup(Arc::new(RecordingResolver::default())).await; + let first = service.create(request()).await.unwrap(); + let second = service.create(request()).await.unwrap(); + + assert_eq!(first.id, second.id); + assert!(first.id.len() <= 20); + assert!(!first.command.as_deref().unwrap().contains("super-secret")); + assert_eq!(first.status, "pending"); + assert!(first.expires_at > first.created_at); +} + +#[tokio::test] +async fn telegram_resolution_requires_matching_user_chat_and_thread() { + let resolver = Arc::new(RecordingResolver::default()); + let (service, _db) = setup(resolver.clone()).await; + let approval = service.create(request()).await.unwrap(); + + let wrong_thread = service + .resolve( + &approval.id, + 0, + ResolveApprovalContext::Channel { + user_id: "system_default_user".into(), + channel: "telegram".into(), + source_user_id: "telegram-user-1".into(), + chat_id: "-1003977604085".into(), + thread_id: Some(7), + is_admin: false, + }, + ) + .await; + assert!(matches!(wrong_thread, Err(ApprovalError::Forbidden(_)))); + + let row = service + .resolve( + &approval.id, + 1, + ResolveApprovalContext::Channel { + user_id: "system_default_user".into(), + channel: "telegram".into(), + source_user_id: "telegram-user-1".into(), + chat_id: "-1003977604085".into(), + thread_id: Some(5), + is_admin: false, + }, + ) + .await + .unwrap(); + assert_eq!(row.status, "approved"); + assert_eq!(resolver.calls.lock().unwrap().len(), 1); + assert!(resolver.calls.lock().unwrap()[0].3); +} + +#[tokio::test] +async fn telegram_topic_admin_can_resolve_for_requester_but_other_members_cannot() { + let resolver = Arc::new(RecordingResolver::default()); + let (service, _db) = setup(resolver.clone()).await; + let approval = service.create(request()).await.unwrap(); + + let member = service + .resolve( + &approval.id, + 0, + ResolveApprovalContext::Channel { + user_id: "system_default_user".into(), + channel: "telegram".into(), + source_user_id: "different-member".into(), + chat_id: "-1003977604085".into(), + thread_id: Some(5), + is_admin: false, + }, + ) + .await; + assert!(matches!(member, Err(ApprovalError::Forbidden(_)))); + + let resolved = service + .resolve( + &approval.id, + 0, + ResolveApprovalContext::Channel { + user_id: "system_default_user".into(), + channel: "telegram".into(), + source_user_id: "topic-admin".into(), + chat_id: "-1003977604085".into(), + thread_id: Some(5), + is_admin: true, + }, + ) + .await + .unwrap(); + assert_eq!(resolved.status, "approved"); + assert_eq!(resolver.calls.lock().unwrap().len(), 1); +} + +#[tokio::test] +async fn web_owner_can_reject_but_cannot_consume_twice() { + let resolver = Arc::new(RecordingResolver::default()); + let (service, _db) = setup(resolver.clone()).await; + let approval = service.create(request()).await.unwrap(); + + let row = service + .resolve( + &approval.id, + 2, + ResolveApprovalContext::Web { + user_id: "system_default_user".into(), + }, + ) + .await + .unwrap(); + assert_eq!(row.status, "rejected"); + + let duplicate = service + .resolve( + &approval.id, + 0, + ResolveApprovalContext::Web { + user_id: "system_default_user".into(), + }, + ) + .await; + assert!(matches!(duplicate, Err(ApprovalError::Conflict(_)))); + assert_eq!(resolver.calls.lock().unwrap().len(), 1); +} + +#[tokio::test] +async fn resolver_failure_cancels_consumed_approval() { + let resolver = Arc::new(RecordingResolver { + fail: true, + ..Default::default() + }); + let (service, _db) = setup(resolver).await; + let approval = service.create(request()).await.unwrap(); + + assert!(matches!( + service + .resolve( + &approval.id, + 0, + ResolveApprovalContext::Web { + user_id: "system_default_user".into(), + }, + ) + .await, + Err(ApprovalError::Resolver(_)) + )); + assert_eq!( + service.get("system_default_user", &approval.id).await.unwrap().status, + "cancelled" + ); +} + +#[tokio::test] +async fn authenticated_routes_list_and_resolve_owned_approvals() { + let resolver = Arc::new(RecordingResolver::default()); + let (service, _db) = setup(resolver.clone()).await; + let approval = service.create(request()).await.unwrap(); + let app = approval_routes(ApprovalRouterState { + service: Arc::new(service), + }) + .layer(Extension(CurrentUser { + id: "system_default_user".into(), + username: "system_default_user".into(), + })); + + let response = app + .clone() + .oneshot(Request::builder().uri("/api/approvals").body(Body::empty()).unwrap()) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::OK); + let bytes = response.into_body().collect().await.unwrap().to_bytes(); + let body: Value = serde_json::from_slice(&bytes).unwrap(); + assert_eq!(body["data"].as_array().unwrap().len(), 1); + + let response = app + .oneshot( + Request::builder() + .method("POST") + .uri(format!("/api/approvals/{}/resolve", approval.id)) + .header("content-type", "application/json") + .body(Body::from(json!({"option_index": 0}).to_string())) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::OK); + assert_eq!(resolver.calls.lock().unwrap().len(), 1); +} diff --git a/crates/aionui-development/tests/delivery_service.rs b/crates/aionui-development/tests/delivery_service.rs new file mode 100644 index 000000000..73ededa25 --- /dev/null +++ b/crates/aionui-development/tests/delivery_service.rs @@ -0,0 +1,617 @@ +use std::path::Path; +use std::sync::{Arc, Mutex}; + +use aionui_db::{IDevelopmentRepository, IProjectRepository, SqliteDevelopmentRepository, SqliteProjectRepository}; +use aionui_development::{ + CreatePullRequestInput, CreateTagInput, DeliveryProvider, DeliveryProviderSnapshot, DeliveryService, + PrepareDeliveryInput, ProviderCiCheck, ProviderPullRequest, ProviderReviewComment, ProviderTag, +}; +use async_trait::async_trait; + +#[derive(Default)] +struct FakeProvider { + pushes: Mutex, + pull_requests: Mutex, + merges: Mutex, + tags: Mutex, + snapshot: Mutex, + preflight_error: Mutex>, +} + +#[async_trait] +impl DeliveryProvider for FakeProvider { + async fn preflight(&self, _repository: &Path) -> Result<(), String> { + match self.preflight_error.lock().unwrap().clone() { + Some(error) => Err(error), + None => Ok(()), + } + } + + async fn push(&self, _repository: &Path, _branch: &str) -> Result<(), String> { + *self.pushes.lock().unwrap() += 1; + Ok(()) + } + + async fn ensure_pull_request( + &self, + _repository: &Path, + _head: &str, + _base: &str, + _title: &str, + _body: &str, + ) -> Result { + *self.pull_requests.lock().unwrap() += 1; + Ok(ProviderPullRequest { + number: 7, + url: "https://github.example/pr/7".into(), + status: "open".into(), + review_status: "pending".into(), + }) + } + + async fn synchronize(&self, _repository: &Path, _number: i64) -> Result { + Ok(self.snapshot.lock().unwrap().clone()) + } + + async fn merge(&self, _repository: &Path, _number: i64) -> Result<(), String> { + *self.merges.lock().unwrap() += 1; + Ok(()) + } + + async fn ensure_tag(&self, _repository: &Path, tag: &str, commit: &str) -> Result { + *self.tags.lock().unwrap() += 1; + Ok(ProviderTag { + name: tag.into(), + commit_sha: commit.into(), + remote_url: Some(format!("https://github.example/releases/tag/{tag}")), + }) + } +} + +fn git(repository: &Path, args: &[&str]) -> String { + let output = std::process::Command::new("git") + .arg("-C") + .arg(repository) + .args(args) + .output() + .unwrap(); + assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr)); + String::from_utf8_lossy(&output.stdout).trim().to_owned() +} + +async fn setup() -> ( + DeliveryService, + Arc, + Arc, + tempfile::TempDir, + aionui_db::Database, +) { + let workspace = tempfile::tempdir().unwrap(); + git(workspace.path(), &["init", "-b", "main"]); + git(workspace.path(), &["config", "user.email", "delivery@example.com"]); + git(workspace.path(), &["config", "user.name", "Delivery Test"]); + std::fs::write(workspace.path().join("README.md"), "baseline\n").unwrap(); + git(workspace.path(), &["add", "."]); + git(workspace.path(), &["commit", "-m", "baseline"]); + let baseline = git(workspace.path(), &["rev-parse", "HEAD"]); + + let db = aionui_db::init_database_memory().await.unwrap(); + let project_repo = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + project_repo + .create(&aionui_db::models::ProjectRow { + id: "project-delivery".into(), + user_id: "system_default_user".into(), + name: "Delivery".into(), + local_path: workspace.path().to_string_lossy().into_owned(), + repository_url: Some("https://github.com/example/delivery.git".into()), + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + let repo = Arc::new(SqliteDevelopmentRepository::new(db.pool().clone())); + repo.create_run(&aionui_db::models::DevelopmentRunRow { + id: "run-delivery".into(), + user_id: "system_default_user".into(), + project_id: "project-delivery".into(), + team_id: None, + source_channel: Some("webui".into()), + source_user_id: None, + execution_mode: "single".into(), + status: "reviewing".into(), + request_summary: "Ship delivery".into(), + acceptance_criteria: r#"["tests pass"]"#.into(), + baseline_commit: Some(baseline), + integration_branch: None, + started_at: Some(1), + finished_at: None, + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + repo.create_task(&aionui_db::models::DevelopmentTaskRow { + id: "task-complete".into(), + team_id: "run-delivery".into(), + run_id: Some("run-delivery".into()), + subject: "Implement".into(), + description: None, + status: "completed".into(), + owner: Some("agent".into()), + blocked_by: "[]".into(), + blocks: "[]".into(), + metadata: None, + acceptance_criteria: r#"["tests pass"]"#.into(), + task_type: "implementation".into(), + risk_level: "medium".into(), + assigned_workspace_lease_id: None, + review_status: "approved".into(), + verification_status: "passed".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + repo.create_gate(&aionui_db::models::QualityGateRunRow { + id: "gate-pass".into(), + run_id: "run-delivery".into(), + task_id: None, + gate_type: "unit_test".into(), + command: "cargo test".into(), + working_directory: workspace.path().to_string_lossy().into_owned(), + exit_code: Some(0), + status: "passed".into(), + stdout_artifact_id: None, + stderr_artifact_id: None, + duration_ms: Some(1), + isolation_mode: "host".into(), + execution_id: Some("gate-failed".into()), + required: true, + started_at: Some(1), + finished_at: Some(2), + created_at: 1, + }) + .await + .unwrap(); + + let provider = Arc::new(FakeProvider::default()); + let service = DeliveryService::new(repo.clone(), project_repo, provider.clone()); + (service, provider, repo, workspace, db) +} + +async fn pass_final_integration_gate(service: &DeliveryService, repo: &SqliteDevelopmentRepository) { + let delivery = service.get("system_default_user", "run-delivery").await.unwrap(); + let timestamp = delivery.created_at + 1; + repo.create_gate(&aionui_db::models::QualityGateRunRow { + id: "gate-final-integration".into(), + run_id: "run-delivery".into(), + task_id: None, + // Match the public quality-gate API and project command profile name. + gate_type: "integration_test".into(), + command: "cargo test --workspace".into(), + working_directory: "/tmp".into(), + exit_code: Some(0), + status: "passed".into(), + stdout_artifact_id: None, + stderr_artifact_id: None, + duration_ms: Some(1), + isolation_mode: "host".into(), + execution_id: Some("final-integration".into()), + required: true, + started_at: Some(timestamp), + finished_at: Some(timestamp), + created_at: timestamp, + }) + .await + .unwrap(); +} + +#[tokio::test] +async fn prepare_creates_non_protected_branch_and_candidate_commit_idempotently() { + let (service, _provider, _repo, workspace, _db) = setup().await; + std::fs::write(workspace.path().join("README.md"), "delivered\n").unwrap(); + + let first = service + .prepare( + "system_default_user", + "run-delivery", + PrepareDeliveryInput { + message: Some("feat: deliver".into()), + }, + ) + .await + .unwrap(); + let second = service + .prepare( + "system_default_user", + "run-delivery", + PrepareDeliveryInput { message: None }, + ) + .await + .unwrap(); + + assert_ne!(first.branch, "main"); + assert!(first.branch.starts_with("aion/run/")); + assert_eq!(first.commit_sha, second.commit_sha); + assert_eq!(git(workspace.path(), &["branch", "--show-current"]), first.branch); +} + +#[tokio::test] +async fn remote_flow_is_retry_safe_and_failed_ci_creates_one_rework_task() { + let (service, provider, repo, workspace, _db) = setup().await; + std::fs::write(workspace.path().join("README.md"), "delivered\n").unwrap(); + service + .prepare( + "system_default_user", + "run-delivery", + PrepareDeliveryInput { message: None }, + ) + .await + .unwrap(); + service.push("system_default_user", "run-delivery", 2).await.unwrap(); + service.push("system_default_user", "run-delivery", 2).await.unwrap(); + assert_eq!(*provider.pushes.lock().unwrap(), 1); + + service + .create_pull_request( + "system_default_user", + "run-delivery", + CreatePullRequestInput { + title: Some("Ship delivery".into()), + confirmed: true, + }, + ) + .await + .unwrap(); + service + .create_pull_request( + "system_default_user", + "run-delivery", + CreatePullRequestInput { + title: None, + confirmed: true, + }, + ) + .await + .unwrap(); + assert_eq!(*provider.pull_requests.lock().unwrap(), 1); + pass_final_integration_gate(&service, &repo).await; + + *provider.snapshot.lock().unwrap() = DeliveryProviderSnapshot { + pull_request: ProviderPullRequest { + number: 7, + url: "https://github.example/pr/7".into(), + status: "open".into(), + review_status: "approved".into(), + }, + checks: vec![ProviderCiCheck { + id: "check-unit".into(), + name: "unit".into(), + status: "failed".into(), + details_url: None, + summary: Some("tests failed".into()), + }], + review_comments: vec![], + }; + let failed = service.sync("system_default_user", "run-delivery").await.unwrap(); + assert_eq!(failed.ci_status, "failed"); + assert!(service.merge("system_default_user", "run-delivery", 2).await.is_err()); + let rework = repo + .list_tasks("run-delivery") + .await + .unwrap() + .into_iter() + .filter(|task| task.task_type == "rework") + .collect::>(); + assert_eq!(rework.len(), 1); + service.sync("system_default_user", "run-delivery").await.unwrap(); + assert_eq!( + repo.list_tasks("run-delivery") + .await + .unwrap() + .into_iter() + .filter(|task| task.task_type == "rework") + .count(), + 1 + ); + + *provider.snapshot.lock().unwrap() = DeliveryProviderSnapshot { + pull_request: ProviderPullRequest { + number: 7, + url: "https://github.example/pr/7".into(), + status: "open".into(), + review_status: "approved".into(), + }, + checks: vec![ProviderCiCheck { + id: "check-unit".into(), + name: "unit".into(), + status: "passed".into(), + details_url: None, + summary: Some("tests passed".into()), + }], + review_comments: vec![], + }; + let passed = service.sync("system_default_user", "run-delivery").await.unwrap(); + assert_eq!(passed.ci_status, "passed"); + assert_eq!(passed.review_status, "approved"); + let rework_task = repo + .list_tasks("run-delivery") + .await + .unwrap() + .into_iter() + .find(|task| task.task_type == "rework") + .unwrap(); + repo.update_task_state("run-delivery", &rework_task.id, "completed", "approved", "passed") + .await + .unwrap(); + let ready = service.sync("system_default_user", "run-delivery").await.unwrap(); + assert_eq!(ready.status, "merge_ready"); + let merged = service.merge("system_default_user", "run-delivery", 2).await.unwrap(); + assert_eq!(merged.status, "merged"); + assert_eq!(*provider.merges.lock().unwrap(), 1); + let commit_sha = merged.commit_sha.clone().unwrap(); + let first_tag = service + .create_tag( + "system_default_user", + "run-delivery", + CreateTagInput { + name: "v1.0.0".into(), + commit_sha: commit_sha.clone(), + confirmed: true, + confirmation_count: 2, + }, + ) + .await + .unwrap(); + let duplicate_tag = service + .create_tag( + "system_default_user", + "run-delivery", + CreateTagInput { + name: "v1.0.0".into(), + commit_sha, + confirmed: true, + confirmation_count: 2, + }, + ) + .await + .unwrap(); + assert_eq!(first_tag.id, duplicate_tag.id); + assert_eq!(*provider.tags.lock().unwrap(), 1); + assert!(service.list_tags("other-user", "run-delivery").await.is_err()); +} + +#[tokio::test] +async fn unresolved_review_comments_are_redispatched_once_as_rework_tasks() { + let (service, provider, repo, workspace, _db) = setup().await; + std::fs::write(workspace.path().join("README.md"), "review me\n").unwrap(); + service + .prepare( + "system_default_user", + "run-delivery", + PrepareDeliveryInput { message: None }, + ) + .await + .unwrap(); + service.push("system_default_user", "run-delivery", 2).await.unwrap(); + service + .create_pull_request( + "system_default_user", + "run-delivery", + CreatePullRequestInput { + title: None, + confirmed: true, + }, + ) + .await + .unwrap(); + *provider.snapshot.lock().unwrap() = DeliveryProviderSnapshot { + pull_request: ProviderPullRequest { + number: 7, + url: "https://github.example/pr/7".into(), + status: "open".into(), + review_status: "changes_requested".into(), + }, + checks: vec![ProviderCiCheck { + id: "check-unit".into(), + name: "unit".into(), + status: "passed".into(), + details_url: None, + summary: None, + }], + review_comments: vec![ProviderReviewComment { + id: "review-comment-17".into(), + body: "Handle the error path".into(), + url: Some("https://github.example/pr/7#discussion-17".into()), + author: Some("reviewer".into()), + resolved: false, + }], + }; + + service.sync("system_default_user", "run-delivery").await.unwrap(); + service.sync("system_default_user", "run-delivery").await.unwrap(); + + let tasks = repo + .list_tasks("run-delivery") + .await + .unwrap() + .into_iter() + .filter(|task| task.task_type == "review_rework") + .collect::>(); + assert_eq!(tasks.len(), 1); + assert!( + tasks[0] + .description + .as_deref() + .unwrap_or_default() + .contains("Handle the error path") + ); +} + +#[tokio::test] +async fn merge_ready_requires_a_passing_run_level_integration_gate_after_candidate_creation() { + let (service, provider, _repo, workspace, _db) = setup().await; + std::fs::write(workspace.path().join("README.md"), "candidate\n").unwrap(); + service + .prepare( + "system_default_user", + "run-delivery", + PrepareDeliveryInput { message: None }, + ) + .await + .unwrap(); + service.push("system_default_user", "run-delivery", 2).await.unwrap(); + service + .create_pull_request( + "system_default_user", + "run-delivery", + CreatePullRequestInput { + title: None, + confirmed: true, + }, + ) + .await + .unwrap(); + *provider.snapshot.lock().unwrap() = DeliveryProviderSnapshot { + pull_request: ProviderPullRequest { + number: 7, + url: "https://github.example/pr/7".into(), + status: "open".into(), + review_status: "approved".into(), + }, + checks: vec![ProviderCiCheck { + id: "check-unit".into(), + name: "unit".into(), + status: "passed".into(), + details_url: None, + summary: None, + }], + review_comments: vec![], + }; + + let delivery = service.sync("system_default_user", "run-delivery").await.unwrap(); + assert_eq!(delivery.merge_status, "blocked"); + assert!(service.merge("system_default_user", "run-delivery", 2).await.is_err()); +} + +#[tokio::test] +async fn prepare_blocks_latest_failed_gate_and_protected_integration_branch() { + let (service, _provider, repo, workspace, db) = setup().await; + std::fs::write(workspace.path().join("README.md"), "delivered\n").unwrap(); + repo.create_gate(&aionui_db::models::QualityGateRunRow { + id: "gate-latest-failed".into(), + run_id: "run-delivery".into(), + task_id: None, + gate_type: "unit_test".into(), + command: "cargo test".into(), + working_directory: workspace.path().to_string_lossy().into_owned(), + exit_code: Some(1), + status: "failed".into(), + stdout_artifact_id: None, + stderr_artifact_id: None, + duration_ms: Some(1), + isolation_mode: "host".into(), + execution_id: Some("gate-pass".into()), + required: true, + started_at: Some(2), + finished_at: Some(3), + created_at: 2, + }) + .await + .unwrap(); + assert!( + service + .prepare( + "system_default_user", + "run-delivery", + PrepareDeliveryInput { message: None }, + ) + .await + .is_err() + ); + + sqlx::query("DELETE FROM quality_gate_runs WHERE id = 'gate-latest-failed'") + .execute(db.pool()) + .await + .unwrap(); + sqlx::query("UPDATE development_runs SET integration_branch = 'main' WHERE id = 'run-delivery'") + .execute(db.pool()) + .await + .unwrap(); + assert!( + service + .prepare( + "system_default_user", + "run-delivery", + PrepareDeliveryInput { message: None }, + ) + .await + .is_err() + ); + assert_eq!(git(workspace.path(), &["branch", "--show-current"]), "main"); +} + +#[tokio::test] +async fn no_change_requires_explicit_artifact_and_cannot_be_pushed() { + let (service, _provider, repo, _workspace, _db) = setup().await; + assert!( + service + .prepare( + "system_default_user", + "run-delivery", + PrepareDeliveryInput { message: None }, + ) + .await + .is_err() + ); + repo.create_artifact(&aionui_db::models::TaskArtifactRow { + id: "accepted-no-change".into(), + run_id: "run-delivery".into(), + task_id: Some("task-complete".into()), + artifact_type: "no_code_change".into(), + path_or_uri: "review-approved".into(), + checksum: "review-approved".into(), + producer_agent_id: Some("reviewer".into()), + metadata: Some(r#"{"reason":"documentation-only acceptance"}"#.into()), + created_at: 2, + }) + .await + .unwrap(); + let delivery = service + .prepare( + "system_default_user", + "run-delivery", + PrepareDeliveryInput { message: None }, + ) + .await + .unwrap(); + assert_eq!(delivery.status, "no_change"); + assert!(delivery.commit_sha.is_none()); + assert!(service.push("system_default_user", "run-delivery", 2).await.is_err()); +} + +#[tokio::test] +async fn provider_failures_are_persisted_without_credentials() { + let (service, provider, _repo, workspace, _db) = setup().await; + std::fs::write(workspace.path().join("README.md"), "delivered\n").unwrap(); + service + .prepare( + "system_default_user", + "run-delivery", + PrepareDeliveryInput { message: None }, + ) + .await + .unwrap(); + *provider.preflight_error.lock().unwrap() = + Some("authorization: bearer-secret token=ghp_sensitive password=hunter2".into()); + assert!(service.push("system_default_user", "run-delivery", 2).await.is_err()); + let delivery = service.get("system_default_user", "run-delivery").await.unwrap(); + let error = delivery.last_error.unwrap(); + assert!(error.contains("[REDACTED]")); + assert!(!error.contains("bearer-secret")); + assert!(!error.contains("ghp_sensitive")); + assert!(!error.contains("hunter2")); + assert!(!delivery.report_json.contains("ghp_sensitive")); +} diff --git a/crates/aionui-development/tests/deployment_service.rs b/crates/aionui-development/tests/deployment_service.rs new file mode 100644 index 000000000..cc6d86003 --- /dev/null +++ b/crates/aionui-development/tests/deployment_service.rs @@ -0,0 +1,242 @@ +use std::sync::{Arc, Mutex}; + +use aionui_db::{ + IDevelopmentRepository, IProjectRepository, SqliteAgentWorkspaceLeaseRepository, + SqliteDevelopmentOperationsRepository, SqliteDevelopmentRepository, SqliteProjectRepository, +}; +use aionui_development::{ + DeploymentExecution, DeploymentProvider, DeploymentRequestInput, DeploymentService, DevelopmentOperationsService, +}; +use async_trait::async_trait; + +#[derive(Default)] +struct RecordingDeploymentProvider { + executions: Mutex>, +} + +#[async_trait] +impl DeploymentProvider for RecordingDeploymentProvider { + async fn deploy(&self, execution: &DeploymentExecution) -> Result, String> { + self.executions.lock().unwrap().push(execution.clone()); + Ok(Some(format!("remote:{}", execution.deployment_key))) + } + + async fn cancel(&self, _remote_id: &str) -> Result<(), String> { + Ok(()) + } +} + +async fn setup() -> ( + DeploymentService, + Arc, + Arc, + aionui_db::Database, +) { + let db = aionui_db::init_database_memory().await.unwrap(); + let projects = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + projects + .create(&aionui_db::models::ProjectRow { + id: "project-deploy".into(), + user_id: "system_default_user".into(), + name: "Deploy".into(), + local_path: "/tmp/deploy".into(), + repository_url: Some("https://github.com/acme/app.git".into()), + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + let repo = Arc::new(SqliteDevelopmentRepository::new(db.pool().clone())); + let now = aionui_common::now_ms(); + repo.create_run(&aionui_db::models::DevelopmentRunRow { + id: "run-deploy".into(), + user_id: "system_default_user".into(), + project_id: "project-deploy".into(), + team_id: None, + source_channel: Some("webui".into()), + source_user_id: None, + execution_mode: "single".into(), + status: "succeeded".into(), + request_summary: "Deploy release".into(), + acceptance_criteria: "[]".into(), + baseline_commit: Some("base123".into()), + integration_branch: Some("aion/run/deploy".into()), + started_at: Some(now), + finished_at: Some(now), + created_at: now, + updated_at: now, + }) + .await + .unwrap(); + repo.upsert_delivery(&aionui_db::models::DevelopmentDeliveryRow { + id: "delivery-deploy".into(), + run_id: "run-deploy".into(), + project_id: "project-deploy".into(), + user_id: "system_default_user".into(), + provider: "github".into(), + repository: Some("https://github.com/acme/app.git".into()), + branch: "aion/run/deploy".into(), + base_branch: "main".into(), + commit_sha: Some("abc1234".into()), + status: "merged".into(), + push_status: "pushed".into(), + pr_number: Some(42), + pr_url: Some("https://github.com/acme/app/pull/42".into()), + pr_status: "merged".into(), + ci_status: "passed".into(), + review_status: "approved".into(), + merge_status: "merged".into(), + report_json: "{}".into(), + last_error: None, + created_at: now, + updated_at: now, + }) + .await + .unwrap(); + let provider = Arc::new(RecordingDeploymentProvider::default()); + let operations = Arc::new(DevelopmentOperationsService::new( + Arc::new(SqliteDevelopmentOperationsRepository::new(db.pool().clone())), + repo.clone(), + projects.clone(), + Arc::new(SqliteAgentWorkspaceLeaseRepository::new(db.pool().clone())), + )); + let service = DeploymentService::new(repo.clone(), projects, provider.clone()).with_operations(operations); + (service, provider, repo, db) +} + +fn request() -> DeploymentRequestInput { + DeploymentRequestInput { + environment: "production".into(), + deployment_key: "release-2026-07-20".into(), + commit_sha: "abc1234".into(), + } +} + +#[tokio::test] +async fn deployment_requires_unexpired_human_approval_tied_to_the_exact_request() { + let (service, provider, _repo, db) = setup().await; + let pending = service + .request("system_default_user", "run-deploy", request()) + .await + .unwrap(); + assert!(service.list("other-user", "run-deploy").await.is_err()); + assert!(service.get("other-user", &pending.id).await.is_err()); + assert_eq!(pending.status, "pending_approval"); + assert!( + service + .execute("system_default_user", "run-deploy", &pending.id) + .await + .is_err() + ); + + assert!( + service + .approve("system_default_user", "run-deploy", &pending.id, 1) + .await + .is_err() + ); + let approved = service + .approve("system_default_user", "run-deploy", &pending.id, 2) + .await + .unwrap(); + assert_eq!(approved.status, "approved"); + + sqlx::query("UPDATE development_deployments SET approval_commit_sha = 'different' WHERE id = ?") + .bind(&pending.id) + .execute(db.pool()) + .await + .unwrap(); + assert!( + service + .execute("system_default_user", "run-deploy", &pending.id) + .await + .is_err() + ); + assert!(provider.executions.lock().unwrap().is_empty()); +} + +#[tokio::test] +async fn duplicate_requests_and_callbacks_never_deploy_twice() { + let (service, provider, _repo, db) = setup().await; + let first = service + .request("system_default_user", "run-deploy", request()) + .await + .unwrap(); + let duplicate = service + .request("system_default_user", "run-deploy", request()) + .await + .unwrap(); + assert_eq!(first.id, duplicate.id); + service + .approve("system_default_user", "run-deploy", &first.id, 2) + .await + .unwrap(); + + let completed = service + .execute("system_default_user", "run-deploy", &first.id) + .await + .unwrap(); + let callback = service + .execute("system_default_user", "run-deploy", &first.id) + .await + .unwrap(); + assert_eq!(completed.status, "succeeded"); + assert_eq!(callback.status, "succeeded"); + assert_eq!(provider.executions.lock().unwrap().len(), 1); + let actions = sqlx::query_scalar::<_, String>( + "SELECT action FROM development_audit_events WHERE target_id = ? ORDER BY created_at, id", + ) + .bind(&first.id) + .fetch_all(db.pool()) + .await + .unwrap(); + assert!(actions.contains(&"deployment.request".to_owned())); + assert!(actions.contains(&"deployment.approve".to_owned())); + assert!(actions.contains(&"deployment.execute".to_owned())); +} + +#[tokio::test] +async fn expired_or_rejected_production_approval_fails_closed() { + let (service, provider, _repo, db) = setup().await; + let pending = service + .request("system_default_user", "run-deploy", request()) + .await + .unwrap(); + sqlx::query("UPDATE development_deployments SET approval_expires_at = 1 WHERE id = ?") + .bind(&pending.id) + .execute(db.pool()) + .await + .unwrap(); + assert!( + service + .approve("system_default_user", "run-deploy", &pending.id, 2) + .await + .is_err() + ); + assert!( + service + .execute("system_default_user", "run-deploy", &pending.id) + .await + .is_err() + ); + assert!(provider.executions.lock().unwrap().is_empty()); +} + +#[tokio::test] +async fn deployment_actions_are_scoped_to_the_run_in_the_route_context() { + let (service, provider, _repo, _db) = setup().await; + let pending = service + .request("system_default_user", "run-deploy", request()) + .await + .unwrap(); + + assert!( + service + .approve("system_default_user", "another-run", &pending.id, 2) + .await + .is_err() + ); + assert!(provider.executions.lock().unwrap().is_empty()); +} diff --git a/crates/aionui-development/tests/development_routes.rs b/crates/aionui-development/tests/development_routes.rs new file mode 100644 index 000000000..ca51a3aad --- /dev/null +++ b/crates/aionui-development/tests/development_routes.rs @@ -0,0 +1,859 @@ +use std::path::Path; +use std::sync::Arc; +use std::sync::atomic::{AtomicUsize, Ordering}; + +use aionui_auth::CurrentUser; +use aionui_db::models::ProjectRow; +use aionui_db::{ + IDevelopmentRepository, IProjectRepository, SqliteAgentWorkspaceLeaseRepository, + SqliteDevelopmentOperationsRepository, SqliteDevelopmentRepository, SqliteProjectRepository, init_database_memory, +}; +use aionui_development::{ + DeliveryProvider, DeliveryProviderSnapshot, DeliveryService, DeploymentService, DevelopmentOperationsService, + DevelopmentRouterState, DevelopmentService, PortabilityService, PricingService, ProviderPullRequest, + ResourceLeaseCoordinator, RetentionService, SecretService, SystemDevelopmentResourceController, + UnconfiguredDeploymentProvider, development_routes, +}; +use async_trait::async_trait; +use axum::body::Body; +use axum::http::{Request, StatusCode}; +use axum::{Extension, Router}; +use http_body_util::BodyExt; +use tower::ServiceExt; + +#[derive(Default)] +struct FakeDeliveryProvider { + pushes: AtomicUsize, +} + +#[async_trait] +impl DeliveryProvider for FakeDeliveryProvider { + async fn preflight(&self, _repository: &Path) -> Result<(), String> { + Ok(()) + } + + async fn push(&self, _repository: &Path, _branch: &str) -> Result<(), String> { + self.pushes.fetch_add(1, Ordering::SeqCst); + Ok(()) + } + + async fn ensure_pull_request( + &self, + _repository: &Path, + _head: &str, + _base: &str, + _title: &str, + _body: &str, + ) -> Result { + unreachable!() + } + + async fn synchronize(&self, _repository: &Path, _number: i64) -> Result { + unreachable!() + } + + async fn merge(&self, _repository: &Path, _number: i64) -> Result<(), String> { + unreachable!() + } +} + +fn git(repository: &Path, args: &[&str]) -> String { + let output = std::process::Command::new("git") + .arg("-C") + .arg(repository) + .args(args) + .output() + .unwrap(); + assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr)); + String::from_utf8_lossy(&output.stdout).trim().to_owned() +} + +async fn app_for( + current_user_id: &str, +) -> ( + Router, + tempfile::TempDir, + aionui_db::Database, + Arc, +) { + let db = init_database_memory().await.unwrap(); + let project = tempfile::tempdir().unwrap(); + git(project.path(), &["init", "-b", "main"]); + git(project.path(), &["config", "user.email", "routes@example.com"]); + git(project.path(), &["config", "user.name", "Route Test"]); + std::fs::write(project.path().join("README.md"), "baseline\n").unwrap(); + git(project.path(), &["add", "."]); + git(project.path(), &["commit", "-m", "baseline"]); + let project_repo = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + project_repo + .create(&ProjectRow { + id: "project-1".into(), + user_id: "system_default_user".into(), + name: "Project".into(), + local_path: project.path().to_string_lossy().into_owned(), + repository_url: Some("https://github.com/example/project.git".into()), + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + let development_repo = Arc::new(SqliteDevelopmentRepository::new(db.pool().clone())); + let lease_repo = Arc::new(SqliteAgentWorkspaceLeaseRepository::new(db.pool().clone())); + let operations_repo = Arc::new(SqliteDevelopmentOperationsRepository::new(db.pool().clone())); + let operations_service = Arc::new( + DevelopmentOperationsService::new( + operations_repo.clone(), + development_repo.clone(), + project_repo.clone(), + lease_repo.clone(), + ) + .with_resources( + ResourceLeaseCoordinator::new(operations_repo.clone(), "route-instance"), + Arc::new(SystemDevelopmentResourceController), + ), + ); + let service = Arc::new( + DevelopmentService::new( + development_repo.clone(), + project_repo.clone(), + lease_repo, + project.path().join("artifacts"), + ) + .with_operations(operations_service.clone()), + ); + let provider = Arc::new(FakeDeliveryProvider::default()); + let delivery_service = Arc::new( + DeliveryService::new(development_repo.clone(), project_repo.clone(), provider.clone()) + .with_operations(operations_service.clone()), + ); + let router = development_routes(DevelopmentRouterState { + service, + delivery_service, + deployment_service: Arc::new(DeploymentService::new( + development_repo.clone(), + project_repo, + Arc::new(UnconfiguredDeploymentProvider), + )), + operations_service, + secret_service: Arc::new(SecretService::new( + operations_repo.clone(), + Arc::new(SqliteProjectRepository::new(db.pool().clone())), + Arc::new([9_u8; 32]), + )), + pricing_service: Arc::new(PricingService::new(operations_repo.clone())), + development_repo, + operations_repo, + approval_repo: Arc::new(aionui_db::SqliteApprovalRepository::new(db.pool().clone())), + portability_service: Arc::new(PortabilityService::new( + db.pool().clone(), + b"development-route-test", + "route-test-instance", + )), + retention_service: Arc::new(RetentionService::new(db.pool().clone())), + }) + .layer(Extension(CurrentUser { + id: current_user_id.into(), + username: current_user_id.into(), + })); + (router, project, db, provider) +} + +async fn app() -> ( + Router, + tempfile::TempDir, + aionui_db::Database, + Arc, +) { + app_for("system_default_user").await +} + +async fn json(response: axum::response::Response) -> serde_json::Value { + let bytes = response.into_body().collect().await.unwrap().to_bytes(); + serde_json::from_slice(&bytes).unwrap() +} + +#[tokio::test] +async fn retention_routes_are_owner_scoped_and_require_confirmation_for_cleanup() { + let (app, _project, _db, _provider) = app().await; + let updated = app + .clone() + .oneshot( + Request::builder() + .method("PUT") + .uri("/api/development-projects/project-1/retention") + .header("content-type", "application/json") + .body(Body::from( + r#"{"conversation_history_days":30,"artifact_days":60,"evaluation_days":90}"#, + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(updated.status(), StatusCode::OK); + assert_eq!(json(updated).await["data"]["artifact_days"], 60); + + let preview = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri("/api/development-projects/project-1/retention/cleanup") + .header("content-type", "application/json") + .body(Body::from(r#"{"dry_run":true,"confirmation_count":0}"#)) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(preview.status(), StatusCode::OK); + assert_eq!(json(preview).await["data"]["dry_run"], true); + + let rejected = app + .oneshot( + Request::builder() + .method("POST") + .uri("/api/development-projects/project-1/retention/cleanup") + .header("content-type", "application/json") + .body(Body::from(r#"{"dry_run":false,"confirmation_count":1}"#)) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(rejected.status(), StatusCode::BAD_REQUEST); + + let (other_app, _project, _db, _provider) = app_for("other-user").await; + let forbidden = other_app + .oneshot( + Request::builder() + .uri("/api/development-projects/project-1/retention") + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(forbidden.status(), StatusCode::NOT_FOUND); +} + +#[tokio::test] +async fn secret_routes_return_only_metadata_and_enforce_project_ownership() { + let (app, _project, _db, _provider) = app().await; + let response = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri("/api/development-projects/project-1/secrets") + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "name": "GitHub token", + "value": "ghp_route_secret_must_not_escape", + "expires_at": null + }) + .to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::CREATED); + let body = json(response).await; + let secret_id = body["data"]["id"].as_str().unwrap().to_owned(); + assert!(!body.to_string().contains("ghp_route_secret_must_not_escape")); + assert!(body["data"].get("encrypted_value").is_none()); + + let grant = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri(format!( + "/api/development-projects/project-1/secrets/{secret_id}/grants" + )) + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "secret_id": &secret_id, + "scope_type": "project", + "scope_id": "project-1", + "environment_key": "GITHUB_TOKEN", + "expires_at": null + }) + .to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(grant.status(), StatusCode::OK); + + let (other_app, _other_project, _other_db, _other_provider) = app_for("other-user").await; + let unauthorized = other_app + .oneshot( + Request::builder() + .uri("/api/development-projects/project-1/secrets") + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(unauthorized.status(), StatusCode::NOT_FOUND); + + let revoked = app + .oneshot( + Request::builder() + .method("POST") + .uri(format!( + "/api/development-projects/project-1/secrets/{secret_id}/revoke" + )) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(revoked.status(), StatusCode::OK); +} + +#[tokio::test] +async fn operations_routes_manage_policy_snapshot_and_recovery() { + let (app, _project, db, _provider) = app().await; + let response = app + .clone() + .oneshot( + Request::builder() + .uri("/api/development-projects/project-1/operations/policy") + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::OK); + assert_eq!(json(response).await["data"]["isolation_mode"], "host"); + + let response = app + .clone() + .oneshot( + Request::builder() + .method("PUT") + .uri("/api/development-projects/project-1/operations/policy") + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "isolation_mode": "docker", + "container_image": "node:24-alpine", + "container_cpu_millis": 1000, + "container_memory_mb": 2048, + "container_pids_limit": 256, + "network_mode": "none", + "allowed_secret_keys": ["NPM_TOKEN"], + "max_duration_ms": 14400000, + "max_parallel_agents": 4, + "max_retries": 3, + "max_cost_microunits": 0, + "alert_percent": 80, + "over_limit_action": "pause" + }) + .to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::OK); + let body = json(response).await; + assert_eq!(body["data"]["isolation_mode"], "docker"); + assert_eq!(body["data"]["allowed_secret_keys_json"], "[\"NPM_TOKEN\"]"); + + let run = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri("/api/development-runs") + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "project_id": "project-1", + "execution_mode": "single", + "request_summary": "recover", + "acceptance_criteria": ["safe"] + }) + .to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(run.status(), StatusCode::CREATED); + let run_id = json(run).await["data"]["id"].as_str().unwrap().to_owned(); + sqlx::query("UPDATE development_runs SET updated_at = 1, started_at = 1 WHERE id = ?") + .bind(&run_id) + .execute(db.pool()) + .await + .unwrap(); + + let response = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri("/api/development-operations/reconcile") + .header("content-type", "application/json") + .body(Body::from("{\"stale_after_ms\":10}")) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::OK); + assert_eq!(json(response).await["data"].as_array().unwrap().len(), 1); + + let response = app + .clone() + .oneshot( + Request::builder() + .uri(format!( + "/api/development-projects/project-1/operations?run_id={run_id}" + )) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::OK); + assert_eq!(json(response).await["data"]["recovery"].as_array().unwrap().len(), 1); + + let response = app + .oneshot( + Request::builder() + .method("POST") + .uri(format!("/api/development-runs/{run_id}/recovery")) + .header("content-type", "application/json") + .body(Body::from("{\"action\":\"terminate\"}")) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::OK); + assert_eq!(json(response).await["data"]["status_after"], "cancelled"); +} + +#[tokio::test] +async fn routes_create_and_read_a_development_board() { + let (app, _project, _db, _provider) = app().await; + let response = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri("/api/development-runs") + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "project_id": "project-1", + "execution_mode": "single", + "request_summary": "Implement feature", + "acceptance_criteria": ["tests pass"] + }) + .to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::CREATED); + let run_id = json(response).await["data"]["id"].as_str().unwrap().to_owned(); + + let response = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri(format!("/api/development-runs/{run_id}/tasks")) + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "subject": "Implement", + "acceptance_criteria": ["tests pass"], + "task_type": "implementation", + "risk_level": "medium" + }) + .to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::CREATED); + + let response = app + .oneshot( + Request::builder() + .uri(format!("/api/development-runs/{run_id}/tasks")) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::OK); + assert_eq!(json(response).await["data"].as_array().unwrap().len(), 1); +} + +#[tokio::test] +async fn timeline_merges_run_and_task_events_and_controls_are_server_validated() { + let (app, _project, db, _provider) = app().await; + let run = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri("/api/development-runs") + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "project_id": "project-1", + "execution_mode": "single", + "request_summary": "Timeline fixture", + "acceptance_criteria": ["events are correlated"] + }) + .to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + let run_id = json(run).await["data"]["id"].as_str().unwrap().to_owned(); + let task = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri(format!("/api/development-runs/{run_id}/tasks")) + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "subject": "Timeline task", + "blocked_by": [], + "acceptance_criteria": ["events are correlated"], + "task_type": "implementation", + "risk_level": "medium" + }) + .to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(task.status(), StatusCode::CREATED); + + let timeline = app + .clone() + .oneshot( + Request::builder() + .uri(format!("/api/development-runs/{run_id}/timeline")) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(timeline.status(), StatusCode::OK); + let body = json(timeline).await; + let events = body["data"]["events"].as_array().unwrap(); + assert!(events.iter().any(|event| event["kind"] == "run")); + assert!(events.iter().any(|event| event["kind"] == "task")); + assert_eq!(body["data"]["controls"]["allowed_run_actions"][0], "pause"); + + let paused = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri(format!("/api/development-runs/{run_id}/control")) + .header("content-type", "application/json") + .body(Body::from(r#"{"action":"pause","task_id":null,"target_slot_id":null}"#)) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(paused.status(), StatusCode::OK); + assert_eq!(json(paused).await["data"]["run_status"], "paused"); + + sqlx::query( + "INSERT INTO development_recovery_records \ + (id, user_id, project_id, run_id, recovery_key, finding, decision, status_before, status_after, details_json, created_at) \ + VALUES ('route-pending-recovery', 'system_default_user', 'project-1', ?, ?, 'stale run', 'retry', \ + 'paused', NULL, '{\"state\":\"pending\"}', 1)", + ) + .bind(&run_id) + .bind(format!("run:{run_id}:stale")) + .execute(db.pool()) + .await + .unwrap(); + let bypass = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri(format!("/api/development-runs/{run_id}/control")) + .header("content-type", "application/json") + .body(Body::from(r#"{"action":"retry","task_id":null,"target_slot_id":null}"#)) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(bypass.status(), StatusCode::CONFLICT); + let cancel_bypass = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri(format!("/api/development-runs/{run_id}/control")) + .header("content-type", "application/json") + .body(Body::from( + r#"{"action":"cancel","task_id":null,"target_slot_id":null}"#, + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(cancel_bypass.status(), StatusCode::CONFLICT); + + let rejected = app + .oneshot( + Request::builder() + .method("POST") + .uri(format!("/api/development-runs/{run_id}/control")) + .header("content-type", "application/json") + .body(Body::from(r#"{"action":"pause","task_id":null,"target_slot_id":null}"#)) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(rejected.status(), StatusCode::CONFLICT); +} + +#[tokio::test] +async fn user_reconcile_orphans_expired_resources_before_takeover() { + let (app, _project, db, _provider) = app().await; + let created = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri("/api/development-runs") + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "project_id": "project-1", + "execution_mode": "single", + "request_summary": "Recover expired resource", + "acceptance_criteria": ["resource is taken over"] + }) + .to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + let run_id = json(created).await["data"]["id"].as_str().unwrap().to_owned(); + sqlx::query("UPDATE development_runs SET status = 'paused', updated_at = 1 WHERE id = ?") + .bind(&run_id) + .execute(db.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO execution_resource_leases \ + (id, user_id, project_id, run_id, environment_id, environment_kind, resource_kind, resource_identifier, \ + status, accepts_work, owner_instance_id, heartbeat_at, expires_at, cleanup_order, created_at, updated_at) \ + VALUES ('route-expired-lease', 'system_default_user', 'project-1', ?, 'host:local', 'host', 'service', \ + 'route-service', 'active', 1, 'dead-instance', 1, 2, 30, 1, 1)", + ) + .bind(&run_id) + .execute(db.pool()) + .await + .unwrap(); + + let reconciled = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri("/api/development-operations/reconcile") + .header("content-type", "application/json") + .body(Body::from(r#"{"stale_after_ms":1}"#)) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(reconciled.status(), StatusCode::OK); + let lease_status: String = + sqlx::query_scalar("SELECT status FROM execution_resource_leases WHERE id = 'route-expired-lease'") + .fetch_one(db.pool()) + .await + .unwrap(); + assert_eq!(lease_status, "orphaned"); + + let takeover = app + .oneshot( + Request::builder() + .method("POST") + .uri(format!("/api/development-runs/{run_id}/recovery")) + .header("content-type", "application/json") + .body(Body::from(r#"{"action":"takeover"}"#)) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(takeover.status(), StatusCode::OK); + let owner: String = + sqlx::query_scalar("SELECT owner_instance_id FROM execution_resource_leases WHERE id = 'route-expired-lease'") + .fetch_one(db.pool()) + .await + .unwrap(); + assert_eq!(owner, "route-instance"); +} + +#[tokio::test] +async fn malformed_run_payload_is_rejected() { + let (app, _project, _db, _provider) = app().await; + let response = app + .oneshot( + Request::builder() + .method("POST") + .uri("/api/development-runs") + .header("content-type", "application/json") + .body(Body::from("{")) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::BAD_REQUEST); +} + +#[tokio::test] +async fn delivery_routes_prepare_and_require_confirmation_for_push() { + let (app, project, db, provider) = app().await; + let now = aionui_common::now_ms(); + let repo = SqliteDevelopmentRepository::new(db.pool().clone()); + repo.create_run(&aionui_db::models::DevelopmentRunRow { + id: "run-route-delivery".into(), + user_id: "system_default_user".into(), + project_id: "project-1".into(), + team_id: None, + source_channel: Some("webui".into()), + source_user_id: None, + execution_mode: "single".into(), + status: "reviewing".into(), + request_summary: "Ship route delivery".into(), + acceptance_criteria: r#"["tests pass"]"#.into(), + baseline_commit: Some(git(project.path(), &["rev-parse", "HEAD"])), + integration_branch: None, + started_at: Some(now), + finished_at: None, + created_at: now, + updated_at: now, + }) + .await + .unwrap(); + repo.create_task(&aionui_db::models::DevelopmentTaskRow { + id: "route-task".into(), + team_id: "run:run-route-delivery".into(), + run_id: Some("run-route-delivery".into()), + subject: "Implement".into(), + description: None, + status: "completed".into(), + owner: Some("agent".into()), + blocked_by: "[]".into(), + blocks: "[]".into(), + metadata: None, + acceptance_criteria: r#"["tests pass"]"#.into(), + task_type: "implementation".into(), + risk_level: "medium".into(), + assigned_workspace_lease_id: None, + review_status: "approved".into(), + verification_status: "passed".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + repo.create_gate(&aionui_db::models::QualityGateRunRow { + id: "route-gate".into(), + run_id: "run-route-delivery".into(), + task_id: None, + gate_type: "unit_test".into(), + command: "cargo test".into(), + working_directory: project.path().to_string_lossy().into_owned(), + exit_code: Some(0), + status: "passed".into(), + stdout_artifact_id: None, + stderr_artifact_id: None, + duration_ms: Some(1), + isolation_mode: "host".into(), + execution_id: Some("gate-route".into()), + required: true, + started_at: Some(1), + finished_at: Some(2), + created_at: 1, + }) + .await + .unwrap(); + std::fs::write(project.path().join("README.md"), "delivered\n").unwrap(); + + let prepared = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri("/api/development-runs/run-route-delivery/delivery/prepare") + .header("content-type", "application/json") + .body(Body::from(r#"{"message":"feat: deliver route"}"#)) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(prepared.status(), StatusCode::OK); + assert_ne!(json(prepared).await["data"]["branch"], "main"); + + let rejected = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri("/api/development-runs/run-route-delivery/delivery/push") + .header("content-type", "application/json") + .body(Body::from(r#"{"confirmed":false,"confirmation_count":0}"#)) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(rejected.status(), StatusCode::BAD_REQUEST); + assert_eq!(provider.pushes.load(Ordering::SeqCst), 0); + + let pushed = app + .clone() + .oneshot( + Request::builder() + .method("POST") + .uri("/api/development-runs/run-route-delivery/delivery/push") + .header("content-type", "application/json") + .body(Body::from(r#"{"confirmed":true,"confirmation_count":2}"#)) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(pushed.status(), StatusCode::OK); + assert_eq!(provider.pushes.load(Ordering::SeqCst), 1); + + let fetched = app + .oneshot( + Request::builder() + .uri("/api/development-runs/run-route-delivery/delivery") + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(fetched.status(), StatusCode::OK); + assert_eq!(json(fetched).await["data"]["push_status"], "pushed"); +} diff --git a/crates/aionui-development/tests/development_service.rs b/crates/aionui-development/tests/development_service.rs new file mode 100644 index 000000000..1fd4c39cf --- /dev/null +++ b/crates/aionui-development/tests/development_service.rs @@ -0,0 +1,495 @@ +use std::sync::Arc; + +use aionui_db::models::{ProjectCommandProfileRow, ProjectRow}; +use aionui_db::{ + IProjectRepository, SqliteAgentWorkspaceLeaseRepository, SqliteDevelopmentRepository, SqliteProjectRepository, + init_database_memory, +}; +use aionui_development::{ + CreateArtifactInput, CreateDevelopmentRunInput, CreateDevelopmentTaskInput, DevelopmentService, SubmitReviewInput, +}; +use sha2::{Digest, Sha256}; + +async fn setup(project_path: &str) -> (DevelopmentService, tempfile::TempDir) { + setup_with_command(project_path, "printf gate-ok", 10).await +} + +async fn setup_with_command( + project_path: &str, + unit_test_command: &str, + timeout_seconds: i64, +) -> (DevelopmentService, tempfile::TempDir) { + let db = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO users (id, username, password_hash, created_at, updated_at) \ + VALUES ('user-1', 'developer', '', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + let project_repo = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + project_repo + .create(&ProjectRow { + id: "project-1".into(), + user_id: "user-1".into(), + name: "Project".into(), + local_path: project_path.into(), + repository_url: None, + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + project_repo + .upsert_command_profile(&ProjectCommandProfileRow { + project_id: "project-1".into(), + install_command: None, + format_command: None, + lint_command: None, + typecheck_command: None, + unit_test_command: Some(unit_test_command.into()), + integration_test_command: None, + e2e_command: None, + build_command: None, + security_scan_command: None, + command_timeout_seconds: timeout_seconds, + updated_at: 1, + }) + .await + .unwrap(); + let artifacts = tempfile::tempdir().unwrap(); + let service = DevelopmentService::new( + Arc::new(SqliteDevelopmentRepository::new(db.pool().clone())), + project_repo, + Arc::new(SqliteAgentWorkspaceLeaseRepository::new(db.pool().clone())), + artifacts.path().to_path_buf(), + ); + (service, artifacts) +} + +#[tokio::test] +async fn create_run_and_task_are_owner_scoped() { + let project = tempfile::tempdir().unwrap(); + let (service, _artifacts) = setup(project.path().to_str().unwrap()).await; + let run = service + .create_run( + "user-1", + CreateDevelopmentRunInput { + project_id: "project-1".into(), + team_id: None, + source_channel: Some("webui".into()), + source_user_id: None, + execution_mode: "single".into(), + request_summary: "Fix issue".into(), + acceptance_criteria: vec!["unit tests pass".into()], + }, + ) + .await + .unwrap(); + assert!(service.get_run("other", &run.id).await.is_err()); + + let task = service + .create_task( + "user-1", + &run.id, + CreateDevelopmentTaskInput { + subject: "Implement fix".into(), + description: None, + owner: Some("implementer".into()), + blocked_by: vec![], + acceptance_criteria: vec!["unit tests pass".into()], + task_type: "implementation".into(), + risk_level: "medium".into(), + assigned_workspace_lease_id: None, + }, + ) + .await + .unwrap(); + assert_eq!(service.list_tasks("user-1", &run.id).await.unwrap()[0].id, task.id); +} + +#[tokio::test] +async fn configured_gate_runs_and_records_bounded_artifact() { + let project = tempfile::tempdir().unwrap(); + let (service, _artifacts) = setup(project.path().to_str().unwrap()).await; + let run = service + .create_run( + "user-1", + CreateDevelopmentRunInput { + project_id: "project-1".into(), + team_id: None, + source_channel: None, + source_user_id: None, + execution_mode: "single".into(), + request_summary: "Run test".into(), + acceptance_criteria: vec!["tests pass".into()], + }, + ) + .await + .unwrap(); + let gate = service + .execute_gate("user-1", &run.id, None, "unit_test", None, true) + .await + .unwrap(); + assert_eq!(gate.status, "passed"); + assert_eq!(gate.exit_code, Some(0)); + assert!(gate.stdout_artifact_id.is_some()); +} + +#[tokio::test] +async fn completion_is_rejected_without_required_evidence() { + let project = tempfile::tempdir().unwrap(); + let (service, _artifacts) = setup(project.path().to_str().unwrap()).await; + let run = service + .create_run( + "user-1", + CreateDevelopmentRunInput { + project_id: "project-1".into(), + team_id: None, + source_channel: None, + source_user_id: None, + execution_mode: "single".into(), + request_summary: "Implement".into(), + acceptance_criteria: vec!["works".into()], + }, + ) + .await + .unwrap(); + let task = service + .create_task( + "user-1", + &run.id, + CreateDevelopmentTaskInput { + subject: "Implement".into(), + description: None, + owner: None, + blocked_by: vec![], + acceptance_criteria: vec!["works".into()], + task_type: "implementation".into(), + risk_level: "high".into(), + assigned_workspace_lease_id: None, + }, + ) + .await + .unwrap(); + + let evaluation = service.evaluate_completion("user-1", &run.id, &task.id).await.unwrap(); + assert!(!evaluation.allowed); + assert!(evaluation.reasons.iter().any(|reason| reason.contains("gate"))); + assert!(service.complete_task("user-1", &run.id, &task.id).await.is_err()); +} + +#[tokio::test] +async fn completion_succeeds_with_gate_review_acceptance_and_commit_evidence() { + let project = tempfile::tempdir().unwrap(); + let (service, _artifacts) = setup(project.path().to_str().unwrap()).await; + let run = service + .create_run( + "user-1", + CreateDevelopmentRunInput { + project_id: "project-1".into(), + team_id: None, + source_channel: None, + source_user_id: None, + execution_mode: "single".into(), + request_summary: "Implement".into(), + acceptance_criteria: vec!["works".into()], + }, + ) + .await + .unwrap(); + let task = service + .create_task( + "user-1", + &run.id, + CreateDevelopmentTaskInput { + subject: "Implement".into(), + description: None, + owner: Some("implementer".into()), + blocked_by: vec![], + acceptance_criteria: vec!["works".into()], + task_type: "implementation".into(), + risk_level: "high".into(), + assigned_workspace_lease_id: None, + }, + ) + .await + .unwrap(); + service + .execute_gate("user-1", &run.id, Some(&task.id), "unit_test", None, true) + .await + .unwrap(); + let report_path = project.path().join("test-report.txt"); + std::fs::write(&report_path, b"tests passed").unwrap(); + let report_checksum = format!("sha256:{:x}", Sha256::digest(b"tests passed")); + for (artifact_type, value, checksum) in [ + ("test", report_path.to_string_lossy().into_owned(), report_checksum), + ("commit", "abc1234".into(), "sha256:verified".into()), + ] { + service + .create_artifact( + "user-1", + &run.id, + CreateArtifactInput { + task_id: Some(task.id.clone()), + artifact_type: artifact_type.into(), + path_or_uri: value, + checksum, + producer_agent_id: Some("implementer".into()), + metadata: None, + }, + ) + .await + .unwrap(); + } + service + .submit_review( + "user-1", + &run.id, + SubmitReviewInput { + task_id: task.id.clone(), + reviewer_agent_id: "reviewer".into(), + producer_agent_id: Some("implementer".into()), + findings: vec![], + approved: true, + }, + ) + .await + .unwrap(); + + assert!( + service + .evaluate_completion("user-1", &run.id, &task.id) + .await + .unwrap() + .allowed + ); + assert_eq!( + service.complete_task("user-1", &run.id, &task.id).await.unwrap().status, + "completed" + ); +} + +#[tokio::test] +async fn configured_reviewer_role_is_enforced_and_separated_from_implementer() { + let project = tempfile::tempdir().unwrap(); + let (service, _artifacts) = setup(project.path().to_str().unwrap()).await; + let run = service + .create_run( + "user-1", + CreateDevelopmentRunInput { + project_id: "project-1".into(), + team_id: None, + source_channel: None, + source_user_id: None, + execution_mode: "single".into(), + request_summary: "Review".into(), + acceptance_criteria: vec!["reviewed".into()], + }, + ) + .await + .unwrap(); + let task = service + .create_task( + "user-1", + &run.id, + CreateDevelopmentTaskInput { + subject: "Implement".into(), + description: None, + owner: Some("implementer".into()), + blocked_by: vec![], + acceptance_criteria: vec!["reviewed".into()], + task_type: "implementation".into(), + risk_level: "high".into(), + assigned_workspace_lease_id: None, + }, + ) + .await + .unwrap(); + service + .assign_role("user-1", &run.id, "tester", "tester") + .await + .unwrap(); + let review = || SubmitReviewInput { + task_id: task.id.clone(), + reviewer_agent_id: "reviewer".into(), + producer_agent_id: Some("implementer".into()), + findings: vec![], + approved: true, + }; + assert!(service.submit_review("user-1", &run.id, review()).await.is_err()); + service + .assign_role("user-1", &run.id, "reviewer", "reviewer") + .await + .unwrap(); + assert!(service.submit_review("user-1", &run.id, review()).await.is_ok()); +} + +#[tokio::test] +async fn gate_failure_timeout_and_output_bounds_are_persisted() { + let project = tempfile::tempdir().unwrap(); + let (failed_service, _artifacts) = + setup_with_command(project.path().to_str().unwrap(), "printf failure >&2; exit 7", 10).await; + let input = || CreateDevelopmentRunInput { + project_id: "project-1".into(), + team_id: None, + source_channel: None, + source_user_id: None, + execution_mode: "single".into(), + request_summary: "Verify".into(), + acceptance_criteria: vec!["verified".into()], + }; + let run = failed_service.create_run("user-1", input()).await.unwrap(); + let failed = failed_service + .execute_gate("user-1", &run.id, None, "unit_test", None, true) + .await + .unwrap(); + assert_eq!(failed.status, "failed"); + assert_eq!(failed.exit_code, Some(7)); + + let project = tempfile::tempdir().unwrap(); + let (timeout_service, _artifacts) = setup_with_command(project.path().to_str().unwrap(), "sleep 2", 1).await; + let run = timeout_service.create_run("user-1", input()).await.unwrap(); + let timed_out = timeout_service + .execute_gate("user-1", &run.id, None, "unit_test", None, true) + .await + .unwrap(); + assert_eq!(timed_out.status, "timed_out"); + + let project = tempfile::tempdir().unwrap(); + let (bounded_service, _artifacts) = + setup_with_command(project.path().to_str().unwrap(), "head -c 1100000 /dev/zero", 10).await; + let run = bounded_service.create_run("user-1", input()).await.unwrap(); + let gate = bounded_service + .execute_gate("user-1", &run.id, None, "unit_test", None, true) + .await + .unwrap(); + let stdout = bounded_service + .list_artifacts("user-1", &run.id, None) + .await + .unwrap() + .into_iter() + .find(|artifact| Some(&artifact.id) == gate.stdout_artifact_id.as_ref()) + .unwrap(); + assert_eq!(std::fs::metadata(stdout.path_or_uri).unwrap().len(), 1024 * 1024); +} + +#[tokio::test] +async fn artifact_registration_rejects_outside_paths_and_forged_checksums() { + let project = tempfile::tempdir().unwrap(); + let outside = tempfile::NamedTempFile::new().unwrap(); + let (service, _artifacts) = setup(project.path().to_str().unwrap()).await; + let run = service + .create_run( + "user-1", + CreateDevelopmentRunInput { + project_id: "project-1".into(), + team_id: None, + source_channel: None, + source_user_id: None, + execution_mode: "single".into(), + request_summary: "Evidence".into(), + acceptance_criteria: vec!["valid evidence".into()], + }, + ) + .await + .unwrap(); + let artifact = |path: String, checksum: &str| CreateArtifactInput { + task_id: None, + artifact_type: "test".into(), + path_or_uri: path, + checksum: checksum.into(), + producer_agent_id: None, + metadata: None, + }; + assert!( + service + .create_artifact( + "user-1", + &run.id, + artifact(outside.path().to_string_lossy().into_owned(), "sha256:forged"), + ) + .await + .is_err() + ); + let inside = project.path().join("report.txt"); + std::fs::write(&inside, b"passed").unwrap(); + assert!( + service + .create_artifact( + "user-1", + &run.id, + artifact(inside.to_string_lossy().into_owned(), "sha256:forged"), + ) + .await + .is_err() + ); +} + +#[tokio::test] +async fn task_state_machine_rejects_skips_and_completion_bypass() { + let project = tempfile::tempdir().unwrap(); + let (service, _artifacts) = setup(project.path().to_str().unwrap()).await; + let run = service + .create_run( + "user-1", + CreateDevelopmentRunInput { + project_id: "project-1".into(), + team_id: None, + source_channel: None, + source_user_id: None, + execution_mode: "single".into(), + request_summary: "State machine".into(), + acceptance_criteria: vec!["controlled".into()], + }, + ) + .await + .unwrap(); + let task = service + .create_task( + "user-1", + &run.id, + CreateDevelopmentTaskInput { + subject: "Implement".into(), + description: None, + owner: None, + blocked_by: vec![], + acceptance_criteria: vec!["controlled".into()], + task_type: "implementation".into(), + risk_level: "medium".into(), + assigned_workspace_lease_id: None, + }, + ) + .await + .unwrap(); + assert!( + service + .transition_task("user-1", &run.id, &task.id, "in_progress") + .await + .is_err() + ); + assert_eq!( + service + .transition_task("user-1", &run.id, &task.id, "claimed") + .await + .unwrap() + .status, + "claimed" + ); + assert_eq!( + service + .transition_task("user-1", &run.id, &task.id, "in_progress") + .await + .unwrap() + .status, + "in_progress" + ); + assert!( + service + .transition_task("user-1", &run.id, &task.id, "completed") + .await + .is_err() + ); +} diff --git a/crates/aionui-development/tests/executor.rs b/crates/aionui-development/tests/executor.rs new file mode 100644 index 000000000..3a809f75e --- /dev/null +++ b/crates/aionui-development/tests/executor.rs @@ -0,0 +1,197 @@ +use std::collections::BTreeMap; + +use aionui_db::models::{DevelopmentPolicyRow, ProjectRuntimeProfileRow}; +use aionui_development::{CommandExecutionInput, build_execution_plan, execute_command}; + +fn policy(mode: &str) -> DevelopmentPolicyRow { + DevelopmentPolicyRow { + id: "policy".into(), + user_id: "user".into(), + project_id: "project".into(), + isolation_mode: mode.into(), + container_image: (mode == "docker").then(|| "node:24-alpine".into()), + devcontainer_config_path: (mode == "devcontainer").then(|| ".devcontainer/devcontainer.json".into()), + container_cpu_millis: 750, + container_memory_mb: 1024, + container_pids_limit: 128, + network_mode: "none".into(), + allowed_secret_keys_json: "[\"NPM_TOKEN\",\"IGNORED_TOKEN\"]".into(), + allowed_commands_json: "[]".into(), + protected_paths_json: "[]".into(), + allowed_network_hosts_json: "[]".into(), + protected_branches_json: "[\"main\"]".into(), + dangerous_confirmation_count: 2, + max_duration_ms: 60_000, + max_parallel_agents: 2, + max_retries: 1, + max_cost_microunits: 0, + max_total_tokens: 0, + fallback_model: None, + alert_percent: 80, + over_limit_action: "pause".into(), + created_at: 1, + updated_at: 1, + } +} + +fn runtime() -> ProjectRuntimeProfileRow { + ProjectRuntimeProfileRow { + project_id: "project".into(), + environment_kind: "node".into(), + language: Some("typescript".into()), + package_manager: Some("bun".into()), + runtime_version: Some("24".into()), + env_keys: "[\"NPM_TOKEN\",\"PUBLIC_FLAG\"]".into(), + metadata: "{}".into(), + updated_at: 1, + } +} + +#[test] +fn host_plan_preserves_compatibility_without_container_arguments() { + let workspace = tempfile::tempdir().unwrap(); + let plan = build_execution_plan(&CommandExecutionInput { + execution_id: "gate-host", + run_id: "run-host", + command: "bun test", + working_directory: workspace.path(), + timeout_seconds: 30, + policy: &policy("host"), + runtime_profile: Some(&runtime()), + environment: BTreeMap::new(), + }) + .unwrap(); + assert_eq!(plan.isolation_mode, "host"); + assert_eq!(plan.steps.len(), 1); + assert!(matches!(plan.steps[0].program.as_str(), "sh" | "cmd")); + assert!(!plan.steps[0].args.iter().any(|arg| arg == "docker")); +} + +#[test] +fn docker_plan_is_unprivileged_bounded_and_passes_secrets_by_name() { + let workspace = tempfile::tempdir().unwrap(); + let environment = BTreeMap::from([ + ("NPM_TOKEN".into(), "do-not-put-this-in-args".into()), + ("IGNORED_TOKEN".into(), "not-in-runtime-allowlist".into()), + ("PUBLIC_FLAG".into(), "1".into()), + ]); + let plan = build_execution_plan(&CommandExecutionInput { + execution_id: "gate-docker", + run_id: "run-docker", + command: "bun test", + working_directory: workspace.path(), + timeout_seconds: 30, + policy: &policy("docker"), + runtime_profile: Some(&runtime()), + environment, + }) + .unwrap(); + let step = &plan.steps[0]; + assert_eq!(step.program, "docker"); + let joined = step.args.join(" "); + for required in [ + "run", + "--rm", + "--init", + "--cap-drop ALL", + "no-new-privileges", + "--pids-limit 128", + "--cpus 0.750", + "--memory 1024m", + "--network none", + "--env NPM_TOKEN", + "--workdir /workspace", + "node:24-alpine", + ] { + assert!(joined.contains(required), "missing Docker safety argument: {required}"); + } + assert!(!joined.contains("do-not-put-this-in-args")); + assert!(!joined.contains("IGNORED_TOKEN")); + assert!(!joined.contains("/var/run/docker.sock")); + assert_eq!(plan.cleanup.as_ref().unwrap().program, "docker"); +} + +#[test] +fn devcontainer_plan_uses_project_bound_config_and_never_embeds_secret_values() { + let workspace = tempfile::tempdir().unwrap(); + let config_dir = workspace.path().join(".devcontainer"); + std::fs::create_dir_all(&config_dir).unwrap(); + std::fs::write(config_dir.join("devcontainer.json"), "{}").unwrap(); + let plan = build_execution_plan(&CommandExecutionInput { + execution_id: "gate-devcontainer", + run_id: "run-devcontainer", + command: "bun test", + working_directory: workspace.path(), + timeout_seconds: 30, + policy: &policy("devcontainer"), + runtime_profile: Some(&runtime()), + environment: BTreeMap::from([("NPM_TOKEN".into(), "secret-value".into())]), + }) + .unwrap(); + assert_eq!(plan.steps.len(), 2); + assert!(plan.steps.iter().all(|step| step.program == "devcontainer")); + assert_eq!(plan.steps[0].args[0], "up"); + assert_eq!(plan.steps[1].args[0], "exec"); + assert!( + !plan + .steps + .iter() + .flat_map(|step| &step.args) + .any(|arg| arg.contains("secret-value")) + ); + + let mut escaping = policy("devcontainer"); + escaping.devcontainer_config_path = Some("../devcontainer.json".into()); + assert!( + build_execution_plan(&CommandExecutionInput { + execution_id: "escape", + run_id: "run", + command: "true", + working_directory: workspace.path(), + timeout_seconds: 30, + policy: &escaping, + runtime_profile: None, + environment: BTreeMap::new(), + }) + .is_err() + ); +} + +#[tokio::test] +async fn host_execution_redacts_configured_secrets_and_times_out() { + let workspace = tempfile::tempdir().unwrap(); + let environment = BTreeMap::from([("NPM_TOKEN".into(), "super-secret-value".into())]); + let passed = execute_command(CommandExecutionInput { + execution_id: "host-redaction", + run_id: "run-host", + command: "printf '%s' \"$NPM_TOKEN\"", + working_directory: workspace.path(), + timeout_seconds: 5, + policy: &policy("host"), + runtime_profile: Some(&runtime()), + environment: environment.clone(), + }) + .await + .unwrap(); + assert_eq!(passed.status, "passed"); + assert_eq!(passed.stdout, "[REDACTED]"); + + let timed_out = execute_command(CommandExecutionInput { + execution_id: "host-timeout", + run_id: "run-host", + command: if cfg!(windows) { + "ping -n 3 127.0.0.1" + } else { + "sleep 2" + }, + working_directory: workspace.path(), + timeout_seconds: 1, + policy: &policy("host"), + runtime_profile: None, + environment, + }) + .await + .unwrap(); + assert_eq!(timed_out.status, "timed_out"); + assert_eq!(timed_out.exit_code, None); +} diff --git a/crates/aionui-development/tests/export_import.rs b/crates/aionui-development/tests/export_import.rs new file mode 100644 index 000000000..e9b3716cd --- /dev/null +++ b/crates/aionui-development/tests/export_import.rs @@ -0,0 +1,889 @@ +use aionui_db::init_database_memory; +use aionui_development::{ + EvaluationComparisonRequest, EvaluationRecordInput, ImportProjectBundleRequest, PortabilityService, + RetentionCleanupRequest, RetentionPolicyInput, RetentionService, +}; + +async fn seed_source(pool: &aionui_db::SqlitePool) { + sqlx::query( + "INSERT INTO projects (id,user_id,name,local_path,repository_url,default_branch,project_type,created_at,updated_at) \ + VALUES ('project-export','system_default_user','Portable','/source/project','https://example.test/repo.git','main','single',1,1)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO project_command_profiles \ + (project_id,unit_test_command,command_timeout_seconds,updated_at) VALUES ('project-export','cargo test',900,1)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO conversations (id,user_id,name,type,extra,status,source,channel_chat_id,created_at,updated_at) \ + VALUES ('conversation-export','system_default_user','History','codex','{}','finished','telegram','chat-1',1,2)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO messages (id,conversation_id,type,content,position,status,created_at) \ + VALUES ('message-export','conversation-export','text','{\"text\":\"kept\"}','right','finish',2)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO teams (id,user_id,name,workspace,workspace_mode,agents,created_at,updated_at) \ + VALUES ('team-export','system_default_user','Portable Team','/source/project/packages/api','shared','[]',1,1)", + ) + .execute(pool) + .await + .unwrap(); + for (kind, id) in [("conversation", "conversation-export"), ("team", "team-export")] { + sqlx::query( + "INSERT INTO project_resource_links (project_id,user_id,resource_type,resource_id,created_at) \ + VALUES ('project-export','system_default_user',?,?,1)", + ) + .bind(kind) + .bind(id) + .execute(pool) + .await + .unwrap(); + } + sqlx::query( + "INSERT INTO assistant_users (id,platform_user_id,platform_type,authorized_at) \ + VALUES ('telegram-user','42','telegram',1)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO assistant_sessions \ + (id,user_id,agent_type,conversation_id,chat_id,message_thread_id,bound_agent_id,bound_backend,\ + bound_provider_id,bound_model,created_at,last_activity) \ + VALUES ('session-export','telegram-user','codex','conversation-export','chat-1',3,'codex-agent',\ + 'codex','provider-main','claude',1,1)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO channel_topic_model_overrides \ + (platform,internal_user_id,chat_id,message_thread_id,agent_id,provider_id,model,updated_at) \ + VALUES ('telegram','system_default_user','chat-1',3,'codex-agent','provider-main','claude',1)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO users (id,username,password_hash,created_at,updated_at) \ + VALUES ('other-source-user','other-source-user','disabled',1,1)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO channel_topic_model_overrides \ + (platform,internal_user_id,chat_id,message_thread_id,agent_id,provider_id,model,updated_at) \ + VALUES ('telegram','other-source-user','chat-1',3,'other-agent','other-provider','private-model',1)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO telegram_topic_bindings \ + (chat_id,message_thread_id,agent_id,bound_by_user_id,created_at,updated_at) \ + VALUES ('chat-1',3,'codex','42',1,1)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO development_policies \ + (id,user_id,project_id,isolation_mode,created_at,updated_at) \ + VALUES ('policy-export','system_default_user','project-export','host',1,1)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO development_retention_policies \ + (user_id,project_id,conversation_history_days,artifact_days,evaluation_days,immutable_audit_log,updated_at) \ + VALUES ('system_default_user','project-export',120,60,180,1,1)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO development_runs \ + (id,user_id,project_id,execution_mode,status,request_summary,acceptance_criteria,created_at,updated_at) \ + VALUES ('run-export','system_default_user','project-export','single','succeeded','Portable run','[]',1,2)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO development_deliveries \ + (id,run_id,project_id,user_id,branch,base_branch,status,created_at,updated_at) \ + VALUES ('delivery-export','run-export','project-export','system_default_user','feature','main','merged',1,2)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO development_audit_events \ + (id,user_id,actor_type,actor_id,action,target_type,target_id,project_id,run_id,result,redacted_payload_json,created_at) \ + VALUES ('audit-export','system_default_user','user','system_default_user','portable.test','run','run-export',\ + 'project-export','run-export','success','{}',2)", + ) + .execute(pool) + .await + .unwrap(); + sqlx::query( + "INSERT INTO development_secrets \ + (id,user_id,project_id,name,encrypted_value,status,created_at,updated_at) \ + VALUES ('secret-export','system_default_user','project-export','TOKEN','ciphertext-must-not-export','active',1,1)", + ) + .execute(pool) + .await + .unwrap(); +} + +#[tokio::test] +async fn signed_project_bundle_round_trips_with_owner_and_path_remapping_without_secrets() { + let source = init_database_memory().await.unwrap(); + seed_source(source.pool()).await; + let exporter = PortabilityService::new(source.pool().clone(), b"shared-portability-key", "source-instance"); + let bundle = exporter + .export_project("system_default_user", "project-export") + .await + .unwrap(); + + assert_eq!(bundle.manifest.format_version, 1); + assert!(!bundle.manifest.source_instance_id.is_empty()); + assert!(bundle.records.contains_key("conversations")); + assert!(bundle.records.contains_key("messages")); + assert!(bundle.records.contains_key("teams")); + assert!(bundle.records.contains_key("telegram_topic_bindings")); + assert_eq!(bundle.records["development_retention_policies"].len(), 1); + let encoded = serde_json::to_string(&bundle).unwrap(); + assert!(!encoded.contains("development_secrets")); + assert!(!encoded.contains("ciphertext-must-not-export")); + assert!(!encoded.contains("private-model")); + assert_eq!(bundle.records["channel_topic_model_overrides"].len(), 1); + exporter.validate_bundle(&bundle).unwrap(); + + let target = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO users (id, username, password_hash, created_at, updated_at) \ + VALUES ('restored-owner','restored-owner','disabled',1,1)", + ) + .execute(target.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO assistant_users (id,platform_user_id,platform_type,authorized_at) \ + VALUES ('target-telegram-user','42','telegram',1)", + ) + .execute(target.pool()) + .await + .unwrap(); + let mut importer = PortabilityService::new(target.pool().clone(), b"different-target-key", "target-instance"); + assert!( + importer + .validate_bundle(&bundle) + .unwrap_err() + .to_string() + .contains("not trusted") + ); + importer.trust_signer(&exporter.signer_public_key()).unwrap(); + let report = importer + .import_project( + "restored-owner", + ImportProjectBundleRequest { + bundle: bundle.clone(), + local_path: "/restored/project".into(), + }, + ) + .await + .unwrap(); + assert_eq!(report.project_id, "project-export"); + assert_eq!(report.owner_id, "restored-owner"); + assert!(report.imported); + assert!(report.conflicts.is_empty()); + + let restored_owner: String = sqlx::query_scalar("SELECT user_id FROM projects WHERE id='project-export'") + .fetch_one(target.pool()) + .await + .unwrap(); + let restored_path: String = sqlx::query_scalar("SELECT local_path FROM projects WHERE id='project-export'") + .fetch_one(target.pool()) + .await + .unwrap(); + assert_eq!(restored_owner, "restored-owner"); + assert_eq!(restored_path, "/restored/project"); + assert_eq!( + sqlx::query_scalar::<_, String>("SELECT workspace FROM teams WHERE id='team-export'") + .fetch_one(target.pool()) + .await + .unwrap(), + "/restored/project/packages/api" + ); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM messages WHERE id='message-export'") + .fetch_one(target.pool()) + .await + .unwrap(), + 1 + ); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM telegram_topic_bindings WHERE chat_id='chat-1'") + .fetch_one(target.pool()) + .await + .unwrap(), + 1 + ); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM development_audit_events WHERE id='audit-export'") + .fetch_one(target.pool()) + .await + .unwrap(), + 1 + ); + assert_eq!( + sqlx::query_scalar::<_, i64>( + "SELECT conversation_history_days FROM development_retention_policies \ + WHERE user_id='restored-owner' AND project_id='project-export'", + ) + .fetch_one(target.pool()) + .await + .unwrap(), + 120 + ); + assert_eq!( + sqlx::query_scalar::<_, i64>( + "SELECT COUNT(*) FROM assistant_sessions WHERE conversation_id='conversation-export' \ + AND user_id='target-telegram-user' AND chat_id='chat-1' AND message_thread_id=3", + ) + .fetch_one(target.pool()) + .await + .unwrap(), + 1 + ); + let restored_binding: (Option, Option, Option, Option) = sqlx::query_as( + "SELECT bound_agent_id,bound_backend,bound_provider_id,bound_model \ + FROM assistant_sessions WHERE id='session-export'", + ) + .fetch_one(target.pool()) + .await + .unwrap(); + assert_eq!( + restored_binding, + ( + Some("codex-agent".into()), + Some("codex".into()), + Some("provider-main".into()), + Some("claude".into()) + ) + ); + let reexported = importer + .export_project("restored-owner", "project-export") + .await + .unwrap(); + assert_eq!(reexported.records["assistant_sessions"].len(), 1); + assert_eq!(reexported.records["telegram_topic_bindings"].len(), 1); + assert_eq!( + reexported.records["assistant_sessions"][0]["bound_agent_id"], + "codex-agent" + ); + assert_eq!(reexported.records["assistant_sessions"][0]["bound_model"], "claude"); + + let conflict = importer + .import_project( + "restored-owner", + ImportProjectBundleRequest { + bundle, + local_path: "/restored/project".into(), + }, + ) + .await + .unwrap(); + assert!(!conflict.imported); + assert!(conflict.conflicts.iter().any(|item| item == "projects:project-export")); +} + +#[tokio::test] +async fn import_rejects_tampering_future_versions_path_traversal_and_rolls_back() { + let source = init_database_memory().await.unwrap(); + seed_source(source.pool()).await; + let exporter = PortabilityService::new(source.pool().clone(), b"shared-portability-key", "source-instance"); + let bundle = exporter + .export_project("system_default_user", "project-export") + .await + .unwrap(); + let target = init_database_memory().await.unwrap(); + let importer = PortabilityService::new(target.pool().clone(), b"shared-portability-key", "target-instance"); + + let mut tampered = bundle.clone(); + tampered.records.get_mut("projects").unwrap()[0]["name"] = "tampered".into(); + assert!( + importer + .validate_bundle(&tampered) + .unwrap_err() + .to_string() + .contains("checksum") + ); + + let mut tampered_manifest = bundle.clone(); + tampered_manifest.manifest.app_version = "forged-version".into(); + assert!( + importer + .validate_bundle(&tampered_manifest) + .unwrap_err() + .to_string() + .contains("signature") + ); + + let mut future = bundle.clone(); + future.manifest.format_version = 99; + assert!( + importer + .validate_bundle(&future) + .unwrap_err() + .to_string() + .contains("unsupported") + ); + + let traversal = importer + .import_project( + "system_default_user", + ImportProjectBundleRequest { + bundle: bundle.clone(), + local_path: "/restored/../escape".into(), + }, + ) + .await + .unwrap_err(); + assert!(traversal.to_string().contains("path traversal")); + + let mut invalid = bundle; + invalid.records.get_mut("development_deliveries").unwrap()[0]["run_id"] = "missing-run".into(); + exporter.seal_bundle(&mut invalid).unwrap(); + let error = importer + .import_project( + "system_default_user", + ImportProjectBundleRequest { + bundle: invalid, + local_path: "/restored/transaction".into(), + }, + ) + .await + .unwrap_err(); + assert!(error.to_string().contains("validation")); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM projects WHERE id='project-export'") + .fetch_one(target.pool()) + .await + .unwrap(), + 0 + ); + + let mut outside = exporter + .export_project("system_default_user", "project-export") + .await + .unwrap(); + outside.records.get_mut("teams").unwrap()[0]["workspace"] = "/unrelated/workspace".into(); + exporter.seal_bundle(&mut outside).unwrap(); + let error = importer + .import_project( + "system_default_user", + ImportProjectBundleRequest { + bundle: outside, + local_path: "/restored/project".into(), + }, + ) + .await + .unwrap_err(); + assert!(error.to_string().contains("outside source project")); +} + +#[tokio::test] +async fn platform_instance_is_stable_and_release_gate_detects_historical_regressions() { + let database = init_database_memory().await.unwrap(); + seed_source(database.pool()).await; + let service = PortabilityService::new(database.pool().clone(), b"evaluation-key", "runtime-instance"); + let first = service.platform_instance().await.unwrap(); + tokio::time::sleep(std::time::Duration::from_millis(2)).await; + let second = PortabilityService::new(database.pool().clone(), b"evaluation-key", "other-runtime") + .platform_instance() + .await + .unwrap(); + assert_eq!(first.instance_id, second.instance_id); + assert_eq!(first.last_started_at, second.last_started_at); + tokio::time::sleep(std::time::Duration::from_millis(2)).await; + service.record_startup().await.unwrap(); + let after_startup = service.platform_instance().await.unwrap(); + assert!(after_startup.last_started_at > second.last_started_at); + assert_eq!(first.schema_version, 34); + assert!(first.data_size_bytes > 0); + + service + .record_evaluation( + "system_default_user", + EvaluationRecordInput { + project_id: "project-export".into(), + release_id: "release-baseline".into(), + scenario_id: "codex-smoke".into(), + result: "passed".into(), + duration_ms: 1_000, + failure_category: None, + input_tokens: 100, + output_tokens: 50, + cost_microunits: 1_000, + cost_source: "provider".into(), + accepted_baseline: true, + }, + ) + .await + .unwrap(); + service + .record_evaluation( + "system_default_user", + EvaluationRecordInput { + project_id: "project-export".into(), + release_id: "release-current".into(), + scenario_id: "codex-smoke".into(), + result: "passed".into(), + duration_ms: 1_500, + failure_category: None, + input_tokens: 100, + output_tokens: 50, + cost_microunits: 1_400, + cost_source: "provider".into(), + accepted_baseline: false, + }, + ) + .await + .unwrap(); + + let comparison = service + .compare_evaluations( + "system_default_user", + EvaluationComparisonRequest { + project_id: "project-export".into(), + release_id: "release-current".into(), + required_scenarios: vec!["codex-smoke".into(), "claude-smoke".into()], + max_duration_regression_percent: 20, + max_cost_regression_percent: 20, + }, + ) + .await + .unwrap(); + assert!(!comparison.allowed); + assert!(comparison.regressions.iter().any(|item| item.category == "duration")); + assert!(comparison.regressions.iter().any(|item| item.category == "cost")); + assert!(comparison.regressions.iter().any(|item| item.category == "missing")); +} + +#[tokio::test] +async fn retention_policy_previews_and_requires_confirmation_before_project_scoped_cleanup() { + let database = init_database_memory().await.unwrap(); + seed_source(database.pool()).await; + let now = aionui_common::now_ms(); + let old = now - 400 * 24 * 60 * 60 * 1_000; + sqlx::query("UPDATE messages SET created_at=? WHERE id='message-export'") + .bind(now) + .execute(database.pool()) + .await + .unwrap(); + + sqlx::query( + "INSERT INTO messages (id,conversation_id,type,content,position,status,created_at) \ + VALUES ('message-old','conversation-export','text','{\"text\":\"expired\"}','right','finish',?)", + ) + .bind(old) + .execute(database.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO task_artifacts \ + (id,run_id,artifact_type,path_or_uri,checksum,created_at) \ + VALUES ('artifact-old','run-export','log','/source/project/.aion/old.log','sha256:old',?)", + ) + .bind(old) + .execute(database.pool()) + .await + .unwrap(); + for (id, baseline) in [("evaluation-old", 0), ("evaluation-baseline", 1)] { + sqlx::query( + "INSERT INTO development_evaluations \ + (id,user_id,project_id,release_id,scenario_id,result,duration_ms,input_tokens,output_tokens,\ + cost_microunits,cost_source,accepted_baseline,created_at) \ + VALUES (?,'system_default_user','project-export',?,'retention','passed',1,0,0,0,'test',?,?)", + ) + .bind(id) + .bind(id) + .bind(baseline) + .bind(old) + .execute(database.pool()) + .await + .unwrap(); + } + + let service = RetentionService::new(database.pool().clone()); + let policy = service + .update_policy( + "system_default_user", + "project-export", + RetentionPolicyInput { + conversation_history_days: 30, + artifact_days: 30, + evaluation_days: 30, + }, + ) + .await + .unwrap(); + assert!(policy.immutable_audit_log); + + let preview = service + .cleanup( + "system_default_user", + "project-export", + RetentionCleanupRequest { + dry_run: true, + confirmation_count: 0, + }, + ) + .await + .unwrap(); + assert_eq!(preview.message_count, 1); + assert_eq!(preview.artifact_count, 1); + assert_eq!(preview.evaluation_count, 1); + assert_eq!(preview.audit_events_retained, 1); + + let rejected = service + .cleanup( + "system_default_user", + "project-export", + RetentionCleanupRequest { + dry_run: false, + confirmation_count: 1, + }, + ) + .await + .unwrap_err(); + assert!(rejected.to_string().contains("confirmation")); + + let applied = service + .cleanup( + "system_default_user", + "project-export", + RetentionCleanupRequest { + dry_run: false, + confirmation_count: 2, + }, + ) + .await + .unwrap(); + assert!(!applied.dry_run); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM messages WHERE id IN ('message-old','message-export')",) + .fetch_one(database.pool()) + .await + .unwrap(), + 1 + ); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM development_evaluations WHERE scenario_id='retention'",) + .fetch_one(database.pool()) + .await + .unwrap(), + 1 + ); + assert_eq!( + sqlx::query_scalar::<_, i64>( + "SELECT COUNT(*) FROM development_audit_events WHERE project_id='project-export'", + ) + .fetch_one(database.pool()) + .await + .unwrap(), + 2 + ); + + let bundle = PortabilityService::new(database.pool().clone(), b"retention-key", "source-instance") + .export_project("system_default_user", "project-export") + .await + .unwrap(); + assert_eq!(bundle.records["development_retention_policies"].len(), 1); +} + +#[tokio::test] +async fn retention_policy_rejects_invalid_ranges_and_cross_owner_access() { + let database = init_database_memory().await.unwrap(); + seed_source(database.pool()).await; + let service = RetentionService::new(database.pool().clone()); + let invalid = service + .update_policy( + "system_default_user", + "project-export", + RetentionPolicyInput { + conversation_history_days: 0, + artifact_days: 30, + evaluation_days: 30, + }, + ) + .await + .unwrap_err(); + assert!(invalid.to_string().contains("between 1 and 3650")); + assert!( + service + .get_policy("other-user", "project-export") + .await + .unwrap_err() + .to_string() + .contains("project project-export") + ); +} + +#[tokio::test] +async fn import_reports_secondary_conflicts_before_writing_any_rows() { + let source = init_database_memory().await.unwrap(); + seed_source(source.pool()).await; + let exporter = PortabilityService::new(source.pool().clone(), b"source-key", "source-instance"); + let bundle = exporter + .export_project("system_default_user", "project-export") + .await + .unwrap(); + let target = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO conversations (id,user_id,name,type,extra,status,created_at,updated_at) \ + VALUES ('conversation-export','system_default_user','Conflict','codex','{}','finished',1,1)", + ) + .execute(target.pool()) + .await + .unwrap(); + let mut importer = PortabilityService::new(target.pool().clone(), b"target-key", "target-instance"); + importer.trust_signer(&exporter.signer_public_key()).unwrap(); + let report = importer + .import_project( + "system_default_user", + ImportProjectBundleRequest { + bundle, + local_path: "/restored/project".into(), + }, + ) + .await + .unwrap(); + assert!(!report.imported); + assert!( + report + .conflicts + .iter() + .any(|item| item == "conversations:conversation-export") + ); + assert!( + report + .conflicts + .iter() + .any(|item| item == "assistant_users:telegram:42:re_pair_required") + ); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM projects WHERE id='project-export'") + .fetch_one(target.pool()) + .await + .unwrap(), + 0 + ); +} + +#[tokio::test] +async fn import_preflights_logical_session_conflicts_and_duplicate_portable_keys() { + let source = init_database_memory().await.unwrap(); + seed_source(source.pool()).await; + let exporter = PortabilityService::new(source.pool().clone(), b"source-key", "source-instance"); + let bundle = exporter + .export_project("system_default_user", "project-export") + .await + .unwrap(); + let target = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO assistant_users (id,platform_user_id,platform_type,authorized_at) \ + VALUES ('target-user','42','telegram',1)", + ) + .execute(target.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO conversations (id,user_id,name,type,extra,status,created_at,updated_at) \ + VALUES ('target-conversation','system_default_user','Existing','codex','{}','finished',1,1)", + ) + .execute(target.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO assistant_sessions \ + (id,user_id,agent_type,conversation_id,chat_id,message_thread_id,created_at,last_activity) \ + VALUES ('target-session','target-user','codex','target-conversation','chat-1',3,1,1)", + ) + .execute(target.pool()) + .await + .unwrap(); + let mut importer = PortabilityService::new(target.pool().clone(), b"target-key", "target-instance"); + importer.trust_signer(&exporter.signer_public_key()).unwrap(); + let report = importer + .import_project( + "system_default_user", + ImportProjectBundleRequest { + bundle: bundle.clone(), + local_path: "/restored/project".into(), + }, + ) + .await + .unwrap(); + assert!(!report.imported); + assert!( + report + .conflicts + .iter() + .any(|item| item == "assistant_sessions:target-session") + ); + assert_eq!( + sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM projects WHERE id='project-export'") + .fetch_one(target.pool()) + .await + .unwrap(), + 0 + ); + + let mut duplicate = bundle; + let duplicate_profile = duplicate.records["project_command_profiles"][0].clone(); + duplicate + .records + .get_mut("project_command_profiles") + .unwrap() + .push(duplicate_profile); + exporter.seal_bundle(&mut duplicate).unwrap(); + let error = importer + .import_project( + "system_default_user", + ImportProjectBundleRequest { + bundle: duplicate, + local_path: "/restored/duplicate".into(), + }, + ) + .await + .unwrap_err(); + assert!(error.to_string().contains("duplicate project_command_profiles")); +} + +#[cfg(unix)] +#[tokio::test] +async fn import_rejects_existing_symbolic_links_in_remapped_workspace_path() { + let source = init_database_memory().await.unwrap(); + seed_source(source.pool()).await; + let exporter = PortabilityService::new(source.pool().clone(), b"source-key", "source-instance"); + let bundle = exporter + .export_project("system_default_user", "project-export") + .await + .unwrap(); + let target = init_database_memory().await.unwrap(); + let mut importer = PortabilityService::new(target.pool().clone(), b"target-key", "target-instance"); + importer.trust_signer(&exporter.signer_public_key()).unwrap(); + let directory = tempfile::tempdir().unwrap(); + let target_project = directory.path().join("project"); + let outside = directory.path().join("outside"); + std::fs::create_dir(&target_project).unwrap(); + std::fs::create_dir(&outside).unwrap(); + std::os::unix::fs::symlink(&outside, target_project.join("packages")).unwrap(); + + let error = importer + .import_project( + "system_default_user", + ImportProjectBundleRequest { + bundle, + local_path: target_project.to_string_lossy().into_owned(), + }, + ) + .await + .unwrap_err(); + assert!(error.to_string().contains("symbolic link")); +} + +#[tokio::test] +async fn evaluation_baseline_is_one_passing_release_and_never_mixes_scenarios() { + let database = init_database_memory().await.unwrap(); + seed_source(database.pool()).await; + let service = PortabilityService::new(database.pool().clone(), b"evaluation-key", "runtime-instance"); + let input = |release: &str, scenario: &str, result: &str, baseline: bool| EvaluationRecordInput { + project_id: "project-export".into(), + release_id: release.into(), + scenario_id: scenario.into(), + result: result.into(), + duration_ms: 100, + failure_category: None, + input_tokens: 1, + output_tokens: 1, + cost_microunits: 1, + cost_source: "test".into(), + accepted_baseline: baseline, + }; + service + .record_evaluation( + "system_default_user", + input("baseline-a", "codex-smoke", "passed", true), + ) + .await + .unwrap(); + service + .record_evaluation( + "system_default_user", + input("baseline-b", "claude-smoke", "passed", true), + ) + .await + .unwrap(); + service + .record_evaluation( + "system_default_user", + input("candidate", "codex-smoke", "passed", false), + ) + .await + .unwrap(); + service + .record_evaluation( + "system_default_user", + input("candidate", "claude-smoke", "passed", false), + ) + .await + .unwrap(); + let comparison = service + .compare_evaluations( + "system_default_user", + EvaluationComparisonRequest { + project_id: "project-export".into(), + release_id: "candidate".into(), + required_scenarios: vec!["codex-smoke".into(), "claude-smoke".into()], + max_duration_regression_percent: 20, + max_cost_regression_percent: 20, + }, + ) + .await + .unwrap(); + assert!(!comparison.allowed); + assert_eq!(comparison.baseline_release_ids, vec!["baseline-b"]); + assert!( + comparison + .regressions + .iter() + .any(|item| item.scenario_id == "codex-smoke" && item.category == "baseline_missing") + ); + + let rejected = service + .record_evaluation( + "system_default_user", + input("bad-baseline", "codex-smoke", "failed", true), + ) + .await + .unwrap_err(); + assert!(rejected.to_string().contains("passing evaluation")); +} diff --git a/crates/aionui-development/tests/github_delivery.rs b/crates/aionui-development/tests/github_delivery.rs new file mode 100644 index 000000000..a9136b9ed --- /dev/null +++ b/crates/aionui-development/tests/github_delivery.rs @@ -0,0 +1,138 @@ +use std::path::Path; +use std::sync::{Arc, Mutex}; + +use aionui_development::{ + DeliveryProvider, DeliveryProviderRegistry, DeliveryProviderSnapshot, ProviderCiCheck, ProviderPullRequest, + ProviderTag, +}; +use async_trait::async_trait; + +#[derive(Default)] +struct ContractProvider { + name: &'static str, + calls: Mutex>, + tags: Mutex>, +} + +impl ContractProvider { + fn named(name: &'static str) -> Self { + Self { + name, + ..Self::default() + } + } +} + +#[async_trait] +impl DeliveryProvider for ContractProvider { + fn name(&self) -> &'static str { + self.name + } + + async fn preflight(&self, _repository: &Path) -> Result<(), String> { + self.calls.lock().unwrap().push("preflight".into()); + Ok(()) + } + + async fn push(&self, _repository: &Path, branch: &str) -> Result<(), String> { + self.calls.lock().unwrap().push(format!("push:{branch}")); + Ok(()) + } + + async fn ensure_pull_request( + &self, + _repository: &Path, + head: &str, + base: &str, + _title: &str, + _body: &str, + ) -> Result { + self.calls.lock().unwrap().push(format!("change:{head}:{base}")); + Ok(ProviderPullRequest { + number: 17, + url: format!("https://{}.example/changes/17", self.name), + status: "open".into(), + review_status: "approved".into(), + }) + } + + async fn synchronize(&self, _repository: &Path, number: i64) -> Result { + self.calls.lock().unwrap().push(format!("sync:{number}")); + Ok(DeliveryProviderSnapshot { + pull_request: ProviderPullRequest { + number, + url: format!("https://{}.example/changes/{number}", self.name), + status: "open".into(), + review_status: "approved".into(), + }, + checks: vec![ProviderCiCheck { + id: "unit".into(), + name: "unit".into(), + status: "passed".into(), + details_url: None, + summary: None, + }], + review_comments: vec![], + }) + } + + async fn merge(&self, _repository: &Path, number: i64) -> Result<(), String> { + self.calls.lock().unwrap().push(format!("merge:{number}")); + Ok(()) + } + + async fn ensure_tag(&self, _repository: &Path, tag: &str, commit: &str) -> Result { + let mut tags = self.tags.lock().unwrap(); + if !tags.iter().any(|existing| existing.0 == tag) { + tags.push((tag.into(), commit.into())); + } + Ok(ProviderTag { + name: tag.into(), + commit_sha: commit.into(), + remote_url: Some(format!("https://{}.example/tags/{tag}", self.name)), + }) + } +} + +async fn assert_provider_contract(provider: Arc) { + let registry = DeliveryProviderRegistry::new(provider.clone()); + let selected = registry.get(provider.name()).unwrap(); + let repository = Path::new("."); + selected.preflight(repository).await.unwrap(); + selected.push(repository, "aion/run/contract").await.unwrap(); + let change = selected + .ensure_pull_request(repository, "aion/run/contract", "main", "Contract", "Evidence") + .await + .unwrap(); + let snapshot = selected.synchronize(repository, change.number).await.unwrap(); + assert_eq!(snapshot.checks[0].status, "passed"); + selected.merge(repository, change.number).await.unwrap(); + let first = selected.ensure_tag(repository, "v1.2.3", "abc123").await.unwrap(); + let second = selected.ensure_tag(repository, "v1.2.3", "abc123").await.unwrap(); + assert_eq!(first, second); + assert_eq!(provider.tags.lock().unwrap().len(), 1); +} + +#[tokio::test] +async fn github_implements_the_delivery_contract() { + assert_provider_contract(Arc::new(ContractProvider::named("github"))).await; +} + +#[test] +fn repository_urls_select_only_github() { + let registry = DeliveryProviderRegistry::new(Arc::new(ContractProvider::named("github"))); + + assert_eq!( + registry + .name_for_repository(Some("git@github.com:acme/app.git")) + .unwrap(), + "github" + ); + let unsupported = registry + .name_for_repository(Some("https://example.invalid/acme/app.git")) + .unwrap_err(); + assert_eq!( + unsupported.to_string(), + "Invalid development request: repository host is not a supported GitHub provider" + ); +} diff --git a/crates/aionui-development/tests/observed_agent_usage.rs b/crates/aionui-development/tests/observed_agent_usage.rs new file mode 100644 index 000000000..0d8c9b29a --- /dev/null +++ b/crates/aionui-development/tests/observed_agent_usage.rs @@ -0,0 +1,213 @@ +use std::sync::Arc; + +use aionui_common::now_ms; +use aionui_db::models::{DevelopmentRunRow, ProjectRow}; +use aionui_db::{ + IDevelopmentOperationsRepository, IDevelopmentRepository, IProjectRepository, SqliteAgentWorkspaceLeaseRepository, + SqliteDevelopmentOperationsRepository, SqliteDevelopmentRepository, SqliteProjectRepository, UsageDimension, + init_database_memory, +}; +use aionui_development::{ + DevelopmentOperationsService, DevelopmentPolicyInput, DevelopmentUsageIngestor, ObservedAgentTurnUsage, + PricingService, +}; +use serde_json::json; + +#[tokio::test] +async fn observed_agent_turn_is_idempotent_and_pauses_the_bound_run() { + let db = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO users (id, username, password_hash, created_at, updated_at) \ + VALUES ('usage-user', 'usage-user', '', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + + let workspace = tempfile::tempdir().unwrap(); + let project_repo = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + project_repo + .create(&ProjectRow { + id: "usage-project".into(), + user_id: "usage-user".into(), + name: "Usage".into(), + local_path: workspace.path().to_string_lossy().into_owned(), + repository_url: None, + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + project_repo + .bind_resource("usage-project", "usage-user", "conversation", "usage-conversation") + .await + .unwrap(); + + let development_repo = Arc::new(SqliteDevelopmentRepository::new(db.pool().clone())); + let started_at = now_ms(); + development_repo + .create_run(&DevelopmentRunRow { + id: "usage-run".into(), + user_id: "usage-user".into(), + project_id: "usage-project".into(), + team_id: None, + source_channel: None, + source_user_id: None, + execution_mode: "single".into(), + status: "running".into(), + request_summary: "observe usage".into(), + acceptance_criteria: "[]".into(), + baseline_commit: None, + integration_branch: None, + started_at: Some(started_at), + finished_at: None, + created_at: started_at, + updated_at: started_at, + }) + .await + .unwrap(); + + let operations_repo = Arc::new(SqliteDevelopmentOperationsRepository::new(db.pool().clone())); + let operations = DevelopmentOperationsService::new( + operations_repo.clone(), + development_repo.clone(), + project_repo.clone(), + Arc::new(SqliteAgentWorkspaceLeaseRepository::new(db.pool().clone())), + ); + operations + .upsert_policy( + "usage-user", + "usage-project", + DevelopmentPolicyInput { + isolation_mode: "host".into(), + container_image: None, + devcontainer_config_path: None, + container_cpu_millis: 1000, + container_memory_mb: 1024, + container_pids_limit: 128, + network_mode: "none".into(), + allowed_secret_keys: vec![], + allowed_commands: vec![], + protected_paths: vec![], + allowed_network_hosts: vec![], + protected_branches: vec!["main".into()], + dangerous_confirmation_count: 2, + max_duration_ms: 60_000, + max_parallel_agents: 1, + max_retries: 1, + max_cost_microunits: 0, + max_total_tokens: 100, + fallback_model: None, + alert_percent: 80, + over_limit_action: "pause".into(), + }, + ) + .await + .unwrap(); + + let ingestor = DevelopmentUsageIngestor::new( + project_repo, + development_repo.clone(), + operations_repo.clone(), + operations.clone(), + PricingService::new(operations_repo.clone()).with_budget(operations), + ); + let event = ObservedAgentTurnUsage { + user_id: "usage-user".into(), + conversation_id: "usage-conversation".into(), + turn_id: "turn-budget-1".into(), + agent_id: Some("codex-agent".into()), + provider: "openai".into(), + model: "gpt-test".into(), + team_id: None, + slot_id: None, + usage: Some(json!({ + "input_tokens": 120, + "output_tokens": 5, + "size": 258400, + "used": 120, + "cost": {"amount": 0.25, "currency": "USD"} + })), + duration_ms: 20, + retry_count: 0, + occurred_at: now_ms(), + }; + + let first = ingestor.record(event.clone()).await.unwrap().unwrap(); + assert!(first.inserted); + assert_eq!(first.row.input_tokens, 120); + assert_eq!(first.row.cost_microunits, 250_000); + assert_eq!(first.budget.as_ref().unwrap().action, "pause"); + assert!(!first.budget.as_ref().unwrap().reasons.is_empty()); + assert_eq!( + development_repo + .get_run("usage-run", "usage-user") + .await + .unwrap() + .unwrap() + .status, + "paused" + ); + let admission = ingestor + .admit("usage-user", "usage-conversation", None) + .await + .unwrap() + .unwrap(); + assert_eq!(admission.run_id, "usage-run"); + assert_eq!(admission.run_status, "paused"); + assert!(!admission.evaluation.reasons.is_empty()); + + let duplicate = ingestor.record(event).await.unwrap().unwrap(); + assert!(!duplicate.inserted); + assert_eq!(duplicate.budget.as_ref().unwrap().action, "pause"); + assert!(!duplicate.budget.as_ref().unwrap().reasons.is_empty()); + let summary = operations_repo + .summarize_usage_dimension("usage-user", &UsageDimension::Conversation("usage-conversation".into())) + .await + .unwrap(); + assert_eq!(summary.event_count, 1); + assert_eq!(summary.input_tokens, 120); + assert_eq!(summary.output_tokens, 5); +} + +#[tokio::test] +async fn unbound_conversation_usage_is_not_assigned_to_an_unrelated_project() { + let db = init_database_memory().await.unwrap(); + let project_repo = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + let development_repo = Arc::new(SqliteDevelopmentRepository::new(db.pool().clone())); + let operations_repo = Arc::new(SqliteDevelopmentOperationsRepository::new(db.pool().clone())); + let operations = DevelopmentOperationsService::new( + operations_repo.clone(), + development_repo.clone(), + project_repo.clone(), + Arc::new(SqliteAgentWorkspaceLeaseRepository::new(db.pool().clone())), + ); + let ingestor = DevelopmentUsageIngestor::new( + project_repo, + development_repo, + operations_repo.clone(), + operations, + PricingService::new(operations_repo), + ); + let result = ingestor + .record(ObservedAgentTurnUsage { + user_id: "nobody".into(), + conversation_id: "unbound".into(), + turn_id: "turn-unbound".into(), + agent_id: None, + provider: "unknown".into(), + model: "unknown".into(), + team_id: None, + slot_id: None, + usage: Some(json!({"used": 10})), + duration_ms: 1, + retry_count: 0, + occurred_at: now_ms(), + }) + .await + .unwrap(); + assert!(result.is_none()); + assert!(ingestor.admit("nobody", "unbound", None).await.unwrap().is_none()); +} diff --git a/crates/aionui-development/tests/operations_service.rs b/crates/aionui-development/tests/operations_service.rs new file mode 100644 index 000000000..1092a2b65 --- /dev/null +++ b/crates/aionui-development/tests/operations_service.rs @@ -0,0 +1,729 @@ +use std::sync::Arc; + +use aionui_common::now_ms; +use aionui_db::models::{ + DevelopmentRunRoleRow, DevelopmentRunRow, DevelopmentUsageEventRow, ProjectRow, QualityGateRunRow, +}; +use aionui_db::{ + IDevelopmentOperationsRepository, IDevelopmentRepository, IProjectRepository, SqliteAgentWorkspaceLeaseRepository, + SqliteDevelopmentOperationsRepository, SqliteDevelopmentRepository, SqliteProjectRepository, init_database_memory, +}; +use aionui_development::{ + DevelopmentOperationsService, DevelopmentPolicyInput, PolicyDecision, PolicyOperation, RecoveryDecisionInput, + ResourceLeaseCoordinator, ResourceLeaseInput, SystemDevelopmentResourceController, redact_sensitive, +}; + +struct Fixture { + service: DevelopmentOperationsService, + operations_repo: Arc, + development_repo: Arc, + _project: tempfile::TempDir, +} + +async fn setup(run_started_at: i64) -> Fixture { + let db = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO users (id, username, password_hash, created_at, updated_at) \ + VALUES ('user-ops', 'operations', '', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + let project = tempfile::tempdir().unwrap(); + git2::Repository::init(project.path()).unwrap(); + let project_repo = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + project_repo + .create(&ProjectRow { + id: "project-ops".into(), + user_id: "user-ops".into(), + name: "Operations".into(), + local_path: project.path().to_string_lossy().into_owned(), + repository_url: None, + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + let development_repo = Arc::new(SqliteDevelopmentRepository::new(db.pool().clone())); + development_repo + .create_run(&DevelopmentRunRow { + id: "run-ops".into(), + user_id: "user-ops".into(), + project_id: "project-ops".into(), + team_id: Some("team-ops".into()), + source_channel: None, + source_user_id: None, + execution_mode: "team".into(), + status: "running".into(), + request_summary: "Operate".into(), + acceptance_criteria: "[]".into(), + baseline_commit: None, + integration_branch: Some("aion/run/ops/integration".into()), + started_at: Some(run_started_at), + finished_at: None, + created_at: run_started_at, + updated_at: run_started_at, + }) + .await + .unwrap(); + let operations_repo = Arc::new(SqliteDevelopmentOperationsRepository::new(db.pool().clone())); + let service = DevelopmentOperationsService::new( + operations_repo.clone(), + development_repo.clone(), + project_repo, + Arc::new(SqliteAgentWorkspaceLeaseRepository::new(db.pool().clone())), + ) + .with_resources( + ResourceLeaseCoordinator::new(operations_repo.clone(), "instance-ops"), + Arc::new(SystemDevelopmentResourceController), + ); + Fixture { + service, + operations_repo, + development_repo, + _project: project, + } +} + +fn policy() -> DevelopmentPolicyInput { + DevelopmentPolicyInput { + isolation_mode: "docker".into(), + container_image: Some("node:24-alpine".into()), + devcontainer_config_path: None, + container_cpu_millis: 750, + container_memory_mb: 1024, + container_pids_limit: 128, + network_mode: "none".into(), + allowed_secret_keys: vec!["NPM_TOKEN".into()], + allowed_commands: vec![], + protected_paths: vec![], + allowed_network_hosts: vec![], + protected_branches: vec!["main".into()], + dangerous_confirmation_count: 2, + max_duration_ms: 60_000, + max_parallel_agents: 2, + max_retries: 1, + max_cost_microunits: 1_000, + max_total_tokens: 0, + fallback_model: None, + alert_percent: 80, + over_limit_action: "pause".into(), + } +} + +#[tokio::test] +async fn default_policy_is_safe_and_updates_store_secret_names_only() { + let fixture = setup(now_ms()).await; + let default = fixture.service.get_policy("user-ops", "project-ops").await.unwrap(); + assert_eq!(default.isolation_mode, "host"); + assert_eq!(default.over_limit_action, "pause"); + + let stored = fixture + .service + .upsert_policy("user-ops", "project-ops", policy()) + .await + .unwrap(); + assert_eq!(stored.allowed_secret_keys_json, "[\"NPM_TOKEN\"]"); + assert!(!stored.allowed_secret_keys_json.contains("secret")); + + let mut invalid = policy(); + invalid.allowed_secret_keys = vec!["NPM_TOKEN=secret".into()]; + assert!( + fixture + .service + .upsert_policy("user-ops", "project-ops", invalid) + .await + .is_err() + ); + assert!(fixture.service.get_policy("other", "project-ops").await.is_err()); +} + +#[tokio::test] +async fn budget_blocks_before_side_effect_and_deduplicates_alerts() { + let fixture = setup(now_ms()).await; + fixture + .service + .upsert_policy("user-ops", "project-ops", policy()) + .await + .unwrap(); + fixture + .operations_repo + .append_usage(&DevelopmentUsageEventRow { + id: "usage-over".into(), + user_id: "user-ops".into(), + project_id: "project-ops".into(), + run_id: Some("run-ops".into()), + task_id: None, + usage_type: "agent_turn".into(), + source: "provider".into(), + confidence: "reported".into(), + input_tokens: 100, + output_tokens: 50, + cost_microunits: 1_001, + duration_ms: 100, + retry_count: 0, + metadata_json: "{}".into(), + created_at: now_ms(), + }) + .await + .unwrap(); + + let first = fixture + .service + .evaluate_budget("user-ops", "run-ops", "quality_gate", 0) + .await + .unwrap(); + let second = fixture + .service + .evaluate_budget("user-ops", "run-ops", "quality_gate", 0) + .await + .unwrap(); + assert!(!first.allowed); + assert_eq!(first.action, "pause"); + assert!(first.reasons.iter().any(|reason| reason.contains("cost"))); + assert_eq!(second.reasons, first.reasons); + + let snapshot = fixture + .service + .snapshot("user-ops", "project-ops", Some("run-ops")) + .await + .unwrap(); + assert_eq!(snapshot.alerts.len(), 1); + assert!(snapshot.audit.iter().any(|event| event.result == "denied")); +} + +#[tokio::test] +async fn concurrency_and_retry_limits_are_evaluated_from_persisted_state() { + let fixture = setup(now_ms()).await; + let mut configured = policy(); + configured.max_parallel_agents = 1; + configured.max_retries = 0; + configured.max_cost_microunits = 0; + fixture + .service + .upsert_policy("user-ops", "project-ops", configured) + .await + .unwrap(); + fixture + .development_repo + .assign_role(&DevelopmentRunRoleRow { + run_id: "run-ops".into(), + slot_id: "slot-1".into(), + role: "implementer".into(), + assigned_at: 1, + }) + .await + .unwrap(); + + let parallel = fixture + .service + .evaluate_budget("user-ops", "run-ops", "assign_role", 0) + .await + .unwrap(); + let retry = fixture + .service + .evaluate_budget("user-ops", "run-ops", "quality_gate", 1) + .await + .unwrap(); + assert!(!parallel.allowed); + assert!(parallel.reasons.iter().any(|reason| reason.contains("parallel"))); + assert!(!retry.allowed); + assert!(retry.reasons.iter().any(|reason| reason.contains("retry"))); +} + +#[tokio::test] +async fn token_budget_returns_an_audited_model_downgrade_decision() { + let fixture = setup(now_ms()).await; + let mut configured = policy(); + configured.max_cost_microunits = 0; + configured.max_total_tokens = 100; + configured.over_limit_action = "downgrade_model".into(); + configured.fallback_model = Some("claude-haiku".into()); + configured.allowed_commands = vec!["cargo".into(), "bun".into()]; + configured.protected_paths = vec![".github/workflows".into()]; + configured.allowed_network_hosts = vec!["api.github.com".into()]; + configured.protected_branches = vec!["main".into()]; + configured.dangerous_confirmation_count = 2; + fixture + .service + .upsert_policy("user-ops", "project-ops", configured) + .await + .unwrap(); + fixture + .operations_repo + .append_usage(&DevelopmentUsageEventRow { + id: "usage-token-over".into(), + user_id: "user-ops".into(), + project_id: "project-ops".into(), + run_id: Some("run-ops".into()), + task_id: None, + usage_type: "agent_turn".into(), + source: "provider".into(), + confidence: "reported".into(), + input_tokens: 101, + output_tokens: 1, + cost_microunits: 0, + duration_ms: 1, + retry_count: 0, + metadata_json: "{}".into(), + created_at: now_ms(), + }) + .await + .unwrap(); + + let decision = fixture + .service + .evaluate_budget("user-ops", "run-ops", "agent_turn", 0) + .await + .unwrap(); + assert!(!decision.allowed); + assert_eq!(decision.action, "downgrade_model"); + assert_eq!(decision.replacement_model.as_deref(), Some("claude-haiku")); + assert!(decision.reasons.iter().any(|reason| reason.contains("token"))); + + let snapshot = fixture + .service + .snapshot("user-ops", "project-ops", Some("run-ops")) + .await + .unwrap(); + let audit = snapshot + .audit + .iter() + .find(|event| event.action == "budget.agent_turn") + .unwrap(); + assert!(audit.redacted_payload_json.contains("claude-haiku")); + assert!(audit.redacted_payload_json.contains("downgrade_model")); +} + +#[tokio::test] +async fn persisted_policy_decisions_are_owner_scoped_and_audited() { + let fixture = setup(now_ms()).await; + let mut configured = policy(); + configured.allowed_commands = vec!["cargo".into()]; + configured.allowed_network_hosts = vec!["api.github.com".into()]; + configured.protected_paths = vec![".env".into()]; + fixture + .service + .upsert_policy("user-ops", "project-ops", configured) + .await + .unwrap(); + + let allowed = fixture + .service + .evaluate_policy( + "user-ops", + "project-ops", + "run-ops", + &PolicyOperation::Command { + program: "cargo".into(), + }, + 0, + ) + .await + .unwrap(); + assert_eq!(allowed, PolicyDecision::Allowed); + let denied = fixture + .service + .evaluate_policy( + "user-ops", + "project-ops", + "run-ops", + &PolicyOperation::Network { + host: "evil.example".into(), + }, + 0, + ) + .await + .unwrap(); + assert!(matches!(denied, PolicyDecision::Denied { .. })); + assert!( + fixture + .service + .evaluate_policy( + "other", + "project-ops", + "run-ops", + &PolicyOperation::Command { + program: "cargo".into(), + }, + 0, + ) + .await + .is_err() + ); + + let snapshot = fixture + .service + .snapshot("user-ops", "project-ops", Some("run-ops")) + .await + .unwrap(); + assert!( + snapshot + .audit + .iter() + .any(|event| { event.action == "policy.command" && event.result == "success" }) + ); + assert!( + snapshot + .audit + .iter() + .any(|event| { event.action == "policy.network" && event.result == "denied" }) + ); +} + +#[tokio::test] +async fn pause_and_terminate_budget_actions_change_run_state() { + for (action, expected_status) in [("pause", "paused"), ("terminate", "cancelled")] { + let fixture = setup(now_ms()).await; + let mut configured = policy(); + configured.max_cost_microunits = 1; + configured.over_limit_action = action.into(); + fixture + .service + .upsert_policy("user-ops", "project-ops", configured) + .await + .unwrap(); + fixture + .service + .record_usage(DevelopmentUsageEventRow { + id: format!("usage-{action}"), + user_id: "user-ops".into(), + project_id: "project-ops".into(), + run_id: Some("run-ops".into()), + task_id: None, + usage_type: "agent_turn".into(), + source: "provider".into(), + confidence: "reported".into(), + input_tokens: 1, + output_tokens: 1, + cost_microunits: 2, + duration_ms: 1, + retry_count: 0, + metadata_json: "{}".into(), + created_at: now_ms(), + }) + .await + .unwrap(); + let run = fixture + .development_repo + .get_run("run-ops", "user-ops") + .await + .unwrap() + .unwrap(); + assert_eq!(run.status, expected_status); + assert_eq!(run.finished_at.is_some(), action == "terminate"); + } +} + +#[tokio::test] +async fn notify_budget_action_warns_without_blocking_or_changing_run_state() { + let fixture = setup(now_ms()).await; + let mut configured = policy(); + configured.max_cost_microunits = 1; + configured.over_limit_action = "notify".into(); + fixture + .service + .upsert_policy("user-ops", "project-ops", configured) + .await + .unwrap(); + fixture + .operations_repo + .append_usage(&DevelopmentUsageEventRow { + id: "usage-notify".into(), + user_id: "user-ops".into(), + project_id: "project-ops".into(), + run_id: Some("run-ops".into()), + task_id: None, + usage_type: "agent_turn".into(), + source: "provider".into(), + confidence: "reported".into(), + input_tokens: 1, + output_tokens: 1, + cost_microunits: 2, + duration_ms: 1, + retry_count: 0, + metadata_json: "{}".into(), + created_at: now_ms(), + }) + .await + .unwrap(); + + let evaluation = fixture + .service + .evaluate_budget("user-ops", "run-ops", "agent_turn", 0) + .await + .unwrap(); + assert!(evaluation.allowed); + assert_eq!(evaluation.action, "notify"); + assert_eq!( + fixture + .development_repo + .get_run("run-ops", "user-ops") + .await + .unwrap() + .unwrap() + .status, + "running" + ); +} + +#[test] +fn shared_redaction_removes_named_secrets_and_common_credentials() { + let redacted = redact_sensitive( + "Authorization bearer abc123 NPM_TOKEN=s3cr3t https://user:pass@example.com ghp_abcdefghijklmnop", + &["s3cr3t".into()], + ); + assert!(!redacted.contains("abc123")); + assert!(!redacted.contains("s3cr3t")); + assert!(!redacted.contains("user:pass")); + assert!(!redacted.contains("ghp_abcdefghijklmnop")); + assert!(redacted.contains("[REDACTED]")); +} + +#[tokio::test] +async fn recovery_scan_and_decisions_are_idempotent_and_audited() { + let fixture = setup(1).await; + fixture + .development_repo + .create_gate(&QualityGateRunRow { + id: "gate-interrupted".into(), + run_id: "run-ops".into(), + task_id: None, + gate_type: "unit_test".into(), + command: "sleep 100".into(), + working_directory: fixture._project.path().to_string_lossy().into_owned(), + exit_code: None, + status: "running".into(), + stdout_artifact_id: None, + stderr_artifact_id: None, + duration_ms: None, + isolation_mode: "host".into(), + execution_id: Some("gate-interrupted".into()), + required: true, + started_at: Some(1), + finished_at: None, + created_at: 1, + }) + .await + .unwrap(); + let first = fixture.service.reconcile_stale_runs(10).await.unwrap(); + let second = fixture.service.reconcile_stale_runs(10).await.unwrap(); + assert_eq!(first.len(), 1); + assert_eq!(second.len(), 1); + assert_eq!(first[0].id, second[0].id); + assert!(first[0].finding.contains("workspace lease")); + assert_eq!( + fixture.development_repo.list_gates("run-ops", None).await.unwrap()[0].status, + "interrupted" + ); + + let resumed = fixture + .service + .decide_recovery( + "user-ops", + "run-ops", + RecoveryDecisionInput { + action: "resume".into(), + }, + ) + .await + .unwrap(); + let resumed_again = fixture + .service + .decide_recovery( + "user-ops", + "run-ops", + RecoveryDecisionInput { + action: "resume".into(), + }, + ) + .await + .unwrap(); + assert_eq!(resumed.status_after.as_deref(), Some("running")); + assert_eq!(resumed.id, resumed_again.id); + + let snapshot = fixture + .service + .snapshot("user-ops", "project-ops", Some("run-ops")) + .await + .unwrap(); + assert_eq!(snapshot.recovery.len(), 1); + assert!(snapshot.audit.iter().any(|event| event.action == "recovery.resume")); +} + +#[tokio::test] +async fn recovery_rejects_healthy_and_succeeded_runs_but_allows_paused_runs() { + let fixture = setup(now_ms()).await; + let retry = RecoveryDecisionInput { action: "retry".into() }; + + assert!( + fixture + .service + .decide_recovery("user-ops", "run-ops", retry.clone()) + .await + .is_err() + ); + assert_eq!( + fixture + .development_repo + .get_run("run-ops", "user-ops") + .await + .unwrap() + .unwrap() + .status, + "running" + ); + + fixture + .development_repo + .update_run_status("run-ops", "user-ops", "succeeded", Some(now_ms())) + .await + .unwrap(); + assert!( + fixture + .service + .decide_recovery("user-ops", "run-ops", retry.clone()) + .await + .is_err() + ); + assert_eq!( + fixture + .development_repo + .get_run("run-ops", "user-ops") + .await + .unwrap() + .unwrap() + .status, + "succeeded" + ); + + fixture + .development_repo + .update_run_status("run-ops", "user-ops", "paused", None) + .await + .unwrap(); + let recovered = fixture + .service + .decide_recovery("user-ops", "run-ops", retry) + .await + .unwrap(); + assert_eq!(recovered.status_before.as_deref(), Some("paused")); + assert_eq!(recovered.status_after.as_deref(), Some("running")); +} + +#[tokio::test] +async fn conflicting_run_recovery_decisions_are_atomic_and_preserve_the_winner() { + let fixture = setup(now_ms()).await; + fixture + .development_repo + .update_run_status("run-ops", "user-ops", "paused", None) + .await + .unwrap(); + + let (retry_result, rollback_result) = tokio::join!( + fixture + .service + .decide_recovery("user-ops", "run-ops", RecoveryDecisionInput { action: "retry".into() },), + fixture.service.decide_recovery( + "user-ops", + "run-ops", + RecoveryDecisionInput { + action: "rollback".into(), + }, + ) + ); + assert_ne!(retry_result.is_ok(), rollback_result.is_ok()); + + let run = fixture + .development_repo + .get_run("run-ops", "user-ops") + .await + .unwrap() + .unwrap(); + let recovery = fixture + .service + .snapshot("user-ops", "project-ops", Some("run-ops")) + .await + .unwrap() + .recovery + .into_iter() + .find(|row| row.recovery_key == "run:run-ops:stale") + .unwrap(); + match recovery.decision.as_str() { + "retry" => assert_eq!(run.status, "running"), + "rollback" => assert_eq!(run.status, "cancelled"), + decision => panic!("unexpected recovery decision: {decision}"), + } +} + +#[tokio::test] +async fn failed_takeover_keeps_the_run_paused_and_same_action_can_retry() { + let fixture = setup(now_ms()).await; + fixture + .development_repo + .update_run_status("run-ops", "user-ops", "paused", None) + .await + .unwrap(); + let coordinator = ResourceLeaseCoordinator::new(fixture.operations_repo.clone(), "instance-ops"); + let mut lease = coordinator + .create(ResourceLeaseInput { + user_id: "user-ops".into(), + project_id: "project-ops".into(), + run_id: "run-ops".into(), + task_id: None, + turn_id: None, + gate_id: None, + environment_id: "host:local".into(), + environment_kind: "host".into(), + resource_kind: "service".into(), + resource_identifier: "recovery-service".into(), + cleanup_order: 30, + ttl_ms: 60_000, + }) + .await + .unwrap(); + + let decision = RecoveryDecisionInput { + action: "takeover".into(), + }; + assert!( + fixture + .service + .decide_recovery("user-ops", "run-ops", decision.clone()) + .await + .is_err() + ); + assert_eq!( + fixture + .development_repo + .get_run("run-ops", "user-ops") + .await + .unwrap() + .unwrap() + .status, + "paused" + ); + + lease.heartbeat_at = now_ms() - 120_000; + lease.expires_at = now_ms() - 60_000; + fixture.operations_repo.upsert_resource_lease(&lease).await.unwrap(); + coordinator.reconcile_stale(now_ms()).await.unwrap(); + let recovered = fixture + .service + .decide_recovery("user-ops", "run-ops", decision) + .await + .unwrap(); + assert_eq!(recovered.status_after.as_deref(), Some("running")); + assert_eq!( + fixture + .development_repo + .get_run("run-ops", "user-ops") + .await + .unwrap() + .unwrap() + .status, + "running" + ); +} diff --git a/crates/aionui-development/tests/pricing_budget.rs b/crates/aionui-development/tests/pricing_budget.rs new file mode 100644 index 000000000..45e4e09f0 --- /dev/null +++ b/crates/aionui-development/tests/pricing_budget.rs @@ -0,0 +1,144 @@ +use std::sync::Arc; + +use aionui_common::now_ms; +use aionui_db::models::ProjectRow; +use aionui_db::{ + IDevelopmentOperationsRepository, IProjectRepository, SqliteDevelopmentOperationsRepository, + SqliteProjectRepository, init_database_memory, +}; +use aionui_development::{ModelPriceInput, PricingService, UsageDimension, UsageMeasurement}; + +async fn setup() -> ( + PricingService, + Arc, + tempfile::TempDir, +) { + let db = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO users (id, username, password_hash, created_at, updated_at) VALUES ('user-price', 'pricing', '', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + let workspace = tempfile::tempdir().unwrap(); + let projects = SqliteProjectRepository::new(db.pool().clone()); + projects + .create(&ProjectRow { + id: "project-price".into(), + user_id: "user-price".into(), + name: "Pricing".into(), + local_path: workspace.path().to_string_lossy().into_owned(), + repository_url: None, + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + sqlx::query( + "INSERT INTO teams (id, user_id, name, workspace, created_at, updated_at) \ + VALUES ('team-1', 'user-price', 'Pricing Team', ?, 1, 1)", + ) + .bind(workspace.path().to_string_lossy().as_ref()) + .execute(db.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO development_runs \ + (id, user_id, project_id, team_id, execution_mode, status, request_summary, created_at, updated_at) \ + VALUES ('run-price', 'user-price', 'project-price', 'team-1', 'team', 'running', 'price', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO team_tasks (id, team_id, run_id, subject, created_at, updated_at) \ + VALUES ('task-price', 'team-1', 'run-price', 'Measure pricing', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + let repo = Arc::new(SqliteDevelopmentOperationsRepository::new(db.pool().clone())); + (PricingService::new(repo.clone()), repo, workspace) +} + +fn measurement(model: &str) -> UsageMeasurement { + UsageMeasurement { + user_id: "user-price".into(), + project_id: "project-price".into(), + conversation_id: Some("conversation-1".into()), + agent_id: Some("agent-1".into()), + task_id: Some("task-price".into()), + run_id: Some("run-price".into()), + team_id: Some("team-1".into()), + provider: "anthropic".into(), + model: model.into(), + input_tokens: 1_000_000, + output_tokens: 2_000_000, + cache_read_tokens: 1_000_000, + cache_write_tokens: 1_000_000, + duration_ms: 500, + retry_count: 0, + provider_reported_cost_microunits: None, + occurred_at: now_ms(), + } +} + +#[tokio::test] +async fn versioned_pricing_records_all_token_classes_and_cost_provenance() { + let (service, repo, _workspace) = setup().await; + service + .upsert_price(ModelPriceInput { + provider: "anthropic".into(), + model: "claude-test".into(), + input_per_million_microunits: 1_000, + output_per_million_microunits: 2_000, + cache_read_per_million_microunits: 100, + cache_write_per_million_microunits: 200, + source_id: "operator-catalog".into(), + version: "2026-07-20".into(), + effective_at: now_ms() - 1_000, + }) + .await + .unwrap(); + let event = service.record(measurement("claude-test")).await.unwrap(); + assert_eq!(event.cost_microunits, 5_300); + assert_eq!(event.cost_status, "known"); + assert_eq!(event.cost_origin, "platform_estimated"); + assert_eq!(event.price_source_id.as_deref(), Some("operator-catalog")); + assert_eq!(event.price_version.as_deref(), Some("2026-07-20")); + + for scope in [ + UsageDimension::Project("project-price".into()), + UsageDimension::Run("run-price".into()), + UsageDimension::Task("task-price".into()), + UsageDimension::Conversation("conversation-1".into()), + UsageDimension::Agent("agent-1".into()), + UsageDimension::Team("team-1".into()), + ] { + let summary = repo.summarize_usage_dimension("user-price", &scope).await.unwrap(); + assert_eq!(summary.event_count, 1); + assert_eq!(summary.cache_read_tokens, 1_000_000); + assert_eq!(summary.cache_write_tokens, 1_000_000); + assert_eq!(summary.known_cost_microunits, 5_300); + assert_eq!(summary.unknown_cost_events, 0); + } +} + +#[tokio::test] +async fn missing_prices_remain_unknown_and_provider_reported_cost_wins() { + let (service, _repo, _workspace) = setup().await; + let unknown = service.record(measurement("unpriced-model")).await.unwrap(); + assert_eq!(unknown.cost_status, "unknown"); + assert_eq!(unknown.cost_microunits, 0); + assert_eq!(unknown.cost_origin, "unknown"); + assert!(unknown.price_source_id.is_none()); + + let mut reported = measurement("unpriced-model"); + reported.provider_reported_cost_microunits = Some(9_999); + let reported = service.record(reported).await.unwrap(); + assert_eq!(reported.cost_status, "known"); + assert_eq!(reported.cost_microunits, 9_999); + assert_eq!(reported.cost_origin, "provider_reported"); +} diff --git a/crates/aionui-development/tests/requirements_service.rs b/crates/aionui-development/tests/requirements_service.rs new file mode 100644 index 000000000..bb1f55827 --- /dev/null +++ b/crates/aionui-development/tests/requirements_service.rs @@ -0,0 +1,208 @@ +use std::sync::Arc; + +use aionui_db::models::ProjectRow; +use aionui_db::{ + IProjectRepository, SqliteAgentWorkspaceLeaseRepository, SqliteDevelopmentRepository, SqliteProjectRepository, + init_database_memory, +}; +use aionui_development::{ + AppendPlanRevisionInput, CompletionEvidenceInput, CreateDevelopmentRunInput, CreateDevelopmentTaskInput, + DevelopmentService, +}; + +async fn setup() -> DevelopmentService { + let db = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO users (id, username, password_hash, created_at, updated_at) VALUES ('user-1', 'dev', '', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + let project_dir = tempfile::tempdir().unwrap().keep(); + let repo = git2::Repository::init(&project_dir).unwrap(); + std::fs::write(project_dir.join("README.md"), "baseline\n").unwrap(); + let mut index = repo.index().unwrap(); + index.add_path(std::path::Path::new("README.md")).unwrap(); + index.write().unwrap(); + let tree_id = index.write_tree().unwrap(); + let tree = repo.find_tree(tree_id).unwrap(); + let signature = git2::Signature::now("Aion", "aion@example.invalid").unwrap(); + repo.commit(Some("HEAD"), &signature, &signature, "baseline", &tree, &[]) + .unwrap(); + + let project_repo = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + project_repo + .create(&ProjectRow { + id: "project-1".into(), + user_id: "user-1".into(), + name: "Project".into(), + local_path: project_dir.to_string_lossy().into_owned(), + repository_url: None, + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + let artifact_root = tempfile::tempdir().unwrap().keep(); + DevelopmentService::new( + Arc::new(SqliteDevelopmentRepository::new(db.pool().clone())), + project_repo, + Arc::new(SqliteAgentWorkspaceLeaseRepository::new(db.pool().clone())), + artifact_root, + ) +} + +async fn create_run(service: &DevelopmentService) -> aionui_db::models::DevelopmentRunRow { + service + .create_run( + "user-1", + CreateDevelopmentRunInput { + project_id: "project-1".into(), + team_id: None, + source_channel: Some("webui".into()), + source_user_id: None, + execution_mode: "single".into(), + request_summary: "Implement immutable requirements".into(), + acceptance_criteria: vec!["requirements are immutable".into(), "tests prove completion".into()], + }, + ) + .await + .unwrap() +} + +#[tokio::test] +async fn requirement_versions_are_append_only_and_plan_revisions_are_monotonic() { + let service = setup().await; + let run = create_run(&service).await; + let original = service.requirements_snapshot("user-1", &run.id).await.unwrap(); + + service + .append_requirement_revision( + "user-1", + &run.id, + "Requirements and evidence are append-only", + "Clarify acceptance evidence", + vec![ + "requirements are immutable".into(), + "every criterion has accepted evidence".into(), + ], + ) + .await + .unwrap(); + let first_plan = service + .append_plan_revision( + "user-1", + &run.id, + AppendPlanRevisionInput { + summary: "Initial plan".into(), + content: "1. persist versions\n2. verify evidence".into(), + }, + ) + .await + .unwrap(); + let second_plan = service + .append_plan_revision( + "user-1", + &run.id, + AppendPlanRevisionInput { + summary: "Refined plan".into(), + content: "1. persist\n2. map\n3. verify".into(), + }, + ) + .await + .unwrap(); + + let snapshot = service.requirements_snapshot("user-1", &run.id).await.unwrap(); + assert_eq!(snapshot.original_requirement, original.original_requirement); + assert_eq!(snapshot.requirement_versions.len(), 2); + assert_eq!(first_plan.revision, 1); + assert_eq!(second_plan.revision, 2); + assert_eq!(snapshot.plan_revisions.len(), 2); +} + +#[tokio::test] +async fn tasks_must_map_owned_criteria_and_run_completion_requires_accepted_evidence() { + let service = setup().await; + let run = create_run(&service).await; + let snapshot = service.requirements_snapshot("user-1", &run.id).await.unwrap(); + let first = snapshot.active_criteria[0].clone(); + let second = snapshot.active_criteria[1].clone(); + + let unmapped = service + .create_task( + "user-1", + &run.id, + CreateDevelopmentTaskInput { + subject: "Unmapped".into(), + description: None, + owner: Some("codex".into()), + blocked_by: vec![], + acceptance_criteria: vec!["not owned by this run".into()], + task_type: "implementation".into(), + risk_level: "medium".into(), + assigned_workspace_lease_id: None, + }, + ) + .await; + assert!(unmapped.is_err()); + + let task = service + .create_task( + "user-1", + &run.id, + CreateDevelopmentTaskInput { + subject: "Implement".into(), + description: None, + owner: Some("codex".into()), + blocked_by: vec![], + acceptance_criteria: vec![first.statement.clone(), second.statement.clone()], + task_type: "implementation".into(), + risk_level: "medium".into(), + assigned_workspace_lease_id: None, + }, + ) + .await + .unwrap(); + assert!(service.complete_run("user-1", &run.id).await.is_err()); + + service + .record_completion_evidence( + "user-1", + &run.id, + &task.id, + CompletionEvidenceInput { + criterion_id: first.id.clone(), + evidence_type: "code".into(), + artifact_id: None, + reference: "commit:abc1234".into(), + accepted: true, + reviewer_id: Some("reviewer".into()), + }, + ) + .await + .unwrap(); + assert!(service.complete_run("user-1", &run.id).await.is_err()); + + service + .record_completion_evidence( + "user-1", + &run.id, + &task.id, + CompletionEvidenceInput { + criterion_id: second.id, + evidence_type: "test".into(), + artifact_id: None, + reference: "gate:unit_test".into(), + accepted: true, + reviewer_id: Some("reviewer".into()), + }, + ) + .await + .unwrap(); + let completed = service.complete_run("user-1", &run.id).await.unwrap(); + assert_eq!(completed.status, "succeeded"); + let final_snapshot = service.requirements_snapshot("user-1", &run.id).await.unwrap(); + assert!(final_snapshot.coverage.iter().all(|item| item.accepted)); +} diff --git a/crates/aionui-development/tests/restart_e2e.rs b/crates/aionui-development/tests/restart_e2e.rs new file mode 100644 index 000000000..8443320ad --- /dev/null +++ b/crates/aionui-development/tests/restart_e2e.rs @@ -0,0 +1,136 @@ +use std::sync::Arc; + +use aionui_common::now_ms; +use aionui_db::{IDevelopmentOperationsRepository, SqliteDevelopmentOperationsRepository, init_database}; +use aionui_development::{ResourceLeaseCoordinator, ResourceLeaseInput}; + +fn lease_input(kind: &str, identifier: &str, cleanup_order: i64) -> ResourceLeaseInput { + ResourceLeaseInput { + user_id: "system_default_user".into(), + project_id: "project-restart".into(), + run_id: "run-restart".into(), + task_id: Some("task-restart".into()), + turn_id: Some("turn-restart".into()), + gate_id: Some("gate-restart".into()), + environment_id: "host:local".into(), + environment_kind: "host".into(), + resource_kind: kind.into(), + resource_identifier: identifier.into(), + cleanup_order, + ttl_ms: 60_000, + } +} + +#[tokio::test] +async fn restored_instance_reconciles_once_and_persists_each_recovery_decision() { + let directory = tempfile::tempdir().unwrap(); + let database_path = directory.path().join("restart.sqlite3"); + + let database = init_database(&database_path).await.unwrap(); + sqlx::query( + "INSERT INTO projects (id, user_id, name, local_path, project_type, created_at, updated_at) \ + VALUES ('project-restart', 'system_default_user', 'Restart', '/tmp/restart', 'single', 1, 1)", + ) + .execute(database.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO development_runs \ + (id, user_id, project_id, execution_mode, status, request_summary, acceptance_criteria, created_at, updated_at) \ + VALUES ('run-restart', 'system_default_user', 'project-restart', 'single', 'running', 'Restart', '[]', 1, 1)", + ) + .execute(database.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO team_tasks \ + (id, team_id, run_id, subject, status, blocked_by, blocks, acceptance_criteria, task_type, risk_level, \ + review_status, verification_status, created_at, updated_at) \ + VALUES ('task-restart', 'team-restart', 'run-restart', 'Restart task', 'in_progress', '[]', '[]', '[]', \ + 'implementation', 'medium', 'pending', 'running', 1, 1)", + ) + .execute(database.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO quality_gate_runs \ + (id, run_id, task_id, gate_type, command, working_directory, status, required, started_at, created_at) \ + VALUES ('gate-restart', 'run-restart', 'task-restart', 'test', 'redacted', '/tmp/restart', 'running', 1, 1, 1)", + ) + .execute(database.pool()) + .await + .unwrap(); + + let first_repo = Arc::new(SqliteDevelopmentOperationsRepository::new(database.pool().clone())); + let first_instance = ResourceLeaseCoordinator::new(first_repo.clone(), "instance-before-restart"); + let mut lease_ids = Vec::new(); + for decision in ["retry", "rollback", "takeover", "terminate"] { + let mut lease = first_instance + .create(lease_input("process", &format!("child-{decision}"), 20)) + .await + .unwrap(); + lease.heartbeat_at = now_ms() - 120_000; + lease.expires_at = now_ms() - 60_000; + first_repo.upsert_resource_lease(&lease).await.unwrap(); + lease_ids.push((lease.id, decision)); + } + drop(first_instance); + drop(first_repo); + database.close().await; + + // Simulate a fresh application process: reopen the same SQLite file and + // recreate all repository/coordinator state with a new instance identity. + let restored_database = init_database(&database_path).await.unwrap(); + let restored_repo = Arc::new(SqliteDevelopmentOperationsRepository::new( + restored_database.pool().clone(), + )); + let restored_instance = ResourceLeaseCoordinator::new(restored_repo.clone(), "instance-after-restart"); + + let first_scan = restored_instance.reconcile_stale(now_ms()).await.unwrap(); + assert_eq!(first_scan.len(), 4); + assert!(first_scan.iter().all(|lease| lease.status == "orphaned")); + assert!(restored_instance.reconcile_stale(now_ms()).await.unwrap().is_empty()); + + for (lease_id, decision) in lease_ids { + let first = restored_instance + .record_recovery_decision(&lease_id, decision) + .await + .unwrap(); + let duplicate = restored_instance + .record_recovery_decision(&lease_id, decision) + .await + .unwrap(); + assert_eq!(first, duplicate); + assert_eq!(first.recovery_decision.as_deref(), Some(decision)); + } + + let (run_count, task_count, gate_count): (i64, i64, i64) = ( + sqlx::query_scalar("SELECT COUNT(*) FROM development_runs WHERE id = 'run-restart'") + .fetch_one(restored_database.pool()) + .await + .unwrap(), + sqlx::query_scalar("SELECT COUNT(*) FROM team_tasks WHERE id = 'task-restart'") + .fetch_one(restored_database.pool()) + .await + .unwrap(), + sqlx::query_scalar("SELECT COUNT(*) FROM quality_gate_runs WHERE id = 'gate-restart'") + .fetch_one(restored_database.pool()) + .await + .unwrap(), + ); + assert_eq!((run_count, task_count, gate_count), (1, 1, 1)); + + let leases = restored_repo + .list_resource_leases("system_default_user", "run-restart", false) + .await + .unwrap(); + assert_eq!(leases.len(), 4); + assert!(leases.iter().all(|lease| lease.recovery_decision.is_some())); + let takeover = leases + .iter() + .find(|lease| lease.recovery_decision.as_deref() == Some("takeover")) + .expect("takeover decision persisted"); + assert_eq!(takeover.owner_instance_id, "instance-after-restart"); + + restored_database.close().await; +} diff --git a/crates/aionui-development/tests/runner_recovery.rs b/crates/aionui-development/tests/runner_recovery.rs new file mode 100644 index 000000000..053aeec76 --- /dev/null +++ b/crates/aionui-development/tests/runner_recovery.rs @@ -0,0 +1,816 @@ +use std::sync::{Arc, Mutex}; + +use aionui_common::now_ms; +use aionui_db::{ + ExecutionResourceLeaseRow, IDevelopmentOperationsRepository, SqliteDevelopmentOperationsRepository, + SqliteProjectRepository, init_database_memory, +}; +use aionui_development::{ + CleanupTarget, CommandExecutionInput, DevelopmentResourceController, DevelopmentRunner, ResourceLeaseCoordinator, + ResourceLeaseInput, RunnerContext, SecretAccessContext, SecretCreateInput, SecretGrantInput, + SecretReferenceRequest, SecretService, SystemDevelopmentResourceController, default_policy, +}; +use async_trait::async_trait; +use tokio::sync::Notify; + +#[derive(Default)] +struct RecordingController { + calls: Mutex>, +} + +struct FailOnceController { + calls: Mutex>, + failed: Mutex, +} + +struct BlockingController { + started: Arc, + release: Arc, +} + +impl RecordingController { + fn record(&self, value: impl Into) { + self.calls.lock().unwrap().push(value.into()); + } +} + +#[async_trait] +impl DevelopmentResourceController for RecordingController { + async fn signal_agent(&self, run_id: &str) -> Result<(), String> { + self.record(format!("signal:{run_id}")); + Ok(()) + } + + async fn cleanup(&self, target: CleanupTarget<'_>) -> Result<(), String> { + self.record(format!("{}:{}", target.resource_kind, target.resource_identifier)); + Ok(()) + } +} + +#[async_trait] +impl DevelopmentResourceController for FailOnceController { + async fn signal_agent(&self, run_id: &str) -> Result<(), String> { + self.calls.lock().unwrap().push(format!("signal:{run_id}")); + Ok(()) + } + + async fn cleanup(&self, target: CleanupTarget<'_>) -> Result<(), String> { + self.calls + .lock() + .unwrap() + .push(format!("{}:{}", target.resource_kind, target.resource_identifier)); + let mut failed = self.failed.lock().unwrap(); + if !*failed { + *failed = true; + return Err("injected cleanup failure".into()); + } + Ok(()) + } +} + +#[async_trait] +impl DevelopmentResourceController for BlockingController { + async fn signal_agent(&self, _run_id: &str) -> Result<(), String> { + Ok(()) + } + + async fn cleanup(&self, _target: CleanupTarget<'_>) -> Result<(), String> { + self.started.notify_one(); + self.release.notified().await; + Ok(()) + } +} + +async fn setup() -> ( + ResourceLeaseCoordinator, + Arc, + aionui_db::Database, +) { + let db = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO projects (id, user_id, name, local_path, project_type, created_at, updated_at) \ + VALUES ('project-runner', 'system_default_user', 'Runner', '/tmp/runner', 'single', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO development_runs \ + (id, user_id, project_id, execution_mode, status, request_summary, acceptance_criteria, created_at, updated_at) \ + VALUES ('run-runner', 'system_default_user', 'project-runner', 'single', 'running', 'Run', '[]', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + let repo = Arc::new(SqliteDevelopmentOperationsRepository::new(db.pool().clone())); + (ResourceLeaseCoordinator::new(repo.clone(), "instance-a"), repo, db) +} + +fn input(kind: &str, identifier: &str, cleanup_order: i64) -> ResourceLeaseInput { + ResourceLeaseInput { + user_id: "system_default_user".into(), + project_id: "project-runner".into(), + run_id: "run-runner".into(), + task_id: Some("task-1".into()), + turn_id: Some("turn-1".into()), + gate_id: Some("gate-1".into()), + environment_id: "host:local".into(), + environment_kind: "host".into(), + resource_kind: kind.into(), + resource_identifier: identifier.into(), + cleanup_order, + ttl_ms: 60_000, + } +} + +#[tokio::test] +async fn managed_host_execution_persists_environment_and_terminal_process_evidence() { + let (coordinator, repo, db) = setup().await; + let runner = DevelopmentRunner::new(repo.clone(), coordinator, Arc::new(RecordingController::default())); + let workspace = tempfile::tempdir().unwrap(); + let policy = default_policy("system_default_user", "project-runner"); + let output = runner + .execute( + CommandExecutionInput { + execution_id: "gate-runner", + run_id: "run-runner", + command: "printf runner-ok", + working_directory: workspace.path(), + timeout_seconds: 5, + policy: &policy, + runtime_profile: None, + environment: Default::default(), + }, + &RunnerContext { + user_id: "system_default_user".into(), + project_id: "project-runner".into(), + run_id: "run-runner".into(), + task_id: None, + turn_id: Some("turn-runner".into()), + gate_id: Some("gate-runner".into()), + }, + ) + .await + .unwrap(); + assert_eq!(output.status, "passed"); + assert_eq!(output.stdout, "runner-ok"); + + let binding_count: i64 = + sqlx::query_scalar("SELECT COUNT(*) FROM execution_environment_bindings WHERE environment_id = 'host:local'") + .fetch_one(db.pool()) + .await + .unwrap(); + assert_eq!(binding_count, 3); + let leases = repo + .list_resource_leases("system_default_user", "run-runner", false) + .await + .unwrap(); + assert_eq!(leases.len(), 1); + assert_eq!(leases[0].resource_kind, "process"); + assert_eq!(leases[0].status, "released"); + assert_eq!(leases[0].cleanup_result.as_deref(), Some("passed")); +} + +#[tokio::test] +async fn runner_materializes_opaque_secret_references_only_for_the_leased_child() { + let (coordinator, repo, db) = setup().await; + let secrets = SecretService::new( + repo.clone(), + Arc::new(SqliteProjectRepository::new(db.pool().clone())), + Arc::new([9_u8; 32]), + ); + let secret = secrets + .create( + "system_default_user", + "project-runner", + SecretCreateInput { + name: "Runner token".into(), + value: "runner-plaintext-secret".into(), + expires_at: None, + }, + ) + .await + .unwrap(); + secrets + .grant( + "system_default_user", + SecretGrantInput { + secret_id: secret.id.clone(), + scope_type: "run".into(), + scope_id: "run-runner".into(), + environment_key: "RUNNER_TOKEN".into(), + expires_at: None, + }, + ) + .await + .unwrap(); + let runner = + DevelopmentRunner::new(repo, coordinator, Arc::new(RecordingController::default())).with_secrets(secrets); + let workspace = tempfile::tempdir().unwrap(); + let mut policy = default_policy("system_default_user", "project-runner"); + policy.allowed_secret_keys_json = "[\"RUNNER_TOKEN\"]".into(); + + let output = runner + .execute_with_secret_references( + CommandExecutionInput { + execution_id: "gate-secret", + run_id: "run-runner", + command: "printf %s \"$RUNNER_TOKEN\"", + working_directory: workspace.path(), + timeout_seconds: 5, + policy: &policy, + runtime_profile: None, + environment: Default::default(), + }, + &RunnerContext { + user_id: "system_default_user".into(), + project_id: "project-runner".into(), + run_id: "run-runner".into(), + task_id: None, + turn_id: Some("turn-secret".into()), + gate_id: Some("gate-secret".into()), + }, + &SecretAccessContext { + project_id: "project-runner".into(), + run_id: Some("run-runner".into()), + agent_id: None, + }, + &[SecretReferenceRequest { + secret_id: secret.id, + environment_key: "RUNNER_TOKEN".into(), + }], + ) + .await + .unwrap(); + assert_eq!(output.status, "passed"); + assert_eq!(output.stdout, "[REDACTED]"); + let serialized = serde_json::to_string(&output).unwrap(); + assert!(!serialized.contains("runner-plaintext-secret")); +} + +#[tokio::test] +async fn cancellation_uses_fixed_cleanup_order_and_is_idempotent() { + let (coordinator, repo, _db) = setup().await; + for item in [ + input("workspace", "workspace-1", 60), + input("port", "4173", 50), + input("service", "preview-1", 30), + input("container", "container-1", 40), + input("process", "4321", 20), + ] { + coordinator.create(item).await.unwrap(); + } + let controller = RecordingController::default(); + + coordinator + .cancel_run("system_default_user", "run-runner", &controller) + .await + .unwrap(); + coordinator + .cancel_run("system_default_user", "run-runner", &controller) + .await + .unwrap(); + + assert_eq!( + controller.calls.lock().unwrap().as_slice(), + [ + "signal:run-runner", + "process:4321", + "service:preview-1", + "container:container-1", + "port:4173", + "workspace:workspace-1", + ] + ); + let leases = repo + .list_resource_leases("system_default_user", "run-runner", false) + .await + .unwrap(); + assert_eq!(leases.len(), 5); + assert!( + leases + .iter() + .all(|lease| lease.status == "released" && lease.accepts_work == 0) + ); +} + +#[tokio::test] +async fn cancellation_retries_only_resources_whose_cleanup_failed() { + let (coordinator, repo, _db) = setup().await; + coordinator.create(input("process", "4321", 20)).await.unwrap(); + let controller = FailOnceController { + calls: Mutex::new(Vec::new()), + failed: Mutex::new(false), + }; + + assert!( + coordinator + .cancel_run("system_default_user", "run-runner", &controller) + .await + .is_err() + ); + coordinator + .cancel_run("system_default_user", "run-runner", &controller) + .await + .unwrap(); + + assert_eq!( + controller.calls.lock().unwrap().as_slice(), + ["signal:run-runner", "process:4321", "signal:run-runner", "process:4321",] + ); + let leases = repo + .list_resource_leases("system_default_user", "run-runner", false) + .await + .unwrap(); + assert_eq!(leases[0].status, "released"); + assert_eq!(leases[0].cleanup_status.as_deref(), Some("released")); +} + +#[tokio::test] +async fn stale_cleanup_cannot_terminalize_a_lease_after_takeover() { + let (coordinator, repo, _db) = setup().await; + let mut lease = coordinator + .create(input("service", "blocked-cleanup", 30)) + .await + .unwrap(); + lease.heartbeat_at = 1; + lease.expires_at = 2; + lease.updated_at = now_ms(); + repo.upsert_resource_lease(&lease).await.unwrap(); + + let controller = Arc::new(BlockingController { + started: Arc::new(Notify::new()), + release: Arc::new(Notify::new()), + }); + let cancel_coordinator = coordinator.clone(); + let cancel_controller = controller.clone(); + let cancellation = tokio::spawn(async move { + cancel_coordinator + .cancel_run("system_default_user", "run-runner", cancel_controller.as_ref()) + .await + }); + controller.started.notified().await; + + let stopping = repo.get_resource_lease(&lease.id).await.unwrap().unwrap(); + assert_eq!(stopping.status, "stopping"); + assert!(coordinator.complete(&lease, "late normal completion").await.is_err()); + let orphaned = coordinator.reconcile_stale(stopping.expires_at + 1).await.unwrap(); + assert_eq!(orphaned.len(), 1); + assert_eq!(orphaned[0].status, "orphaned"); + + let new_owner = ResourceLeaseCoordinator::new(repo.clone(), "instance-takeover"); + let taken_over = new_owner.record_recovery_decision(&lease.id, "takeover").await.unwrap(); + assert_eq!(taken_over.status, "active"); + assert_eq!(taken_over.owner_instance_id, "instance-takeover"); + + controller.release.notify_one(); + assert!(cancellation.await.unwrap().is_err()); + let persisted = repo.get_resource_lease(&lease.id).await.unwrap().unwrap(); + assert_eq!(persisted.owner_instance_id, "instance-takeover"); + assert_eq!(persisted.status, "active"); + assert_eq!(persisted.accepts_work, 1); + assert!(persisted.terminal_at.is_none()); +} + +#[tokio::test] +async fn cancellation_does_not_succeed_while_an_unclaimed_cleanup_is_in_progress() { + let (coordinator, repo, _db) = setup().await; + let mut lease = coordinator + .create(input("service", "already-stopping", 30)) + .await + .unwrap(); + lease.status = "stopping".into(); + lease.accepts_work = 0; + lease.updated_at = now_ms(); + repo.upsert_resource_lease(&lease).await.unwrap(); + + let result = coordinator + .cancel_run("system_default_user", "run-runner", &RecordingController::default()) + .await; + assert!(result.is_err()); + let persisted = repo.get_resource_lease(&lease.id).await.unwrap().unwrap(); + assert_eq!(persisted.status, "stopping"); + assert!(persisted.terminal_at.is_none()); +} + +#[tokio::test] +async fn stale_reconciliation_and_recovery_decisions_are_persisted_without_sensitive_payloads() { + let (coordinator, repo, _db) = setup().await; + let mut lease = coordinator.create(input("process", "9876", 20)).await.unwrap(); + lease.heartbeat_at = now_ms() - 120_000; + lease.expires_at = now_ms() - 60_000; + repo.upsert_resource_lease(&lease).await.unwrap(); + + let stale = coordinator.reconcile_stale(now_ms()).await.unwrap(); + assert_eq!(stale.len(), 1); + assert_eq!(stale[0].status, "orphaned"); + + for decision in ["retry", "rollback", "takeover", "terminate"] { + let id = format!("decision-{decision}"); + let mut row: ExecutionResourceLeaseRow = coordinator.create(input("service", &id, 30)).await.unwrap(); + if decision == "takeover" { + row.heartbeat_at = now_ms() - 120_000; + row.expires_at = now_ms() - 60_000; + repo.upsert_resource_lease(&row).await.unwrap(); + coordinator.reconcile_stale(now_ms()).await.unwrap(); + } + let first = coordinator.record_recovery_decision(&row.id, decision).await.unwrap(); + let second = coordinator.record_recovery_decision(&row.id, decision).await.unwrap(); + assert_eq!(first.recovery_decision.as_deref(), Some(decision)); + assert_eq!(first, second); + } + + let serialized = serde_json::to_string( + &repo + .list_resource_leases("system_default_user", "run-runner", false) + .await + .unwrap(), + ) + .unwrap(); + assert!(!serialized.contains("command")); + assert!(!serialized.contains("secret")); +} + +#[tokio::test] +async fn takeover_rejects_terminal_leases() { + let (coordinator, repo, _db) = setup().await; + let takeover = ResourceLeaseCoordinator::new(repo.clone(), "instance-takeover"); + for previously_taken_over in [false, true] { + let identifier = format!("terminal-takeover-{previously_taken_over}"); + let mut lease = coordinator.create(input("service", &identifier, 30)).await.unwrap(); + if previously_taken_over { + lease.heartbeat_at = now_ms() - 120_000; + lease.expires_at = now_ms() - 60_000; + repo.upsert_resource_lease(&lease).await.unwrap(); + coordinator.reconcile_stale(now_ms()).await.unwrap(); + lease = takeover.record_recovery_decision(&lease.id, "takeover").await.unwrap(); + takeover.complete(&lease, "done").await.unwrap(); + } else { + coordinator.complete(&lease, "done").await.unwrap(); + } + + let next_owner = ResourceLeaseCoordinator::new(repo.clone(), "instance-next"); + assert!( + next_owner + .record_recovery_decision(&lease.id, "takeover") + .await + .is_err() + ); + let persisted = repo.get_resource_lease(&lease.id).await.unwrap().unwrap(); + assert_eq!(persisted.status, "released"); + assert_eq!(persisted.accepts_work, 0); + assert!(persisted.terminal_at.is_some()); + } +} + +#[tokio::test] +async fn conflicting_resource_recovery_decisions_are_atomic_and_preserve_the_winner() { + let (coordinator, repo, _db) = setup().await; + let row = coordinator.create(input("service", "decision-race", 30)).await.unwrap(); + let takeover = ResourceLeaseCoordinator::new(repo.clone(), "instance-takeover"); + + let (rollback_result, takeover_result) = tokio::join!( + coordinator.record_recovery_decision(&row.id, "rollback"), + takeover.record_recovery_decision(&row.id, "takeover") + ); + assert_ne!(rollback_result.is_ok(), takeover_result.is_ok()); + + let persisted = repo.get_resource_lease(&row.id).await.unwrap().unwrap(); + match persisted.recovery_decision.as_deref() { + Some("rollback") => assert_eq!(persisted.owner_instance_id, "instance-a"), + Some("takeover") => assert_eq!(persisted.owner_instance_id, "instance-takeover"), + decision => panic!("unexpected recovery decision: {decision:?}"), + } +} + +#[tokio::test] +async fn concurrent_takeovers_allow_only_the_persisted_owner_to_succeed() { + let (original_owner, repo, _db) = setup().await; + let mut lease = original_owner + .create(input("service", "concurrent-takeover", 30)) + .await + .unwrap(); + lease.heartbeat_at = now_ms() - 120_000; + lease.expires_at = now_ms() - 60_000; + repo.upsert_resource_lease(&lease).await.unwrap(); + original_owner.reconcile_stale(now_ms()).await.unwrap(); + + let owner_b = ResourceLeaseCoordinator::new(repo.clone(), "instance-b"); + let owner_c = ResourceLeaseCoordinator::new(repo.clone(), "instance-c"); + let (result_b, result_c) = tokio::join!( + owner_b.record_recovery_decision(&lease.id, "takeover"), + owner_c.record_recovery_decision(&lease.id, "takeover") + ); + assert_ne!(result_b.is_ok(), result_c.is_ok()); + let persisted = repo.get_resource_lease(&lease.id).await.unwrap().unwrap(); + assert_eq!( + persisted.owner_instance_id, + if result_b.is_ok() { "instance-b" } else { "instance-c" } + ); + assert_eq!(persisted.status, "active"); + assert_eq!(persisted.accepts_work, 1); +} + +#[tokio::test] +async fn a_new_orphan_epoch_accepts_a_different_recovery_decision() { + let (original_owner, repo, _db) = setup().await; + let mut lease = original_owner + .create(input("service", "recovery-epoch", 30)) + .await + .unwrap(); + lease.heartbeat_at = now_ms() - 120_000; + lease.expires_at = now_ms() - 60_000; + repo.upsert_resource_lease(&lease).await.unwrap(); + original_owner.reconcile_stale(now_ms()).await.unwrap(); + + let takeover = ResourceLeaseCoordinator::new(repo.clone(), "instance-takeover"); + let mut active = takeover.record_recovery_decision(&lease.id, "takeover").await.unwrap(); + assert_eq!(active.recovery_decision.as_deref(), Some("takeover")); + active.heartbeat_at = now_ms() - 120_000; + active.expires_at = now_ms() - 60_000; + repo.upsert_resource_lease(&active).await.unwrap(); + let orphaned = takeover.reconcile_stale(now_ms()).await.unwrap(); + assert_eq!(orphaned.len(), 1); + assert_eq!(orphaned[0].status, "orphaned"); + assert_eq!(orphaned[0].recovery_decision, None); + + let terminated = takeover.record_recovery_decision(&lease.id, "terminate").await.unwrap(); + assert_eq!(terminated.recovery_decision.as_deref(), Some("terminate")); +} + +#[tokio::test] +async fn takeover_reactivates_an_orphaned_lease_and_fences_the_previous_owner() { + let (original_owner, repo, _db) = setup().await; + let mut lease = original_owner + .create(input("service", "takeover-fencing", 30)) + .await + .unwrap(); + lease.heartbeat_at = now_ms() - 120_000; + lease.expires_at = now_ms() - 60_000; + repo.upsert_resource_lease(&lease).await.unwrap(); + original_owner.reconcile_stale(now_ms()).await.unwrap(); + + let new_owner = ResourceLeaseCoordinator::new(repo.clone(), "instance-takeover"); + let mut taken_over = new_owner.record_recovery_decision(&lease.id, "takeover").await.unwrap(); + assert_eq!(taken_over.owner_instance_id, "instance-takeover"); + assert_eq!(taken_over.status, "active"); + assert_eq!(taken_over.accepts_work, 1); + assert!(taken_over.expires_at > taken_over.heartbeat_at); + + assert!(original_owner.heartbeat(&mut lease, 60_000).await.is_err()); + assert!(new_owner.heartbeat(&mut taken_over, 60_000).await.is_ok()); + + let mut second_loss = repo.get_resource_lease(&lease.id).await.unwrap().unwrap(); + second_loss.heartbeat_at = now_ms() - 120_000; + second_loss.expires_at = now_ms() - 60_000; + repo.upsert_resource_lease(&second_loss).await.unwrap(); + new_owner.reconcile_stale(now_ms()).await.unwrap(); + let third_owner = ResourceLeaseCoordinator::new(repo.clone(), "instance-third"); + let retaken = third_owner + .record_recovery_decision(&lease.id, "takeover") + .await + .unwrap(); + assert_eq!(retaken.owner_instance_id, "instance-third"); + assert_eq!(retaken.status, "active"); + assert_eq!(retaken.accepts_work, 1); + + assert!( + repo.heartbeat_resource_lease( + &lease.id, + "instance-takeover", + taken_over.updated_at, + now_ms(), + now_ms() + 60_000, + ) + .await + .unwrap() + .is_none() + ); + assert!( + !repo + .complete_resource_lease( + &lease.id, + "instance-takeover", + taken_over.updated_at, + "stale in-flight owner", + now_ms(), + ) + .await + .unwrap() + ); + assert!(original_owner.complete(&lease, "stale owner").await.is_err()); + assert!(new_owner.complete(&taken_over, "previous owner").await.is_err()); + assert_eq!( + third_owner.complete(&retaken, "new owner").await.unwrap().status, + "released" + ); +} + +#[tokio::test] +async fn same_instance_takeover_fences_the_old_execution_epoch() { + let (coordinator, repo, _db) = setup().await; + let mut old_epoch = coordinator + .create(input("service", "same-instance-epoch", 30)) + .await + .unwrap(); + old_epoch.heartbeat_at = now_ms() - 120_000; + old_epoch.expires_at = now_ms() - 60_000; + repo.upsert_resource_lease(&old_epoch).await.unwrap(); + coordinator.reconcile_stale(now_ms()).await.unwrap(); + + let mut new_epoch = coordinator + .record_recovery_decision(&old_epoch.id, "takeover") + .await + .unwrap(); + assert_eq!(new_epoch.owner_instance_id, old_epoch.owner_instance_id); + assert_ne!(new_epoch.updated_at, old_epoch.updated_at); + + assert!(coordinator.heartbeat(&mut old_epoch, 60_000).await.is_err()); + assert!(coordinator.complete(&old_epoch, "stale completion").await.is_err()); + assert!(coordinator.heartbeat(&mut new_epoch, 60_000).await.is_ok()); + assert_eq!( + coordinator + .complete(&new_epoch, "current completion") + .await + .unwrap() + .status, + "released" + ); +} + +async fn docker_container_ids(filter: &str) -> Vec { + let mut command = aionui_runtime::Builder::clean_cli("docker"); + command.args(["ps", "--all", "--quiet", "--filter", filter]); + let output = command + .output() + .await + .expect("Docker must be installed for live acceptance"); + assert!( + output.status.success(), + "Docker query failed: {}", + String::from_utf8_lossy(&output.stderr) + ); + String::from_utf8_lossy(&output.stdout) + .lines() + .map(str::trim) + .filter(|value| !value.is_empty()) + .map(str::to_owned) + .collect() +} + +#[tokio::test] +#[ignore = "requires a live Docker daemon and the alpine:3.20 image"] +async fn live_docker_runner_executes_redacts_and_removes_timed_out_containers() { + let (coordinator, repo, _db) = setup().await; + let runner = DevelopmentRunner::new(repo.clone(), coordinator, Arc::new(SystemDevelopmentResourceController)); + let workspace = tempfile::tempdir().unwrap(); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + std::fs::set_permissions(workspace.path(), std::fs::Permissions::from_mode(0o777)).unwrap(); + } + let mut policy = default_policy("system_default_user", "project-runner"); + policy.isolation_mode = "docker".into(); + policy.container_image = Some("alpine:3.20".into()); + policy.allowed_secret_keys_json = "[\"LIVE_SECRET\"]".into(); + let secret = "live-docker-secret-must-not-leak"; + + let output = runner + .execute( + CommandExecutionInput { + execution_id: "live-docker-success", + run_id: "run-runner", + command: "printf 'container-ok:%s' \"$LIVE_SECRET\"; printf artifact > result.txt", + working_directory: workspace.path(), + timeout_seconds: 15, + policy: &policy, + runtime_profile: None, + environment: [("LIVE_SECRET".into(), secret.into())].into(), + }, + &RunnerContext { + user_id: "system_default_user".into(), + project_id: "project-runner".into(), + run_id: "run-runner".into(), + task_id: Some("task-live-docker".into()), + turn_id: Some("turn-live-docker".into()), + gate_id: Some("gate-live-docker".into()), + }, + ) + .await + .unwrap(); + assert_eq!(output.status, "passed", "Docker runner stderr: {}", output.stderr); + assert_eq!(output.stdout, "container-ok:[REDACTED]"); + assert_eq!( + std::fs::read_to_string(workspace.path().join("result.txt")).unwrap(), + "artifact" + ); + assert!(!serde_json::to_string(&output).unwrap().contains(secret)); + assert!(docker_container_ids("name=aion-live-docker-success").await.is_empty()); + + let timed_out = runner + .execute( + CommandExecutionInput { + execution_id: "live-docker-timeout", + run_id: "run-runner", + command: "sleep 30", + working_directory: workspace.path(), + timeout_seconds: 1, + policy: &policy, + runtime_profile: None, + environment: Default::default(), + }, + &RunnerContext { + user_id: "system_default_user".into(), + project_id: "project-runner".into(), + run_id: "run-runner".into(), + task_id: Some("task-live-timeout".into()), + turn_id: Some("turn-live-timeout".into()), + gate_id: Some("gate-live-timeout".into()), + }, + ) + .await + .unwrap(); + assert_eq!(timed_out.status, "timed_out"); + assert!(docker_container_ids("name=aion-live-docker-timeout").await.is_empty()); + + let leases = repo + .list_resource_leases("system_default_user", "run-runner", false) + .await + .unwrap(); + assert!(leases.iter().all(|lease| lease.status == "released")); +} + +#[tokio::test] +#[ignore = "requires a live Docker daemon and the Dev Container CLI"] +async fn live_devcontainer_runner_executes_then_cancellation_removes_the_service() { + let (coordinator, repo, _db) = setup().await; + let runner = DevelopmentRunner::new( + repo.clone(), + coordinator.clone(), + Arc::new(SystemDevelopmentResourceController), + ); + let workspace = tempfile::tempdir().unwrap(); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + std::fs::set_permissions(workspace.path(), std::fs::Permissions::from_mode(0o777)).unwrap(); + } + let config_dir = workspace.path().join(".devcontainer"); + std::fs::create_dir_all(&config_dir).unwrap(); + std::fs::write( + config_dir.join("devcontainer.json"), + r#"{"image":"alpine:3.20","remoteUser":"root"}"#, + ) + .unwrap(); + let mut policy = default_policy("system_default_user", "project-runner"); + policy.isolation_mode = "devcontainer".into(); + policy.devcontainer_config_path = Some(".devcontainer/devcontainer.json".into()); + + let output = runner + .execute( + CommandExecutionInput { + execution_id: "live-devcontainer", + run_id: "run-runner", + command: "printf devcontainer-ok; printf artifact > result.txt", + working_directory: workspace.path(), + timeout_seconds: 60, + policy: &policy, + runtime_profile: None, + environment: Default::default(), + }, + &RunnerContext { + user_id: "system_default_user".into(), + project_id: "project-runner".into(), + run_id: "run-runner".into(), + task_id: Some("task-live-devcontainer".into()), + turn_id: Some("turn-live-devcontainer".into()), + gate_id: Some("gate-live-devcontainer".into()), + }, + ) + .await + .unwrap(); + assert_eq!(output.status, "passed"); + assert!(output.stdout.ends_with("devcontainer-ok")); + assert_eq!( + std::fs::read_to_string(workspace.path().join("result.txt")).unwrap(), + "artifact" + ); + + let folder_filter = format!("label=devcontainer.local_folder={}", workspace.path().display()); + assert_eq!(docker_container_ids(&folder_filter).await.len(), 1); + coordinator + .cancel_run( + "system_default_user", + "run-runner", + &SystemDevelopmentResourceController, + ) + .await + .unwrap(); + assert!(docker_container_ids(&folder_filter).await.is_empty()); + + let leases = repo + .list_resource_leases("system_default_user", "run-runner", false) + .await + .unwrap(); + assert!(leases.iter().all(|lease| lease.status == "released")); +} diff --git a/crates/aionui-development/tests/secrets_policy.rs b/crates/aionui-development/tests/secrets_policy.rs new file mode 100644 index 000000000..af656c520 --- /dev/null +++ b/crates/aionui-development/tests/secrets_policy.rs @@ -0,0 +1,313 @@ +use std::sync::Arc; + +use aionui_common::now_ms; +use aionui_db::models::ProjectRow; +use aionui_db::{ + IProjectRepository, SqliteDevelopmentOperationsRepository, SqliteProjectRepository, init_database_memory, +}; +use aionui_development::{ + DevelopmentPolicyRules, PolicyDecision, PolicyEngine, PolicyOperation, SecretAccessContext, SecretCreateInput, + SecretGrantInput, SecretRedactor, SecretReferenceRequest, SecretService, +}; + +async fn setup() -> (SecretService, aionui_db::Database, tempfile::TempDir) { + let db = init_database_memory().await.unwrap(); + for (id, name) in [("user-secret", "secret-owner"), ("user-other", "other-owner")] { + sqlx::query("INSERT INTO users (id, username, password_hash, created_at, updated_at) VALUES (?, ?, '', 1, 1)") + .bind(id) + .bind(name) + .execute(db.pool()) + .await + .unwrap(); + } + let workspace = tempfile::tempdir().unwrap(); + let projects = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + projects + .create(&ProjectRow { + id: "project-secret".into(), + user_id: "user-secret".into(), + name: "Secret Project".into(), + local_path: workspace.path().to_string_lossy().into_owned(), + repository_url: None, + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + let operations = Arc::new(SqliteDevelopmentOperationsRepository::new(db.pool().clone())); + ( + SecretService::new(operations, projects, Arc::new([7_u8; 32])), + db, + workspace, + ) +} + +#[tokio::test] +async fn secret_references_are_encrypted_owner_scoped_granted_and_revocable() { + let (service, db, _workspace) = setup().await; + let secret = service + .create( + "user-secret", + "project-secret", + SecretCreateInput { + name: "GitHub token".into(), + value: "ghp_plaintext_must_never_escape".into(), + expires_at: Some(now_ms() + 60_000), + }, + ) + .await + .unwrap(); + let public_json = serde_json::to_string(&secret).unwrap(); + assert!(!public_json.contains("plaintext")); + assert!(!public_json.contains("ciphertext")); + + let encrypted: String = sqlx::query_scalar("SELECT encrypted_value FROM development_secrets WHERE id = ?") + .bind(&secret.id) + .fetch_one(db.pool()) + .await + .unwrap(); + assert!(!encrypted.contains("ghp_plaintext_must_never_escape")); + + service + .grant( + "user-secret", + SecretGrantInput { + secret_id: secret.id.clone(), + scope_type: "run".into(), + scope_id: "run-allowed".into(), + environment_key: "GITHUB_TOKEN".into(), + expires_at: Some(now_ms() + 30_000), + }, + ) + .await + .unwrap(); + let materialized = service + .materialize( + "user-secret", + &SecretAccessContext { + project_id: "project-secret".into(), + run_id: Some("run-allowed".into()), + agent_id: Some("agent-a".into()), + }, + &[SecretReferenceRequest { + secret_id: secret.id.clone(), + environment_key: "GITHUB_TOKEN".into(), + }], + ) + .await + .unwrap(); + assert_eq!( + materialized.get("GITHUB_TOKEN"), + Some("ghp_plaintext_must_never_escape") + ); + assert!(!format!("{materialized:?}").contains("ghp_plaintext")); + + assert!( + service + .materialize( + "user-other", + &SecretAccessContext { + project_id: "project-secret".into(), + run_id: Some("run-allowed".into()), + agent_id: None, + }, + &[SecretReferenceRequest { + secret_id: secret.id.clone(), + environment_key: "GITHUB_TOKEN".into(), + }], + ) + .await + .is_err() + ); + assert!( + service + .materialize( + "user-secret", + &SecretAccessContext { + project_id: "project-secret".into(), + run_id: Some("run-denied".into()), + agent_id: None, + }, + &[SecretReferenceRequest { + secret_id: secret.id.clone(), + environment_key: "GITHUB_TOKEN".into(), + }], + ) + .await + .is_err() + ); + + service.revoke("user-secret", &secret.id).await.unwrap(); + assert!( + service + .materialize( + "user-secret", + &SecretAccessContext { + project_id: "project-secret".into(), + run_id: Some("run-allowed".into()), + agent_id: None, + }, + &[SecretReferenceRequest { + secret_id: secret.id, + environment_key: "GITHUB_TOKEN".into(), + }], + ) + .await + .is_err() + ); + + let audit: Vec<(String, String)> = sqlx::query_as( + "SELECT action, redacted_payload_json FROM development_audit_events \ + WHERE project_id = 'project-secret' ORDER BY created_at, id", + ) + .fetch_all(db.pool()) + .await + .unwrap(); + for action in ["secret.create", "secret.grant", "secret.materialize", "secret.revoke"] { + assert!( + audit.iter().any(|event| event.0 == action), + "missing audit action {action}" + ); + } + assert!( + audit + .iter() + .all(|event| !event.1.contains("ghp_plaintext_must_never_escape")) + ); +} + +#[tokio::test] +async fn expired_secrets_and_agent_grants_fail_closed() { + let (service, _db, _workspace) = setup().await; + let expired = service + .create( + "user-secret", + "project-secret", + SecretCreateInput { + name: "Expired".into(), + value: "expired-value".into(), + expires_at: Some(now_ms() - 1), + }, + ) + .await + .unwrap(); + service + .grant( + "user-secret", + SecretGrantInput { + secret_id: expired.id.clone(), + scope_type: "agent".into(), + scope_id: "agent-a".into(), + environment_key: "AGENT_TOKEN".into(), + expires_at: None, + }, + ) + .await + .unwrap(); + for agent_id in ["agent-a", "agent-b"] { + assert!( + service + .materialize( + "user-secret", + &SecretAccessContext { + project_id: "project-secret".into(), + run_id: None, + agent_id: Some(agent_id.into()), + }, + &[SecretReferenceRequest { + secret_id: expired.id.clone(), + environment_key: "AGENT_TOKEN".into(), + }], + ) + .await + .is_err() + ); + } +} + +#[test] +fn complete_policy_requires_exact_allowlists_and_double_confirmation_for_dangerous_actions() { + let rules = DevelopmentPolicyRules { + allowed_commands: vec!["cargo".into(), "bun".into()], + protected_paths: vec![".github/workflows".into(), ".env".into()], + allowed_network_hosts: vec!["api.github.com".into()], + protected_branches: vec!["main".into()], + dangerous_confirmation_count: 2, + }; + assert_eq!( + PolicyEngine::evaluate( + &rules, + &PolicyOperation::Command { + program: "cargo".into() + }, + 0 + ), + PolicyDecision::Allowed + ); + assert!(matches!( + PolicyEngine::evaluate(&rules, &PolicyOperation::Command { program: "bash".into() }, 0), + PolicyDecision::Denied { .. } + )); + assert!(matches!( + PolicyEngine::evaluate( + &rules, + &PolicyOperation::Path { + path: ".github/workflows/release.yml".into(), + write: true, + }, + 0, + ), + PolicyDecision::Denied { .. } + )); + assert_eq!( + PolicyEngine::evaluate( + &rules, + &PolicyOperation::Network { + host: "api.github.com".into(), + }, + 0, + ), + PolicyDecision::Allowed + ); + for operation in [ + PolicyOperation::Git { + operation: "push".into(), + branch: Some("main".into()), + }, + PolicyOperation::Deploy { + target: "production".into(), + }, + PolicyOperation::Delete { + path: "workspace".into(), + }, + ] { + assert_eq!( + PolicyEngine::evaluate(&rules, &operation, 1), + PolicyDecision::ConfirmationRequired { remaining: 1 } + ); + assert_eq!(PolicyEngine::evaluate(&rules, &operation, 2), PolicyDecision::Allowed); + } +} + +#[test] +fn one_redactor_covers_every_persisted_and_user_visible_boundary() { + let redactor = SecretRedactor::new(["ghp_secret_value".to_owned(), "database-password".to_owned()]); + for boundary in [ + "message", + "output", + "artifact", + "provider_error", + "audit", + "export", + "backup", + ] { + let redacted = redactor.redact_text(&format!( + "{boundary}: token=ghp_secret_value password=database-password https://user:database-password@example.test" + )); + assert!(!redacted.contains("ghp_secret_value")); + assert!(!redacted.contains("database-password")); + assert!(redacted.contains("[REDACTED]")); + } +} diff --git a/crates/aionui-development/tests/single_run_workspace.rs b/crates/aionui-development/tests/single_run_workspace.rs new file mode 100644 index 000000000..6d6dac33a --- /dev/null +++ b/crates/aionui-development/tests/single_run_workspace.rs @@ -0,0 +1,192 @@ +use std::sync::{Arc, Mutex}; + +use aionui_db::models::ProjectRow; +use aionui_db::{ + IDevelopmentRepository, IProjectRepository, SqliteAgentWorkspaceLeaseRepository, SqliteDevelopmentRepository, + SqliteProjectRepository, init_database_memory, +}; +use aionui_development::{ + CreateDevelopmentRunInput, DevelopmentService, DevelopmentWorkspacePort, PrepareDevelopmentWorkspace, + PreparedDevelopmentWorkspace, +}; + +#[derive(Default)] +struct RecordingWorkspacePort { + prepared: Mutex>, + restored: Mutex>, +} + +#[async_trait::async_trait] +impl DevelopmentWorkspacePort for RecordingWorkspacePort { + async fn prepare(&self, input: PrepareDevelopmentWorkspace) -> Result { + self.prepared.lock().unwrap().push(input.clone()); + Ok(PreparedDevelopmentWorkspace { + lease_id: "lease-1".into(), + workspace_path: "/managed/run-1".into(), + branch: "aion/run/run-1/agent".into(), + safe_point: input.baseline_commit, + }) + } + + async fn restore(&self, lease_id: &str, safe_point: &str) -> Result { + self.restored.lock().unwrap().push((lease_id.into(), safe_point.into())); + Ok("restored_and_released".into()) + } +} + +async fn setup() -> ( + DevelopmentService, + Arc, + Arc, + tempfile::TempDir, +) { + let db = init_database_memory().await.unwrap(); + sqlx::query( + "INSERT INTO users (id, username, password_hash, created_at, updated_at) VALUES ('user-1', 'dev', '', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + let project_dir = tempfile::tempdir().unwrap(); + let repo = git2::Repository::init(project_dir.path()).unwrap(); + std::fs::write(project_dir.path().join("tracked.txt"), "baseline\n").unwrap(); + let mut index = repo.index().unwrap(); + index.add_path(std::path::Path::new("tracked.txt")).unwrap(); + index.write().unwrap(); + let tree_id = index.write_tree().unwrap(); + let tree = repo.find_tree(tree_id).unwrap(); + let signature = git2::Signature::now("Aion", "aion@example.invalid").unwrap(); + repo.commit(Some("HEAD"), &signature, &signature, "baseline", &tree, &[]) + .unwrap(); + std::fs::write(project_dir.path().join("tracked.txt"), "user change\n").unwrap(); + std::fs::write(project_dir.path().join("untracked.txt"), "private draft\n").unwrap(); + + let project_repo = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + project_repo + .create(&ProjectRow { + id: "project-1".into(), + user_id: "user-1".into(), + name: "Project".into(), + local_path: project_dir.path().to_string_lossy().into_owned(), + repository_url: None, + default_branch: Some("main".into()), + project_type: "single".into(), + created_at: 1, + updated_at: 1, + }) + .await + .unwrap(); + let workspace = Arc::new(RecordingWorkspacePort::default()); + let development_repo = Arc::new(SqliteDevelopmentRepository::new(db.pool().clone())); + let service = DevelopmentService::new( + development_repo.clone(), + project_repo, + Arc::new(SqliteAgentWorkspaceLeaseRepository::new(db.pool().clone())), + tempfile::tempdir().unwrap().keep(), + ) + .with_workspace(workspace.clone()); + (service, workspace, development_repo, project_dir) +} + +#[tokio::test] +async fn single_run_captures_initial_user_diff_and_uses_an_isolated_workspace() { + let (service, port, _development_repo, project_dir) = setup().await; + let run = service + .create_run( + "user-1", + CreateDevelopmentRunInput { + project_id: "project-1".into(), + team_id: None, + source_channel: None, + source_user_id: None, + execution_mode: "single".into(), + request_summary: "Implement safely".into(), + acceptance_criteria: vec!["user changes survive".into()], + }, + ) + .await + .unwrap(); + + let workspace = service.prepare_single_workspace("user-1", &run.id).await.unwrap(); + assert_eq!(workspace.workspace_lease_id.as_deref(), Some("lease-1")); + assert!(workspace.initial_diff_checksum.starts_with("sha256:")); + assert!(std::path::Path::new(&workspace.initial_diff_path).is_file()); + assert_eq!(workspace.workspace_path.as_deref(), Some("/managed/run-1")); + assert_eq!( + std::fs::read_to_string(project_dir.path().join("tracked.txt")).unwrap(), + "user change\n" + ); + assert!(project_dir.path().join("untracked.txt").exists()); + assert_eq!(port.prepared.lock().unwrap().len(), 1); +} + +#[tokio::test] +async fn cancellation_restores_the_recorded_safe_point_and_persists_cleanup() { + let (service, port, _development_repo, _project_dir) = setup().await; + let run = service + .create_run( + "user-1", + CreateDevelopmentRunInput { + project_id: "project-1".into(), + team_id: None, + source_channel: None, + source_user_id: None, + execution_mode: "single".into(), + request_summary: "Cancel safely".into(), + acceptance_criteria: vec!["safe point restored".into()], + }, + ) + .await + .unwrap(); + let prepared = service.prepare_single_workspace("user-1", &run.id).await.unwrap(); + let cancelled = service.cancel_single_workspace("user-1", &run.id).await.unwrap(); + + assert_eq!(cancelled.cleanup_status, "restored_and_released"); + assert_eq!(cancelled.safe_point, prepared.safe_point); + assert_eq!( + port.restored.lock().unwrap().as_slice(), + &[("lease-1".into(), prepared.safe_point)] + ); + assert!(service.cancel_single_workspace("user-1", &run.id).await.is_err()); + assert_eq!(port.restored.lock().unwrap().len(), 1); +} + +#[tokio::test] +async fn cancellation_rejects_integrating_and_terminal_runs_before_restore() { + for status in ["integrating", "succeeded", "failed"] { + let (service, port, development_repo, _project_dir) = setup().await; + let run = service + .create_run( + "user-1", + CreateDevelopmentRunInput { + project_id: "project-1".into(), + team_id: None, + source_channel: None, + source_user_id: None, + execution_mode: "single".into(), + request_summary: format!("Reject cancellation from {status}"), + acceptance_criteria: vec!["workspace is untouched".into()], + }, + ) + .await + .unwrap(); + service.prepare_single_workspace("user-1", &run.id).await.unwrap(); + development_repo + .update_run_status(&run.id, "user-1", status, None) + .await + .unwrap(); + + assert!(service.cancel_single_workspace("user-1", &run.id).await.is_err()); + assert!(service.cancel_run("user-1", &run.id).await.is_err()); + assert!(port.restored.lock().unwrap().is_empty()); + assert_eq!( + development_repo + .get_run(&run.id, "user-1") + .await + .unwrap() + .unwrap() + .status, + status + ); + } +} diff --git a/crates/aionui-project/Cargo.toml b/crates/aionui-project/Cargo.toml new file mode 100644 index 000000000..7afe23f46 --- /dev/null +++ b/crates/aionui-project/Cargo.toml @@ -0,0 +1,28 @@ +[package] +name = "aionui-project" +version.workspace = true +edition.workspace = true +license.workspace = true + +[dependencies] +aionui-common.workspace = true +aionui-db.workspace = true +aionui-api-types.workspace = true +aionui-auth.workspace = true +aionui-runtime.workspace = true +async-trait.workspace = true +axum.workspace = true +git2.workspace = true +serde.workspace = true +serde_json.workspace = true +thiserror.workspace = true +tokio.workspace = true +uuid.workspace = true +which.workspace = true +walkdir.workspace = true + +[dev-dependencies] +http-body-util.workspace = true +sqlx.workspace = true +tempfile.workspace = true +tower = { workspace = true, features = ["util"] } diff --git a/crates/aionui-project/src/detection.rs b/crates/aionui-project/src/detection.rs new file mode 100644 index 000000000..5c3139e2a --- /dev/null +++ b/crates/aionui-project/src/detection.rs @@ -0,0 +1,194 @@ +use std::collections::BTreeSet; +use std::fs; +use std::path::{Component, Path}; + +use aionui_api_types::RepositorySubmodule; +use walkdir::{DirEntry, WalkDir}; + +use crate::ProjectError; + +#[derive(Debug, Default)] +pub(crate) struct DetectedProjectFacts { + pub languages: Vec, + pub package_managers: Vec, + pub rules_files: Vec, + pub monorepo_packages: Vec, + pub submodules: Vec, + pub lfs_detected: bool, +} + +pub(crate) fn detect_project(root: &Path) -> Result { + let mut languages = BTreeSet::new(); + let mut package_managers = BTreeSet::new(); + let mut rules_files = BTreeSet::new(); + let mut monorepo_packages = BTreeSet::new(); + let mut lfs_detected = false; + + for entry in WalkDir::new(root) + .follow_links(false) + .max_depth(8) + .into_iter() + .filter_entry(should_visit) + { + let entry = entry.map_err(|error| ProjectError::Internal(format!("repository scan failed: {error}")))?; + if !entry.file_type().is_file() { + continue; + } + let relative = entry + .path() + .strip_prefix(root) + .map_err(|error| ProjectError::Internal(error.to_string()))?; + let relative_text = relative.to_string_lossy().replace('\\', "/"); + let file_name = entry.file_name().to_string_lossy(); + detect_language(entry.path(), &mut languages); + detect_package_manager(&file_name, &mut package_managers); + if is_rules_file(&file_name) { + rules_files.insert(relative_text.clone()); + } + if is_package_manifest(&file_name) + && let Some(parent) = relative.parent().filter(|parent| !parent.as_os_str().is_empty()) + { + monorepo_packages.insert(parent.to_string_lossy().replace('\\', "/")); + } + if !lfs_detected && is_lfs_pointer(entry.path()) { + lfs_detected = true; + } + } + + let submodules = detect_submodules(root)?; + Ok(DetectedProjectFacts { + languages: languages.into_iter().collect(), + package_managers: package_managers.into_iter().collect(), + rules_files: rules_files.into_iter().collect(), + monorepo_packages: monorepo_packages.into_iter().collect(), + submodules, + lfs_detected, + }) +} + +fn should_visit(entry: &DirEntry) -> bool { + if entry.depth() == 0 { + return true; + } + !matches!( + entry.file_name().to_str(), + Some(".git" | "node_modules" | "target" | ".aion") + ) +} + +fn detect_language(path: &Path, output: &mut BTreeSet) { + let language = match path.extension().and_then(|value| value.to_str()) { + Some("rs") => Some("rust"), + Some("ts" | "tsx") => Some("typescript"), + Some("js" | "jsx" | "mjs" | "cjs") => Some("javascript"), + Some("py") => Some("python"), + Some("go") => Some("go"), + Some("java" | "kt" | "kts") => Some("jvm"), + Some("rb") => Some("ruby"), + Some("php") => Some("php"), + Some("cs") => Some("csharp"), + Some("swift") => Some("swift"), + Some("c" | "h" | "cc" | "cpp" | "hpp") => Some("cpp"), + _ => None, + }; + if let Some(language) = language { + output.insert(language.into()); + } +} + +fn detect_package_manager(file_name: &str, output: &mut BTreeSet) { + let manager = match file_name { + "Cargo.toml" => Some("cargo"), + "pnpm-lock.yaml" | "pnpm-workspace.yaml" => Some("pnpm"), + "yarn.lock" => Some("yarn"), + "bun.lock" | "bun.lockb" => Some("bun"), + "package-lock.json" => Some("npm"), + "go.mod" | "go.work" => Some("go"), + "uv.lock" | "pyproject.toml" => Some("python"), + "Gemfile" => Some("bundler"), + "pom.xml" => Some("maven"), + "build.gradle" | "build.gradle.kts" => Some("gradle"), + _ => None, + }; + if let Some(manager) = manager { + output.insert(manager.into()); + } +} + +fn is_rules_file(file_name: &str) -> bool { + matches!( + file_name, + "AGENTS.md" | "CLAUDE.md" | "CONTRIBUTING.md" | ".cursorrules" | ".editorconfig" + ) +} + +fn is_package_manifest(file_name: &str) -> bool { + matches!( + file_name, + "Cargo.toml" | "package.json" | "pyproject.toml" | "go.mod" | "pom.xml" + ) +} + +fn is_lfs_pointer(path: &Path) -> bool { + let Ok(metadata) = fs::metadata(path) else { + return false; + }; + if metadata.len() > 4096 { + return false; + } + fs::read_to_string(path) + .ok() + .is_some_and(|value| value.starts_with("version https://git-lfs.github.com/spec/v1\n")) +} + +fn detect_submodules(root: &Path) -> Result, ProjectError> { + let config_path = root.join(".gitmodules"); + if !config_path.is_file() { + return Ok(Vec::new()); + } + let source = fs::read_to_string(&config_path) + .map_err(|error| ProjectError::Internal(format!("failed to read .gitmodules: {error}")))?; + let mut output = Vec::new(); + let mut path = None; + let mut url = None; + let flush = |path: &mut Option, url: &mut Option, output: &mut Vec| { + if let Some(value) = path.take() { + let initialized = root.join(&value).join(".git").exists(); + output.push(RepositorySubmodule { + path: value, + url: url.take(), + initialized, + }); + } + }; + for line in source.lines().map(str::trim) { + if line.starts_with('[') { + flush(&mut path, &mut url, &mut output); + } else if let Some(value) = line + .strip_prefix("path") + .and_then(|line| line.split_once('=')) + .map(|(_, v)| v.trim()) + { + super::repository_source::validate_relative_path(value, "submodule path")?; + path = Some(value.replace('\\', "/")); + } else if let Some(value) = line + .strip_prefix("url") + .and_then(|line| line.split_once('=')) + .map(|(_, v)| v.trim()) + { + url = Some(value.to_owned()); + } + } + flush(&mut path, &mut url, &mut output); + output.sort_by(|left, right| left.path.cmp(&right.path)); + Ok(output) +} + +pub(crate) fn is_safe_relative_path(value: &str) -> bool { + let path = Path::new(value); + !value.trim().is_empty() + && !path.is_absolute() + && path + .components() + .all(|component| matches!(component, Component::Normal(_))) +} diff --git a/crates/aionui-project/src/error.rs b/crates/aionui-project/src/error.rs new file mode 100644 index 000000000..f2bcb7037 --- /dev/null +++ b/crates/aionui-project/src/error.rs @@ -0,0 +1,23 @@ +use aionui_db::DbError; + +#[derive(Debug, thiserror::Error)] +pub enum ProjectError { + #[error("Invalid project request: {0}")] + BadRequest(String), + #[error("Project resource not found: {0}")] + NotFound(String), + #[error("Project conflict: {0}")] + Conflict(String), + #[error("Project operation failed: {0}")] + Internal(String), +} + +impl From for ProjectError { + fn from(value: DbError) -> Self { + match value { + DbError::NotFound(message) => Self::NotFound(message), + DbError::Conflict(message) => Self::Conflict(message), + other => Self::Internal(other.to_string()), + } + } +} diff --git a/crates/aionui-project/src/knowledge.rs b/crates/aionui-project/src/knowledge.rs new file mode 100644 index 000000000..11a868017 --- /dev/null +++ b/crates/aionui-project/src/knowledge.rs @@ -0,0 +1,569 @@ +use std::collections::BTreeSet; +use std::path::{Component, Path}; +use std::time::Duration; + +use aionui_api_types::{ProjectKnowledgeFact, ProjectTaskContext}; +use aionui_runtime::Builder; +use serde_json::Value; + +const PROVIDER_TIMEOUT: Duration = Duration::from_secs(300); +const MAX_FACTS: usize = 500; +const MAX_CONTEXT_ITEMS: usize = 20; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum KnowledgeProviderError { + Unavailable, + Timeout, + MalformedOutput, + Rejected, +} + +impl KnowledgeProviderError { + pub fn category(&self) -> &'static str { + match self { + Self::Unavailable => "unavailable", + Self::Timeout => "timeout", + Self::MalformedOutput => "malformed_output", + Self::Rejected => "rejected", + } + } +} + +impl std::fmt::Display for KnowledgeProviderError { + fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "knowledge provider {}", self.category()) + } +} + +impl std::error::Error for KnowledgeProviderError {} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ProjectKnowledgeProviderHealth { + pub provider: String, + pub version: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ProjectKnowledgeProviderRequest { + pub project_path: String, + pub provider_project_name: String, + pub source_commit: Option, + pub changed_paths: Vec, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ProjectKnowledgeProviderResult { + pub provider_project_name: String, + pub source_commit: Option, + pub changed_paths: Vec, + pub facts: Vec, +} + +#[async_trait::async_trait] +pub trait ProjectKnowledgeProvider: Send + Sync { + async fn health(&self) -> Result; + async fn index( + &self, + request: &ProjectKnowledgeProviderRequest, + ) -> Result; + async fn update( + &self, + request: &ProjectKnowledgeProviderRequest, + ) -> Result; + async fn architecture( + &self, + provider_project_name: &str, + ) -> Result, KnowledgeProviderError>; + async fn search( + &self, + provider_project_name: &str, + query: &str, + ) -> Result, KnowledgeProviderError>; + async fn trace( + &self, + provider_project_name: &str, + function_name: &str, + ) -> Result, KnowledgeProviderError>; + async fn task_context( + &self, + provider_project_name: &str, + query: &str, + generation: i64, + ) -> Result; +} + +#[derive(Clone, Debug)] +pub struct CodebaseMemoryCliProvider { + program: String, +} + +impl Default for CodebaseMemoryCliProvider { + fn default() -> Self { + Self::new("codebase-memory-mcp") + } +} + +impl CodebaseMemoryCliProvider { + pub fn new(program: impl Into) -> Self { + Self { + program: program.into(), + } + } + + async fn run_json(&self, arguments: &[String]) -> Result { + let mut command = Builder::clean_cli(&self.program); + command.args(arguments); + let output = tokio::time::timeout(PROVIDER_TIMEOUT, command.output()) + .await + .map_err(|_| KnowledgeProviderError::Timeout)? + .map_err(|error| { + if error.kind() == std::io::ErrorKind::NotFound { + KnowledgeProviderError::Unavailable + } else { + KnowledgeProviderError::Rejected + } + })?; + if !output.status.success() { + return Err(KnowledgeProviderError::Rejected); + } + serde_json::from_slice(&output.stdout).map_err(|_| KnowledgeProviderError::MalformedOutput) + } + + async fn index_with_mode( + &self, + request: &ProjectKnowledgeProviderRequest, + mode: &str, + ) -> Result { + let value = self + .run_json(&[ + "cli".into(), + "index_repository".into(), + "--repo-path".into(), + request.project_path.clone(), + "--name".into(), + request.provider_project_name.clone(), + "--mode".into(), + mode.into(), + "--persistence".into(), + "false".into(), + ]) + .await?; + let provider_project_name = value + .get("project") + .and_then(Value::as_str) + .filter(|value| !value.is_empty()) + .ok_or(KnowledgeProviderError::MalformedOutput)?; + if provider_project_name != request.provider_project_name { + return Err(KnowledgeProviderError::MalformedOutput); + } + Ok(ProjectKnowledgeProviderResult { + provider_project_name: provider_project_name.into(), + source_commit: request.source_commit.clone(), + changed_paths: request.changed_paths.clone(), + facts: Vec::new(), + }) + } + + async fn graph_facts( + &self, + tool: &str, + arguments: Vec, + default_kind: &str, + ) -> Result, KnowledgeProviderError> { + let mut command_arguments = vec!["cli".into(), tool.into()]; + command_arguments.extend(arguments); + let value = self.run_json(&command_arguments).await?; + let mut facts = Vec::new(); + collect_facts(&value, default_kind, &mut facts); + facts.truncate(MAX_FACTS); + Ok(facts) + } +} + +#[async_trait::async_trait] +impl ProjectKnowledgeProvider for CodebaseMemoryCliProvider { + async fn health(&self) -> Result { + let mut command = Builder::clean_cli(&self.program); + command.arg("--version"); + let output = tokio::time::timeout(Duration::from_secs(10), command.output()) + .await + .map_err(|_| KnowledgeProviderError::Timeout)? + .map_err(|error| { + if error.kind() == std::io::ErrorKind::NotFound { + KnowledgeProviderError::Unavailable + } else { + KnowledgeProviderError::Rejected + } + })?; + if !output.status.success() { + return Err(KnowledgeProviderError::Unavailable); + } + let version = String::from_utf8(output.stdout) + .ok() + .and_then(|value| value.lines().next().map(str::trim).map(str::to_owned)) + .filter(|value| !value.is_empty()); + Ok(ProjectKnowledgeProviderHealth { + provider: "codebase-memory".into(), + version, + }) + } + + async fn index( + &self, + request: &ProjectKnowledgeProviderRequest, + ) -> Result { + self.index_with_mode(request, "moderate").await + } + + async fn update( + &self, + request: &ProjectKnowledgeProviderRequest, + ) -> Result { + self.index_with_mode(request, "fast").await + } + + async fn architecture( + &self, + provider_project_name: &str, + ) -> Result, KnowledgeProviderError> { + let mut facts = self + .graph_facts( + "get_architecture", + vec![ + "--project".into(), + provider_project_name.into(), + "--aspects".into(), + "overview".into(), + "--aspects".into(), + "routes".into(), + "--aspects".into(), + "entry_points".into(), + "--aspects".into(), + "packages".into(), + ], + "architecture", + ) + .await?; + let mut located = self + .graph_facts( + "search_graph", + vec![ + "--project".into(), + provider_project_name.into(), + "--name-pattern".into(), + ".*".into(), + "--min-degree".into(), + "1".into(), + "--limit".into(), + "200".into(), + ], + "symbol", + ) + .await?; + facts.append(&mut located); + facts.truncate(MAX_FACTS); + Ok(facts) + } + + async fn search( + &self, + provider_project_name: &str, + query: &str, + ) -> Result, KnowledgeProviderError> { + self.graph_facts( + "search_graph", + vec![ + "--project".into(), + provider_project_name.into(), + "--query".into(), + query.into(), + "--include-connected".into(), + "true".into(), + "--limit".into(), + MAX_CONTEXT_ITEMS.to_string(), + ], + "symbol", + ) + .await + } + + async fn trace( + &self, + provider_project_name: &str, + function_name: &str, + ) -> Result, KnowledgeProviderError> { + let value = self + .run_json(&[ + "cli".into(), + "trace_path".into(), + "--project".into(), + provider_project_name.into(), + "--function-name".into(), + function_name.into(), + "--direction".into(), + "both".into(), + "--depth".into(), + "2".into(), + "--include-tests".into(), + "true".into(), + ]) + .await?; + let mut qualified_names = BTreeSet::new(); + collect_qualified_names(&value, &mut qualified_names); + let mut facts = Vec::new(); + for qualified_name in qualified_names.into_iter().take(MAX_CONTEXT_ITEMS) { + let mut located = self + .graph_facts( + "search_graph", + vec![ + "--project".into(), + provider_project_name.into(), + "--qn-pattern".into(), + format!("^{}$", escape_regex(&qualified_name)), + "--limit".into(), + "1".into(), + ], + "caller", + ) + .await?; + facts.append(&mut located); + } + facts.truncate(MAX_CONTEXT_ITEMS); + Ok(facts) + } + + async fn task_context( + &self, + provider_project_name: &str, + query: &str, + generation: i64, + ) -> Result { + let search = self.search(provider_project_name, query).await?; + let mut traced = Vec::new(); + if let Some(function_name) = search.iter().find_map(|fact| fact.qualified_name.as_deref()) { + traced = self.trace(provider_project_name, function_name).await?; + } + let mut symbols = BTreeSet::new(); + let mut callers = BTreeSet::new(); + let mut tests = BTreeSet::new(); + let mut routes = BTreeSet::new(); + let mut data_entities = BTreeSet::new(); + for fact in search.iter().chain(traced.iter()) { + let value = fact.qualified_name.as_ref().unwrap_or(&fact.name).clone(); + match fact.kind.as_str() { + "test" => { + tests.insert(fact.source_path.clone()); + } + "route" => { + routes.insert(value); + } + "data_entity" => { + data_entities.insert(value); + } + "caller" => { + callers.insert(value); + } + _ => { + symbols.insert(value); + } + } + } + Ok(ProjectTaskContext { + id: String::new(), + project_id: String::new(), + provider_project_name: provider_project_name.into(), + generation, + query: query.into(), + symbols: bounded(symbols), + callers: bounded(callers), + tests: bounded(tests), + routes: bounded(routes), + data_entities: bounded(data_entities), + created_at: 0, + }) + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) struct RepositoryKnowledgeState { + pub source_commit: Option, + pub changed_paths: Vec, +} + +pub(crate) async fn inspect_repository(path: &str) -> Result { + let source_commit = match git_output(path, &["rev-parse", "HEAD"]).await { + Ok(output) => output + .lines() + .next() + .map(str::trim) + .filter(|value| !value.is_empty()) + .map(str::to_owned), + Err(KnowledgeProviderError::Rejected) => None, + Err(error) => return Err(error), + }; + let status = match git_output_bytes(path, &["status", "--porcelain=v1", "-z", "--untracked-files=all"]).await { + Ok(output) => output, + Err(KnowledgeProviderError::Rejected) => Vec::new(), + Err(error) => return Err(error), + }; + let mut changed_paths = Vec::new(); + let mut records = status.split(|byte| *byte == 0).filter(|record| !record.is_empty()); + while let Some(record) = records.next() { + if record.len() < 4 { + return Err(KnowledgeProviderError::MalformedOutput); + } + let path_bytes = &record[3..]; + let changed_path = std::str::from_utf8(path_bytes).map_err(|_| KnowledgeProviderError::MalformedOutput)?; + validate_provider_path(changed_path)?; + changed_paths.push(changed_path.to_owned()); + if record + .get(..2) + .is_some_and(|status| status.contains(&b'R') || status.contains(&b'C')) + { + let original = records.next().ok_or(KnowledgeProviderError::MalformedOutput)?; + let original = std::str::from_utf8(original).map_err(|_| KnowledgeProviderError::MalformedOutput)?; + validate_provider_path(original)?; + changed_paths.push(original.to_owned()); + } + } + changed_paths.sort(); + changed_paths.dedup(); + Ok(RepositoryKnowledgeState { + source_commit, + changed_paths, + }) +} + +async fn git_output(path: &str, arguments: &[&str]) -> Result { + let output = git_output_bytes(path, arguments).await?; + String::from_utf8(output).map_err(|_| KnowledgeProviderError::MalformedOutput) +} + +async fn git_output_bytes(path: &str, arguments: &[&str]) -> Result, KnowledgeProviderError> { + let mut command = Builder::clean_cli("git"); + command.args(arguments); + command.current_dir(path); + let output = tokio::time::timeout(Duration::from_secs(30), command.output()) + .await + .map_err(|_| KnowledgeProviderError::Timeout)? + .map_err(|_| KnowledgeProviderError::Rejected)?; + if !output.status.success() { + return Err(KnowledgeProviderError::Rejected); + } + Ok(output.stdout) +} + +fn validate_provider_path(value: &str) -> Result<(), KnowledgeProviderError> { + let path = Path::new(value); + if value.is_empty() + || path.is_absolute() + || path.components().any(|component| { + matches!( + component, + Component::ParentDir | Component::RootDir | Component::Prefix(_) + ) + }) + { + return Err(KnowledgeProviderError::MalformedOutput); + } + Ok(()) +} + +fn collect_facts(value: &Value, default_kind: &str, facts: &mut Vec) { + if facts.len() >= MAX_FACTS { + return; + } + match value { + Value::Array(items) => { + for item in items { + collect_facts(item, default_kind, facts); + } + } + Value::Object(object) => { + let name = object.get("name").and_then(Value::as_str); + let source_path = object + .get("file_path") + .or_else(|| object.get("source_path")) + .and_then(Value::as_str); + if let (Some(name), Some(source_path)) = (name, source_path) + && validate_provider_path(source_path).is_ok() + { + let label = object.get("label").and_then(Value::as_str).unwrap_or(default_kind); + let kind = normalize_kind(label, source_path, default_kind); + facts.push(ProjectKnowledgeFact { + kind, + name: name.into(), + qualified_name: object.get("qualified_name").and_then(Value::as_str).map(str::to_owned), + source_path: source_path.into(), + source_line: object + .get("start_line") + .or_else(|| object.get("source_line")) + .and_then(Value::as_i64) + .filter(|line| *line > 0), + indexed_at: 0, + }); + } + for child in object.values() { + if child.is_array() || child.is_object() { + collect_facts(child, default_kind, facts); + } + } + } + _ => {} + } +} + +fn normalize_kind(label: &str, source_path: &str, default_kind: &str) -> String { + if source_path.contains("test") || label.eq_ignore_ascii_case("test") { + "test".into() + } else { + match label.to_ascii_lowercase().as_str() { + "route" => "route".into(), + "table" | "entity" | "data_entity" => "data_entity".into(), + "caller" => "caller".into(), + "architecture" => "architecture".into(), + _ => default_kind.into(), + } + } +} + +fn bounded(values: BTreeSet) -> Vec { + values.into_iter().take(MAX_CONTEXT_ITEMS).collect() +} + +fn collect_qualified_names(value: &Value, names: &mut BTreeSet) { + match value { + Value::Array(items) => { + for item in items { + collect_qualified_names(item, names); + } + } + Value::Object(object) => { + if let Some(name) = object.get("qualified_name").and_then(Value::as_str) + && !name.is_empty() + { + names.insert(name.into()); + } + for child in object.values() { + if child.is_array() || child.is_object() { + collect_qualified_names(child, names); + } + } + } + _ => {} + } +} + +fn escape_regex(value: &str) -> String { + let mut escaped = String::with_capacity(value.len()); + for character in value.chars() { + if matches!( + character, + '.' | '^' | '$' | '*' | '+' | '?' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '\\' + ) { + escaped.push('\\'); + } + escaped.push(character); + } + escaped +} diff --git a/crates/aionui-project/src/lib.rs b/crates/aionui-project/src/lib.rs new file mode 100644 index 000000000..b5a58107b --- /dev/null +++ b/crates/aionui-project/src/lib.rs @@ -0,0 +1,27 @@ +//! Project registration and software-development preflight domain. + +mod detection; +mod error; +mod knowledge; +mod repository_source; +mod routes; +mod service; +mod types; + +pub use aionui_api_types::{ + DirtyWorktreeChoice, ProjectKnowledgeFact, ProjectKnowledgeStatus, ProjectRepositoryFacts, + ProjectRepositoryOnboardingInput, ProjectTaskContext, ProjectTaskContextRequest, RepositorySource, + RepositorySubmodule, +}; +pub use error::ProjectError; +pub use knowledge::{ + CodebaseMemoryCliProvider, KnowledgeProviderError, ProjectKnowledgeProvider, ProjectKnowledgeProviderHealth, + ProjectKnowledgeProviderRequest, ProjectKnowledgeProviderResult, +}; +pub use repository_source::RepositoryOnboarder; +pub use routes::{ProjectRouterState, project_routes}; +pub use service::{ProjectAgentCapabilityPort, ProjectService}; +pub use types::{ + AgentCapabilitySnapshot, AgentPreflightResult, CreateProjectInput, OnboardProjectResult, PreflightCheck, + ProjectCommandProfileInput, ProjectPreflightResult, ProjectRuntimeProfileInput, UpdateProjectInput, +}; diff --git a/crates/aionui-project/src/repository_source.rs b/crates/aionui-project/src/repository_source.rs new file mode 100644 index 000000000..40137ed44 --- /dev/null +++ b/crates/aionui-project/src/repository_source.rs @@ -0,0 +1,306 @@ +use std::fs; +use std::path::{Path, PathBuf}; + +use aionui_api_types::{DirtyWorktreeChoice, ProjectRepositoryFacts, RepositorySource}; +use aionui_common::now_ms; +use aionui_runtime::Builder; + +use crate::ProjectError; +use crate::detection::{detect_project, is_safe_relative_path}; + +#[derive(Debug, Clone)] +pub struct RepositoryOnboarder { + managed_root: PathBuf, +} + +impl RepositoryOnboarder { + pub fn new(managed_root: impl Into) -> Self { + Self { + managed_root: managed_root.into(), + } + } + + pub async fn onboard( + &self, + source: RepositorySource, + dirty_choice: DirtyWorktreeChoice, + ) -> Result { + let (path, repository_url, credential_reference) = match source { + RepositorySource::Local { path } => (canonical_directory(&path)?, None, None), + RepositorySource::Clone { + url, + destination_name, + branch, + credential_reference, + } => { + Self::validate_clone_url(&url)?; + Self::validate_destination_name(&destination_name)?; + if let Some(value) = branch.as_deref() { + Self::validate_branch_name(value)?; + } + if let Some(value) = credential_reference.as_deref() { + validate_credential_reference(value)?; + } + let path = self + .clone_repository(&url, &destination_name, branch.as_deref()) + .await?; + (path, Some(url), credential_reference) + } + }; + + let baseline_commit = git_optional(&path, &["rev-parse", "HEAD"]).await?; + let default_branch = git_optional(&path, &["symbolic-ref", "--quiet", "--short", "HEAD"]).await?; + let status = git(&path, &["status", "--porcelain=v1", "-z"]).await?; + let dirty = !status.is_empty(); + let dirty_snapshot_ref = match (dirty, dirty_choice) { + (true, DirtyWorktreeChoice::Reject) => { + return Err(ProjectError::Conflict( + "repository is dirty; choose preserve or snapshot explicitly".into(), + )); + } + (true, DirtyWorktreeChoice::Snapshot) => Some(self.snapshot_dirty_worktree(&path).await?), + _ => None, + }; + let detected = detect_project(&path)?; + Ok(ProjectRepositoryFacts { + local_path: path.to_string_lossy().into_owned(), + repository_url, + default_branch, + baseline_commit, + dirty, + dirty_worktree_choice: dirty_choice, + dirty_snapshot_ref, + credential_reference, + languages: detected.languages, + package_managers: detected.package_managers, + rules_files: detected.rules_files, + monorepo_packages: detected.monorepo_packages, + submodules: detected.submodules, + lfs_detected: detected.lfs_detected, + detected_at: now_ms(), + }) + } + + pub fn validate_clone_url(value: &str) -> Result<(), ProjectError> { + let value = value.trim(); + if value.is_empty() || value.contains(['\n', '\r', '\0']) { + return Err(ProjectError::BadRequest("clone URL is invalid".into())); + } + let supported = value.starts_with("https://") + || value.starts_with("ssh://") + || value.starts_with("file://") + || (value.starts_with("git@") && value.contains(':')); + if !supported { + return Err(ProjectError::BadRequest("clone URL must use HTTPS or SSH".into())); + } + if let Some(authority) = value.strip_prefix("https://").and_then(|rest| rest.split('/').next()) + && authority.contains('@') + { + return Err(ProjectError::BadRequest( + "clone URL must not contain embedded credentials; select a credential reference".into(), + )); + } + if value.contains('?') || value.contains('#') { + return Err(ProjectError::BadRequest( + "clone URL must not contain query or fragment data".into(), + )); + } + Ok(()) + } + + pub fn validate_destination_name(value: &str) -> Result<(), ProjectError> { + validate_relative_path(value, "clone destination")?; + if Path::new(value).components().count() != 1 { + return Err(ProjectError::BadRequest( + "clone destination must be a single directory name".into(), + )); + } + Ok(()) + } + + pub fn validate_branch_name(value: &str) -> Result<(), ProjectError> { + let valid = !value.is_empty() + && !value.starts_with('-') + && !value.starts_with('/') + && !value.ends_with('/') + && !value.ends_with('.') + && !value.contains("..") + && !value.contains("@{") + && !value + .chars() + .any(|ch| ch.is_control() || matches!(ch, ' ' | '~' | '^' | ':' | '?' | '*' | '[' | '\\')); + if valid { + Ok(()) + } else { + Err(ProjectError::BadRequest("branch name is invalid".into())) + } + } + + pub fn validate_submodule_path(value: &str) -> Result<(), ProjectError> { + validate_relative_path(value, "submodule path") + } + + async fn clone_repository( + &self, + url: &str, + destination_name: &str, + branch: Option<&str>, + ) -> Result { + fs::create_dir_all(&self.managed_root) + .map_err(|error| ProjectError::Internal(format!("failed to create managed project root: {error}")))?; + let root = self + .managed_root + .canonicalize() + .map_err(|error| ProjectError::Internal(format!("managed project root cannot be resolved: {error}")))?; + let destination = root.join(destination_name); + if destination.exists() { + return Err(ProjectError::Conflict(format!( + "clone destination already exists: {destination_name}" + ))); + } + let mut command = Builder::clean_cli("git"); + command.arg("clone").arg("--no-tags"); + if let Some(branch) = branch { + command.args(["--branch", branch, "--single-branch"]); + } + command.arg("--").arg(url).arg(&destination); + let output = command + .output() + .await + .map_err(|error| ProjectError::Internal(format!("git clone could not start: {error}")))?; + if !output.status.success() { + let _ = fs::remove_dir_all(&destination); + return Err(ProjectError::BadRequest(format!( + "git clone failed: {}", + safe_git_error(&output.stderr) + ))); + } + let canonical = destination + .canonicalize() + .map_err(|error| ProjectError::Internal(format!("cloned repository cannot be resolved: {error}")))?; + if !canonical.starts_with(&root) || canonical.parent() != Some(root.as_path()) { + let _ = fs::remove_dir_all(&canonical); + return Err(ProjectError::BadRequest( + "clone destination escaped the managed project root".into(), + )); + } + Ok(canonical) + } + + async fn snapshot_dirty_worktree(&self, repository: &Path) -> Result { + let snapshot_root = self.managed_root.join("_snapshots"); + fs::create_dir_all(&snapshot_root) + .map_err(|error| ProjectError::Internal(format!("failed to create snapshot root: {error}")))?; + let snapshot = snapshot_root.join(uuid::Uuid::now_v7().to_string()); + let untracked_root = snapshot.join("untracked"); + fs::create_dir_all(&untracked_root) + .map_err(|error| ProjectError::Internal(format!("failed to create snapshot: {error}")))?; + let patch = git(repository, &["diff", "--binary", "--no-ext-diff", "HEAD"]).await?; + fs::write(snapshot.join("changes.patch"), patch) + .map_err(|error| ProjectError::Internal(format!("failed to write repository snapshot: {error}")))?; + let untracked = git(repository, &["ls-files", "--others", "--exclude-standard", "-z"]).await?; + for relative in untracked.split(|byte| *byte == 0).filter(|item| !item.is_empty()) { + let relative = std::str::from_utf8(relative) + .map_err(|_| ProjectError::BadRequest("untracked file path is not valid UTF-8".into()))?; + validate_relative_path(relative, "untracked file")?; + let source = repository.join(relative); + let metadata = fs::symlink_metadata(&source) + .map_err(|error| ProjectError::Internal(format!("failed to inspect untracked file: {error}")))?; + if metadata.file_type().is_symlink() || !metadata.is_file() { + return Err(ProjectError::BadRequest(format!( + "snapshot does not accept symlink: {relative}" + ))); + } + if metadata.len() > 50 * 1024 * 1024 { + return Err(ProjectError::BadRequest(format!( + "untracked snapshot file is too large: {relative}" + ))); + } + let target = untracked_root.join(relative); + if let Some(parent) = target.parent() { + fs::create_dir_all(parent) + .map_err(|error| ProjectError::Internal(format!("failed to create snapshot directory: {error}")))?; + } + fs::copy(source, target) + .map_err(|error| ProjectError::Internal(format!("failed to snapshot untracked file: {error}")))?; + } + snapshot + .canonicalize() + .map(|value| value.to_string_lossy().into_owned()) + .map_err(|error| ProjectError::Internal(format!("snapshot cannot be resolved: {error}"))) + } +} + +pub(crate) fn validate_relative_path(value: &str, field: &str) -> Result<(), ProjectError> { + if is_safe_relative_path(value) { + Ok(()) + } else { + Err(ProjectError::BadRequest(format!( + "{field} must stay inside its repository boundary" + ))) + } +} + +fn validate_credential_reference(value: &str) -> Result<(), ProjectError> { + let valid = (3..=128).contains(&value.len()) + && value + .chars() + .all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '-' | '_' | '.' | ':')) + && value.contains(':'); + if valid { + Ok(()) + } else { + Err(ProjectError::BadRequest("credential reference is invalid".into())) + } +} + +fn canonical_directory(value: &str) -> Result { + let canonical = Path::new(value) + .canonicalize() + .map_err(|error| ProjectError::BadRequest(format!("repository path cannot be resolved: {error}")))?; + if !canonical.is_dir() { + return Err(ProjectError::BadRequest("repository path is not a directory".into())); + } + Ok(canonical) +} + +async fn git(repository: &Path, args: &[&str]) -> Result, ProjectError> { + let mut command = Builder::clean_cli("git"); + command.args(args).current_dir(repository); + let output = command + .output() + .await + .map_err(|error| ProjectError::Internal(format!("git could not start: {error}")))?; + if output.status.success() { + Ok(output.stdout) + } else { + Err(ProjectError::BadRequest(format!( + "git command failed: {}", + safe_git_error(&output.stderr) + ))) + } +} + +async fn git_optional(repository: &Path, args: &[&str]) -> Result, ProjectError> { + let mut command = Builder::clean_cli("git"); + command.args(args).current_dir(repository); + let output = command + .output() + .await + .map_err(|error| ProjectError::Internal(format!("git could not start: {error}")))?; + if !output.status.success() { + return Ok(None); + } + let value = String::from_utf8_lossy(&output.stdout).trim().to_owned(); + Ok((!value.is_empty()).then_some(value)) +} + +fn safe_git_error(stderr: &[u8]) -> String { + let value = String::from_utf8_lossy(stderr); + let line = value.lines().last().unwrap_or("unknown Git error").trim(); + let mut safe = line.replace(['\r', '\n'], " "); + if safe.len() > 300 { + safe.truncate(300); + } + safe +} diff --git a/crates/aionui-project/src/routes.rs b/crates/aionui-project/src/routes.rs new file mode 100644 index 000000000..b7f10067a --- /dev/null +++ b/crates/aionui-project/src/routes.rs @@ -0,0 +1,337 @@ +// This module is the HTTP boundary where crate-owned `ProjectError` values +// are intentionally mapped to the shared API error envelope. +#![allow(clippy::disallowed_types)] + +use std::sync::Arc; + +use aionui_api_types::{ + ApiResponse, ProjectKnowledgeFact, ProjectKnowledgeStatus, ProjectRepositoryFacts, + ProjectRepositoryOnboardingInput, ProjectTaskContext, ProjectTaskContextRequest, +}; +use aionui_auth::CurrentUser; +use aionui_common::ApiError; +use axum::Router; +use axum::extract::rejection::JsonRejection; +use axum::extract::{Extension, Json, Path, Query, State}; +use axum::http::StatusCode; +use axum::routing::{get, post}; +use serde::Deserialize; + +use crate::error::ProjectError; +use crate::service::ProjectService; +use crate::types::{CreateProjectInput, ProjectCommandProfileInput, ProjectRuntimeProfileInput, UpdateProjectInput}; + +impl From for ApiError { + fn from(error: ProjectError) -> Self { + match error { + ProjectError::BadRequest(message) => Self::BadRequest(message), + ProjectError::NotFound(message) => Self::NotFound(message), + ProjectError::Conflict(message) => Self::Conflict(message), + ProjectError::Internal(_) => Self::Internal("Project operation failed".into()), + } + } +} + +#[derive(Clone)] +pub struct ProjectRouterState { + pub service: Arc, +} + +#[derive(Debug, Deserialize)] +struct BindResourceRequest { + resource_type: String, + resource_id: String, +} + +#[derive(Debug, Default, Deserialize)] +struct ProjectPreflightRequest { + #[serde(default)] + agent_ids: Vec, + #[serde(default)] + refresh_agents: bool, +} + +#[derive(Debug, Deserialize)] +struct ResourceQuery { + resource_type: String, + resource_id: String, +} + +pub fn project_routes(state: ProjectRouterState) -> Router { + Router::new() + .route("/api/projects", post(create).get(list)) + .route("/api/projects/onboard", post(onboard)) + .route("/api/projects/by-resource", get(get_for_resource)) + .route("/api/projects/{id}", get(get_one).patch(update).delete(delete_one)) + .route( + "/api/projects/{id}/command-profile", + get(get_command_profile).put(upsert_command_profile), + ) + .route( + "/api/projects/{id}/runtime-profile", + get(get_runtime_profile).put(upsert_runtime_profile), + ) + .route("/api/projects/{id}/links", get(list_links).post(bind_resource)) + .route("/api/projects/{id}/preflight", post(preflight)) + .route("/api/projects/{id}/repository-facts", get(get_repository_facts)) + .route("/api/projects/{id}/knowledge", get(get_knowledge_status)) + .route("/api/projects/{id}/knowledge/refresh", post(refresh_knowledge)) + .route("/api/projects/{id}/knowledge/facts", get(list_knowledge_facts)) + .route("/api/projects/{id}/knowledge/context", post(task_context)) + .with_state(state) +} + +async fn onboard( + State(state): State, + Extension(user): Extension, + body: Result, JsonRejection>, +) -> Result<(StatusCode, Json>), ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + let result = state.service.onboard(&user.id, input).await.map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(result)))) +} + +async fn get_repository_facts( + State(state): State, + Extension(user): Extension, + Path(id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .get_repository_facts(&user.id, &id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn get_knowledge_status( + State(state): State, + Extension(user): Extension, + Path(id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .get_knowledge_status(&user.id, &id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn refresh_knowledge( + State(state): State, + Extension(user): Extension, + Path(id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .refresh_knowledge(&user.id, &id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn list_knowledge_facts( + State(state): State, + Extension(user): Extension, + Path(id): Path, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .list_knowledge_facts(&user.id, &id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn task_context( + State(state): State, + Extension(user): Extension, + Path(id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .service + .task_context(&user.id, &id, &input.query) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn create( + State(state): State, + Extension(user): Extension, + body: Result, JsonRejection>, +) -> Result<(StatusCode, Json>), ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + let project = state.service.create(&user.id, input).await.map_err(ApiError::from)?; + Ok((StatusCode::CREATED, Json(ApiResponse::ok(project)))) +} + +async fn list( + State(state): State, + Extension(user): Extension, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state.service.list(&user.id).await.map_err(ApiError::from)?, + ))) +} + +async fn get_one( + State(state): State, + Extension(user): Extension, + Path(id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state.service.get(&user.id, &id).await.map_err(ApiError::from)?, + ))) +} + +async fn update( + State(state): State, + Extension(user): Extension, + Path(id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .service + .update(&user.id, &id, input) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn delete_one( + State(state): State, + Extension(user): Extension, + Path(id): Path, +) -> Result { + state.service.delete(&user.id, &id).await.map_err(ApiError::from)?; + Ok(StatusCode::NO_CONTENT) +} + +async fn get_command_profile( + State(state): State, + Extension(user): Extension, + Path(id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .get_command_profile(&user.id, &id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn upsert_command_profile( + State(state): State, + Extension(user): Extension, + Path(id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .service + .upsert_command_profile(&user.id, &id, input) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn get_runtime_profile( + State(state): State, + Extension(user): Extension, + Path(id): Path, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .get_runtime_profile(&user.id, &id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn upsert_runtime_profile( + State(state): State, + Extension(user): Extension, + Path(id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .service + .upsert_runtime_profile(&user.id, &id, input) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn bind_resource( + State(state): State, + Extension(user): Extension, + Path(id): Path, + body: Result, JsonRejection>, +) -> Result { + let Json(input) = body.map_err(ApiError::from)?; + state + .service + .bind_resource(&user.id, &id, &input.resource_type, &input.resource_id) + .await + .map_err(ApiError::from)?; + Ok(StatusCode::NO_CONTENT) +} + +async fn list_links( + State(state): State, + Extension(user): Extension, + Path(id): Path, +) -> Result>>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .list_resource_links(&user.id, &id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn get_for_resource( + State(state): State, + Extension(user): Extension, + Query(query): Query, +) -> Result>, ApiError> { + Ok(Json(ApiResponse::ok( + state + .service + .get_for_resource(&user.id, &query.resource_type, &query.resource_id) + .await + .map_err(ApiError::from)?, + ))) +} + +async fn preflight( + State(state): State, + Extension(user): Extension, + Path(id): Path, + body: Result, JsonRejection>, +) -> Result>, ApiError> { + let Json(input) = body.map_err(ApiError::from)?; + Ok(Json(ApiResponse::ok( + state + .service + .preflight(&user.id, &id, &input.agent_ids, input.refresh_agents) + .await + .map_err(ApiError::from)?, + ))) +} diff --git a/crates/aionui-project/src/service.rs b/crates/aionui-project/src/service.rs new file mode 100644 index 000000000..26296ad5a --- /dev/null +++ b/crates/aionui-project/src/service.rs @@ -0,0 +1,1032 @@ +use std::path::{Path, PathBuf}; +use std::sync::Arc; + +use aionui_api_types::{ + DirtyWorktreeChoice, ProjectKnowledgeFact, ProjectKnowledgeStatus, ProjectRepositoryFacts, + ProjectRepositoryOnboardingInput, ProjectTaskContext, +}; +use aionui_common::now_ms; +use aionui_db::models::{ + ProjectCommandProfileRow, ProjectKnowledgeContextRow, ProjectKnowledgeFactRow, ProjectKnowledgeIndexRow, + ProjectRepositoryFactsRow, ProjectResourceLinkRow, ProjectRow, ProjectRuntimeProfileRow, +}; +use aionui_db::{IConversationRepository, IProjectRepository, ITeamRepository, UpdateProjectParams}; + +use crate::error::ProjectError; +use crate::knowledge::{ + CodebaseMemoryCliProvider, KnowledgeProviderError, ProjectKnowledgeProvider, ProjectKnowledgeProviderRequest, + ProjectKnowledgeProviderResult, inspect_repository, +}; +use crate::repository_source::RepositoryOnboarder; +use crate::types::{ + AgentCapabilitySnapshot, AgentPreflightResult, CreateProjectInput, OnboardProjectResult, PreflightCheck, + ProjectCommandProfileInput, ProjectPreflightResult, ProjectRuntimeProfileInput, UpdateProjectInput, +}; + +const AGENT_SNAPSHOT_STALE_MS: i64 = 24 * 60 * 60 * 1000; + +#[async_trait::async_trait] +pub trait ProjectAgentCapabilityPort: Send + Sync { + async fn snapshot(&self, id: &str, refresh: bool) -> Result, ProjectError>; +} + +#[derive(Clone)] +pub struct ProjectService { + project_repo: Arc, + conversation_repo: Arc, + team_repo: Arc, + agent_port: Arc, + repository_onboarder: RepositoryOnboarder, + knowledge_provider: Arc, +} + +impl ProjectService { + pub fn new( + project_repo: Arc, + conversation_repo: Arc, + team_repo: Arc, + agent_port: Arc, + ) -> Self { + Self { + project_repo, + conversation_repo, + team_repo, + agent_port, + repository_onboarder: RepositoryOnboarder::new(std::env::temp_dir().join("aionui-managed-projects")), + knowledge_provider: Arc::new(CodebaseMemoryCliProvider::default()), + } + } + + pub fn with_managed_project_root(mut self, root: impl Into) -> Self { + self.repository_onboarder = RepositoryOnboarder::new(root); + self + } + + pub fn with_knowledge_provider(mut self, provider: Arc) -> Self { + self.knowledge_provider = provider; + self + } + + pub async fn onboard( + &self, + user_id: &str, + input: ProjectRepositoryOnboardingInput, + ) -> Result { + let name = non_empty(input.name, "project name")?; + validate_project_type(&input.project_type)?; + let repository = self + .repository_onboarder + .onboard(input.source, input.dirty_worktree_choice) + .await?; + let now = now_ms(); + let project = ProjectRow { + id: uuid::Uuid::now_v7().to_string(), + user_id: user_id.to_owned(), + name, + local_path: repository.local_path.clone(), + repository_url: repository.repository_url.clone(), + default_branch: repository.default_branch.clone(), + project_type: input.project_type, + created_at: now, + updated_at: now, + }; + self.project_repo.create(&project).await?; + let facts = repository_facts_row(&project.id, &repository)?; + if let Err(error) = self.project_repo.upsert_repository_facts(&facts).await { + let _ = self.project_repo.delete_for_user(&project.id, user_id).await; + return Err(error.into()); + } + Ok(OnboardProjectResult { project, repository }) + } + + pub async fn get_repository_facts( + &self, + user_id: &str, + project_id: &str, + ) -> Result { + let project = self.get(user_id, project_id).await?; + let row = self + .project_repo + .get_repository_facts(project_id, user_id) + .await? + .ok_or_else(|| ProjectError::NotFound(format!("repository facts for project {project_id}")))?; + project_repository_facts(row, project.local_path) + } + + pub async fn get_knowledge_status( + &self, + user_id: &str, + project_id: &str, + ) -> Result { + let project = self.get(user_id, project_id).await?; + let repository = inspect_repository(&project.local_path) + .await + .map_err(provider_project_error)?; + let Some(row) = self.project_repo.get_knowledge_index(project_id, user_id).await? else { + return Ok(ProjectKnowledgeStatus { + project_id: project_id.into(), + provider: "codebase-memory".into(), + provider_project_name: provider_project_name(project_id), + provider_version: None, + status: "stale".into(), + generation: 0, + source_commit: repository.source_commit, + indexed_at: None, + changed_paths: repository.changed_paths, + error_category: Some("not_indexed".into()), + updated_at: now_ms(), + }); + }; + let mut status = knowledge_status_from_row(&row)?; + if matches!(status.status.as_str(), "healthy" | "stale") + && (status.source_commit != repository.source_commit || status.changed_paths != repository.changed_paths) + { + status.status = "stale".into(); + status.source_commit = repository.source_commit; + status.changed_paths = repository.changed_paths; + status.error_category = Some("repository_changed".into()); + } + Ok(status) + } + + pub async fn refresh_knowledge( + &self, + user_id: &str, + project_id: &str, + ) -> Result { + let project = self.get(user_id, project_id).await?; + let repository = inspect_repository(&project.local_path) + .await + .map_err(provider_project_error)?; + let existing = self.project_repo.get_knowledge_index(project_id, user_id).await?; + if let Some(row) = existing.as_ref() + && row.status == "healthy" + && row.source_commit == repository.source_commit + && parse_string_list(&row.changed_paths_json)? == repository.changed_paths + { + return knowledge_status_from_row(row); + } + + let project_name = existing + .as_ref() + .map(|row| row.provider_project_name.clone()) + .unwrap_or_else(|| provider_project_name(project_id)); + let health = match self.knowledge_provider.health().await { + Ok(health) => health, + Err(error) => { + self.persist_provider_failure(project_id, existing.as_ref(), &project_name, &repository, &error) + .await?; + return Err(provider_project_error(error)); + } + }; + let generation = existing.as_ref().map_or(1, |row| row.generation + 1); + let started_at = now_ms(); + let indexing = ProjectKnowledgeIndexRow { + project_id: project_id.into(), + provider: health.provider.clone(), + provider_project_name: project_name.clone(), + provider_version: health.version.clone(), + status: "indexing".into(), + generation: existing.as_ref().map_or(0, |row| row.generation), + source_commit: repository.source_commit.clone(), + indexed_at: existing.as_ref().and_then(|row| row.indexed_at), + changed_paths_json: serialize_string_list(&repository.changed_paths)?, + error_category: None, + updated_at: started_at, + }; + self.project_repo.upsert_knowledge_index(&indexing).await?; + + let request = ProjectKnowledgeProviderRequest { + project_path: project.local_path, + provider_project_name: project_name.clone(), + source_commit: repository.source_commit.clone(), + changed_paths: repository.changed_paths.clone(), + }; + let provider_result = if existing.as_ref().is_some_and(|row| row.generation > 0) { + self.knowledge_provider.update(&request).await + } else { + self.knowledge_provider.index(&request).await + }; + let provider_result = match provider_result { + Ok(result) => result, + Err(error) => { + self.persist_provider_failure(project_id, existing.as_ref(), &project_name, &repository, &error) + .await?; + return Err(provider_project_error(error)); + } + }; + validate_provider_result(&provider_result, &request)?; + let architecture = match self.knowledge_provider.architecture(&project_name).await { + Ok(facts) => facts, + Err(error) => { + self.persist_provider_failure(project_id, existing.as_ref(), &project_name, &repository, &error) + .await?; + return Err(provider_project_error(error)); + } + }; + let indexed_at = now_ms(); + let mut facts = provider_result.facts; + facts.extend(architecture); + normalize_and_validate_facts(&mut facts, indexed_at)?; + let fact_rows = facts + .into_iter() + .map(|fact| ProjectKnowledgeFactRow { + id: uuid::Uuid::now_v7().to_string(), + project_id: project_id.into(), + generation, + kind: fact.kind, + name: fact.name, + qualified_name: fact.qualified_name, + source_path: fact.source_path, + source_line: fact.source_line, + indexed_at: fact.indexed_at, + }) + .collect::>(); + let completed = ProjectKnowledgeIndexRow { + project_id: project_id.into(), + provider: health.provider, + provider_project_name: project_name, + provider_version: health.version, + status: "healthy".into(), + generation, + source_commit: provider_result.source_commit, + indexed_at: Some(indexed_at), + changed_paths_json: serialize_string_list(&provider_result.changed_paths)?, + error_category: None, + updated_at: indexed_at, + }; + self.project_repo + .commit_knowledge_generation(&completed, &fact_rows) + .await?; + knowledge_status_from_row(&completed) + } + + async fn persist_provider_failure( + &self, + project_id: &str, + existing: Option<&ProjectKnowledgeIndexRow>, + project_name: &str, + repository: &crate::knowledge::RepositoryKnowledgeState, + error: &KnowledgeProviderError, + ) -> Result<(), ProjectError> { + let now = now_ms(); + let status = if matches!(error, KnowledgeProviderError::Unavailable) { + "unavailable" + } else { + "failed" + }; + self.project_repo + .upsert_knowledge_index(&ProjectKnowledgeIndexRow { + project_id: project_id.into(), + provider: "codebase-memory".into(), + provider_project_name: project_name.into(), + provider_version: existing.and_then(|row| row.provider_version.clone()), + status: status.into(), + generation: existing.map_or(0, |row| row.generation), + source_commit: repository.source_commit.clone(), + indexed_at: existing.and_then(|row| row.indexed_at), + changed_paths_json: serialize_string_list(&repository.changed_paths)?, + error_category: Some(error.category().into()), + updated_at: now, + }) + .await?; + Ok(()) + } + + pub async fn list_knowledge_facts( + &self, + user_id: &str, + project_id: &str, + ) -> Result, ProjectError> { + self.get(user_id, project_id).await?; + Ok(self + .project_repo + .list_knowledge_facts(project_id, user_id) + .await? + .into_iter() + .map(|row| ProjectKnowledgeFact { + kind: row.kind, + name: row.name, + qualified_name: row.qualified_name, + source_path: row.source_path, + source_line: row.source_line, + indexed_at: row.indexed_at, + }) + .collect()) + } + + pub async fn task_context( + &self, + user_id: &str, + project_id: &str, + query: &str, + ) -> Result { + self.get(user_id, project_id).await?; + let query = query.trim(); + if query.is_empty() || query.len() > 500 { + return Err(ProjectError::BadRequest( + "task context query must contain 1 to 500 bytes".into(), + )); + } + let index = self + .project_repo + .get_knowledge_index(project_id, user_id) + .await? + .filter(|row| row.generation > 0) + .ok_or_else(|| ProjectError::Conflict("project knowledge has not been indexed".into()))?; + let mut context = self + .knowledge_provider + .task_context(&index.provider_project_name, query, index.generation) + .await + .map_err(provider_project_error)?; + if context.provider_project_name != index.provider_project_name || context.generation != index.generation { + return Err(provider_project_error(KnowledgeProviderError::MalformedOutput)); + } + validate_context(&context)?; + context.id = uuid::Uuid::now_v7().to_string(); + context.project_id = project_id.into(); + context.query = query.into(); + context.created_at = now_ms(); + self.project_repo + .insert_knowledge_context(&ProjectKnowledgeContextRow { + id: context.id.clone(), + project_id: context.project_id.clone(), + provider_project_name: context.provider_project_name.clone(), + generation: context.generation, + query: context.query.clone(), + symbols_json: serialize_string_list(&context.symbols)?, + callers_json: serialize_string_list(&context.callers)?, + tests_json: serialize_string_list(&context.tests)?, + routes_json: serialize_string_list(&context.routes)?, + data_entities_json: serialize_string_list(&context.data_entities)?, + created_at: context.created_at, + }) + .await?; + Ok(context) + } + + pub async fn create(&self, user_id: &str, input: CreateProjectInput) -> Result { + let name = non_empty(input.name, "project name")?; + let local_path = canonical_directory(&input.local_path)?; + validate_project_type(&input.project_type)?; + let now = now_ms(); + let row = ProjectRow { + id: uuid::Uuid::now_v7().to_string(), + user_id: user_id.to_owned(), + name, + local_path, + repository_url: trim_optional(input.repository_url), + default_branch: trim_optional(input.default_branch), + project_type: input.project_type, + created_at: now, + updated_at: now, + }; + self.project_repo.create(&row).await?; + Ok(row) + } + + pub async fn list(&self, user_id: &str) -> Result, ProjectError> { + Ok(self.project_repo.list_for_user(user_id).await?) + } + + pub async fn get(&self, user_id: &str, project_id: &str) -> Result { + self.project_repo + .get_for_user(project_id, user_id) + .await? + .ok_or_else(|| ProjectError::NotFound(format!("project {project_id}"))) + } + + pub async fn update( + &self, + user_id: &str, + project_id: &str, + input: UpdateProjectInput, + ) -> Result { + if let Some(ref value) = input.project_type { + validate_project_type(value)?; + } + let params = UpdateProjectParams { + name: input.name.map(|value| non_empty(value, "project name")).transpose()?, + local_path: input.local_path.map(|value| canonical_directory(&value)).transpose()?, + repository_url: input.repository_url.map(trim_optional), + default_branch: input.default_branch.map(trim_optional), + project_type: input.project_type, + }; + Ok(self.project_repo.update_for_user(project_id, user_id, ¶ms).await?) + } + + pub async fn delete(&self, user_id: &str, project_id: &str) -> Result<(), ProjectError> { + if !self.project_repo.delete_for_user(project_id, user_id).await? { + return Err(ProjectError::NotFound(format!("project {project_id}"))); + } + Ok(()) + } + + pub async fn upsert_command_profile( + &self, + user_id: &str, + project_id: &str, + input: ProjectCommandProfileInput, + ) -> Result { + self.get(user_id, project_id).await?; + if input.command_timeout_seconds <= 0 { + return Err(ProjectError::BadRequest("command timeout must be positive".into())); + } + let row = ProjectCommandProfileRow { + project_id: project_id.to_owned(), + install_command: trim_optional(input.install_command), + format_command: trim_optional(input.format_command), + lint_command: trim_optional(input.lint_command), + typecheck_command: trim_optional(input.typecheck_command), + unit_test_command: trim_optional(input.unit_test_command), + integration_test_command: trim_optional(input.integration_test_command), + e2e_command: trim_optional(input.e2e_command), + build_command: trim_optional(input.build_command), + security_scan_command: trim_optional(input.security_scan_command), + command_timeout_seconds: input.command_timeout_seconds, + updated_at: now_ms(), + }; + self.project_repo.upsert_command_profile(&row).await?; + Ok(row) + } + + pub async fn get_command_profile( + &self, + user_id: &str, + project_id: &str, + ) -> Result { + self.project_repo + .get_command_profile(project_id, user_id) + .await? + .ok_or_else(|| ProjectError::NotFound(format!("command profile for project {project_id}"))) + } + + pub async fn upsert_runtime_profile( + &self, + user_id: &str, + project_id: &str, + input: ProjectRuntimeProfileInput, + ) -> Result { + self.get(user_id, project_id).await?; + if !matches!(input.environment_kind.as_str(), "local" | "container") { + return Err(ProjectError::BadRequest(format!( + "unsupported environment kind: {}", + input.environment_kind + ))); + } + let row = ProjectRuntimeProfileRow { + project_id: project_id.to_owned(), + environment_kind: input.environment_kind, + language: trim_optional(input.language), + package_manager: trim_optional(input.package_manager), + runtime_version: trim_optional(input.runtime_version), + env_keys: serde_json::to_string(&input.env_keys) + .map_err(|error| ProjectError::BadRequest(error.to_string()))?, + metadata: serde_json::to_string(&input.metadata) + .map_err(|error| ProjectError::BadRequest(error.to_string()))?, + updated_at: now_ms(), + }; + self.project_repo.upsert_runtime_profile(&row).await?; + Ok(row) + } + + pub async fn get_runtime_profile( + &self, + user_id: &str, + project_id: &str, + ) -> Result { + self.project_repo + .get_runtime_profile(project_id, user_id) + .await? + .ok_or_else(|| ProjectError::NotFound(format!("runtime profile for project {project_id}"))) + } + + pub async fn bind_resource( + &self, + user_id: &str, + project_id: &str, + resource_type: &str, + resource_id: &str, + ) -> Result<(), ProjectError> { + self.get(user_id, project_id).await?; + let owned = match resource_type { + "conversation" => self + .conversation_repo + .get(resource_id) + .await? + .is_some_and(|row| row.user_id == user_id), + "team" => self + .team_repo + .get_team(resource_id) + .await? + .is_some_and(|row| row.user_id == user_id), + "cron" | "channel" => { + self.project_repo + .resource_is_owned(user_id, resource_type, resource_id) + .await? + } + other => return Err(ProjectError::BadRequest(format!("unsupported resource type: {other}"))), + }; + if !owned { + return Err(ProjectError::NotFound(format!("{resource_type} {resource_id}"))); + } + self.project_repo + .bind_resource(project_id, user_id, resource_type, resource_id) + .await?; + Ok(()) + } + + pub async fn list_resource_links( + &self, + user_id: &str, + project_id: &str, + ) -> Result, ProjectError> { + self.get(user_id, project_id).await?; + Ok(self.project_repo.list_resource_links(project_id, user_id).await?) + } + + pub async fn get_for_resource( + &self, + user_id: &str, + resource_type: &str, + resource_id: &str, + ) -> Result { + if !matches!(resource_type, "conversation" | "team" | "cron" | "channel") { + return Err(ProjectError::BadRequest(format!( + "unsupported resource type: {resource_type}" + ))); + } + self.project_repo + .get_for_resource(user_id, resource_type, resource_id) + .await? + .ok_or_else(|| ProjectError::NotFound(format!("project for {resource_type} {resource_id}"))) + } + + pub async fn preflight( + &self, + user_id: &str, + project_id: &str, + agent_ids: &[String], + refresh_agents: bool, + ) -> Result { + let project = self.get(user_id, project_id).await?; + let command_profile = self.project_repo.get_command_profile(project_id, user_id).await?; + let runtime_profile = self.project_repo.get_runtime_profile(project_id, user_id).await?; + let mut checks = inspect_project(&project, command_profile.as_ref(), runtime_profile.as_ref()); + let mut agents = Vec::with_capacity(agent_ids.len()); + for agent_id in agent_ids { + let snapshot = self.agent_port.snapshot(agent_id, refresh_agents).await?; + agents.push(inspect_agent(agent_id, snapshot)); + } + let overall_status = overall_level( + checks + .iter() + .map(|item| item.level.as_str()) + .chain(agents.iter().map(|item| item.level.as_str())), + ); + checks.sort_by(|left, right| left.code.cmp(&right.code)); + Ok(ProjectPreflightResult { + project_id: project.id, + overall_status, + checks, + agents, + checked_at: now_ms(), + }) + } +} + +fn non_empty(value: String, field: &str) -> Result { + let value = value.trim().to_owned(); + if value.is_empty() { + Err(ProjectError::BadRequest(format!("{field} must not be empty"))) + } else { + Ok(value) + } +} + +fn trim_optional(value: Option) -> Option { + value.map(|item| item.trim().to_owned()).filter(|item| !item.is_empty()) +} + +fn repository_facts_row( + project_id: &str, + facts: &ProjectRepositoryFacts, +) -> Result { + let json_error = |error: serde_json::Error| ProjectError::Internal(error.to_string()); + Ok(ProjectRepositoryFactsRow { + project_id: project_id.to_owned(), + repository_url: facts.repository_url.clone(), + default_branch: facts.default_branch.clone(), + baseline_commit: facts.baseline_commit.clone(), + repository_dirty: facts.dirty, + dirty_worktree_choice: dirty_choice_name(facts.dirty_worktree_choice).into(), + dirty_snapshot_ref: facts.dirty_snapshot_ref.clone(), + credential_reference: facts.credential_reference.clone(), + detected_languages_json: serde_json::to_string(&facts.languages).map_err(json_error)?, + detected_package_managers_json: serde_json::to_string(&facts.package_managers).map_err(json_error)?, + detected_rules_files_json: serde_json::to_string(&facts.rules_files).map_err(json_error)?, + monorepo_packages_json: serde_json::to_string(&facts.monorepo_packages).map_err(json_error)?, + submodules_json: serde_json::to_string(&facts.submodules).map_err(json_error)?, + lfs_detected: facts.lfs_detected, + detected_at: facts.detected_at, + }) +} + +fn project_repository_facts( + row: ProjectRepositoryFactsRow, + local_path: String, +) -> Result { + let json_error = |error: serde_json::Error| ProjectError::Internal(error.to_string()); + Ok(ProjectRepositoryFacts { + local_path, + repository_url: row.repository_url, + default_branch: row.default_branch, + baseline_commit: row.baseline_commit, + dirty: row.repository_dirty, + dirty_worktree_choice: match row.dirty_worktree_choice.as_str() { + "preserve" => DirtyWorktreeChoice::Preserve, + "snapshot" => DirtyWorktreeChoice::Snapshot, + "reject" => DirtyWorktreeChoice::Reject, + value => { + return Err(ProjectError::Internal(format!( + "invalid persisted dirty choice: {value}" + ))); + } + }, + dirty_snapshot_ref: row.dirty_snapshot_ref, + credential_reference: row.credential_reference, + languages: serde_json::from_str(&row.detected_languages_json).map_err(json_error)?, + package_managers: serde_json::from_str(&row.detected_package_managers_json).map_err(json_error)?, + rules_files: serde_json::from_str(&row.detected_rules_files_json).map_err(json_error)?, + monorepo_packages: serde_json::from_str(&row.monorepo_packages_json).map_err(json_error)?, + submodules: serde_json::from_str(&row.submodules_json).map_err(json_error)?, + lfs_detected: row.lfs_detected, + detected_at: row.detected_at, + }) +} + +fn dirty_choice_name(value: DirtyWorktreeChoice) -> &'static str { + match value { + DirtyWorktreeChoice::Preserve => "preserve", + DirtyWorktreeChoice::Snapshot => "snapshot", + DirtyWorktreeChoice::Reject => "reject", + } +} + +fn validate_project_type(value: &str) -> Result<(), ProjectError> { + if matches!(value, "single" | "monorepo" | "unknown") { + Ok(()) + } else { + Err(ProjectError::BadRequest(format!("unsupported project type: {value}"))) + } +} + +fn canonical_directory(value: &str) -> Result { + let path = Path::new(value); + let canonical = path + .canonicalize() + .map_err(|error| ProjectError::BadRequest(format!("project path cannot be resolved: {error}")))?; + if !canonical.is_dir() { + return Err(ProjectError::BadRequest("project path is not a directory".into())); + } + Ok(canonical.to_string_lossy().into_owned()) +} + +fn check(code: &str, level: &str, summary: impl Into) -> PreflightCheck { + PreflightCheck { + code: code.into(), + level: level.into(), + summary: summary.into(), + details: None, + } +} + +fn inspect_project( + project: &ProjectRow, + commands: Option<&ProjectCommandProfileRow>, + runtime: Option<&ProjectRuntimeProfileRow>, +) -> Vec { + let path = PathBuf::from(&project.local_path); + if !path.exists() { + return vec![check("path.exists", "fail", "Project directory no longer exists")]; + } + if !path.is_dir() { + return vec![check("path.directory", "fail", "Project path is not a directory")]; + } + let mut checks = vec![check("path.exists", "pass", "Project directory is available")]; + inspect_git(&path, project, &mut checks); + if let Some(commands) = commands { + inspect_commands(&path, commands, &mut checks); + } + if let Some(runtime) = runtime { + inspect_runtime(&path, runtime, &mut checks); + } + checks +} + +fn inspect_git(path: &Path, project: &ProjectRow, checks: &mut Vec) { + let Ok(repository) = git2::Repository::discover(path) else { + checks.push(check( + "git.repository", + "warning", + "Project directory is not inside a Git repository", + )); + return; + }; + checks.push(check("git.repository", "pass", "Git repository detected")); + let dirty = repository.statuses(None).map(|items| !items.is_empty()).unwrap_or(true); + checks.push(check( + "git.dirty", + if dirty { "warning" } else { "pass" }, + if dirty { + "Git working tree has local changes" + } else { + "Git working tree is clean" + }, + )); + if let Some(expected) = project.default_branch.as_deref() { + let actual = repository + .head() + .ok() + .and_then(|head| head.shorthand().map(str::to_owned)); + let matches = actual.as_deref() == Some(expected); + checks.push(PreflightCheck { + code: "git.branch".into(), + level: if matches { "pass" } else { "warning" }.into(), + summary: if matches { + format!("Current branch matches {expected}") + } else { + format!( + "Current branch {:?} does not match configured branch {expected}", + actual + ) + }, + details: Some(serde_json::json!({ "expected": expected, "actual": actual })), + }); + } +} + +fn inspect_commands(path: &Path, profile: &ProjectCommandProfileRow, checks: &mut Vec) { + for (name, command) in [ + ("install", profile.install_command.as_deref()), + ("format", profile.format_command.as_deref()), + ("lint", profile.lint_command.as_deref()), + ("typecheck", profile.typecheck_command.as_deref()), + ("unit_test", profile.unit_test_command.as_deref()), + ("integration_test", profile.integration_test_command.as_deref()), + ("e2e", profile.e2e_command.as_deref()), + ("build", profile.build_command.as_deref()), + ("security_scan", profile.security_scan_command.as_deref()), + ] { + let Some(command) = command else { continue }; + let program = command_program(command); + let available = program + .as_deref() + .is_some_and(|program| program_available(path, program)); + checks.push(check( + &format!("command.{name}"), + if available { "pass" } else { "fail" }, + if available { + format!("Command executable is available: {command}") + } else { + format!("Command executable is unavailable: {command}") + }, + )); + } +} + +fn command_program(command: &str) -> Option { + command + .split_whitespace() + .find(|part| !part.contains('=') || part.starts_with('/') || part.starts_with("./")) + .map(|part| part.trim_matches(['\'', '"']).to_owned()) +} + +fn program_available(project_path: &Path, program: &str) -> bool { + let program_path = Path::new(program); + if program_path.is_absolute() { + program_path.is_file() + } else if program.contains('/') { + project_path.join(program_path).is_file() + } else { + which::which(program).is_ok() + } +} + +fn inspect_runtime(path: &Path, runtime: &ProjectRuntimeProfileRow, checks: &mut Vec) { + let detected = [ + ("rust", "Cargo.toml"), + ("typescript", "package.json"), + ("python", "pyproject.toml"), + ] + .into_iter() + .find_map(|(language, marker)| path.join(marker).is_file().then_some(language)); + if let (Some(configured), Some(detected)) = (runtime.language.as_deref(), detected) { + checks.push(check( + "runtime.language", + if configured.eq_ignore_ascii_case(detected) { + "pass" + } else { + "warning" + }, + format!("Configured language is {configured}; detected marker suggests {detected}"), + )); + } +} + +fn inspect_agent(agent_id: &str, snapshot: Option) -> AgentPreflightResult { + let Some(snapshot) = snapshot else { + return AgentPreflightResult { + agent_id: agent_id.into(), + level: "fail".into(), + summary: "Agent does not exist".into(), + snapshot: None, + }; + }; + let healthy = snapshot.enabled + && snapshot.installed + && matches!(snapshot.status.as_str(), "online" | "available") + && snapshot + .last_check_status + .as_deref() + .is_some_and(|status| matches!(status, "online" | "available")); + let stale = snapshot + .last_check_at + .is_none_or(|checked_at| now_ms().saturating_sub(checked_at) > AGENT_SNAPSHOT_STALE_MS); + let dynamic_stale = snapshot + .dynamic_probe + .as_ref() + .is_some_and(|probe| now_ms().saturating_sub(probe.checked_at) > AGENT_SNAPSHOT_STALE_MS); + let dynamic_missing = snapshot.agent_type == "acp" && snapshot.dynamic_probe.is_none(); + let dynamic_failed = snapshot.dynamic_probe.as_ref().is_some_and(|probe| !probe.is_usable()); + let (level, summary) = if !healthy { + ("fail", "Agent is not currently healthy") + } else if dynamic_missing { + ("fail", "ACP Agent has no successful dynamic probe") + } else if dynamic_stale { + ("fail", "Agent dynamic probe is stale") + } else if dynamic_failed { + ("fail", "Agent failed the dynamic capability probe") + } else if stale { + ("warning", "Agent health snapshot is stale") + } else { + ("pass", "Agent is available") + }; + AgentPreflightResult { + agent_id: agent_id.into(), + level: level.into(), + summary: summary.into(), + snapshot: Some(snapshot), + } +} + +fn overall_level<'a>(levels: impl Iterator) -> String { + let mut warning = false; + for level in levels { + if level == "fail" { + return "fail".into(); + } + warning |= level == "warning"; + } + if warning { "warning" } else { "pass" }.into() +} + +fn provider_project_name(project_id: &str) -> String { + format!("aionui-project-{project_id}") +} + +fn provider_project_error(error: KnowledgeProviderError) -> ProjectError { + ProjectError::Internal(format!("knowledge provider {}", error.category())) +} + +fn serialize_string_list(values: &[String]) -> Result { + serde_json::to_string(values).map_err(|_| ProjectError::Internal("invalid project knowledge data".into())) +} + +fn parse_string_list(value: &str) -> Result, ProjectError> { + serde_json::from_str(value).map_err(|_| ProjectError::Internal("invalid project knowledge data".into())) +} + +fn knowledge_status_from_row(row: &ProjectKnowledgeIndexRow) -> Result { + Ok(ProjectKnowledgeStatus { + project_id: row.project_id.clone(), + provider: row.provider.clone(), + provider_project_name: row.provider_project_name.clone(), + provider_version: row.provider_version.clone(), + status: row.status.clone(), + generation: row.generation, + source_commit: row.source_commit.clone(), + indexed_at: row.indexed_at, + changed_paths: parse_string_list(&row.changed_paths_json)?, + error_category: row.error_category.clone(), + updated_at: row.updated_at, + }) +} + +fn validate_provider_result( + result: &ProjectKnowledgeProviderResult, + request: &ProjectKnowledgeProviderRequest, +) -> Result<(), ProjectError> { + if result.provider_project_name != request.provider_project_name + || result.source_commit != request.source_commit + || result.changed_paths != request.changed_paths + || result.facts.len() > 500 + { + return Err(provider_project_error(KnowledgeProviderError::MalformedOutput)); + } + Ok(()) +} + +fn normalize_and_validate_facts(facts: &mut Vec, indexed_at: i64) -> Result<(), ProjectError> { + if facts.len() > 500 { + return Err(provider_project_error(KnowledgeProviderError::MalformedOutput)); + } + for fact in facts.iter_mut() { + if !matches!( + fact.kind.as_str(), + "symbol" | "caller" | "test" | "route" | "data_entity" | "architecture" + ) || fact.name.trim().is_empty() + || !safe_relative_source_path(&fact.source_path) + || fact.source_line.is_some_and(|line| line <= 0) + { + return Err(provider_project_error(KnowledgeProviderError::MalformedOutput)); + } + fact.name = fact.name.trim().to_owned(); + fact.indexed_at = indexed_at; + } + facts.sort_by(|left, right| { + (&left.kind, &left.name, &left.source_path, left.source_line).cmp(&( + &right.kind, + &right.name, + &right.source_path, + right.source_line, + )) + }); + facts.dedup_by(|left, right| { + left.kind == right.kind + && left.name == right.name + && left.qualified_name == right.qualified_name + && left.source_path == right.source_path + && left.source_line == right.source_line + }); + Ok(()) +} + +fn safe_relative_source_path(value: &str) -> bool { + let path = Path::new(value); + !value.is_empty() + && !path.is_absolute() + && !path.components().any(|component| { + matches!( + component, + std::path::Component::ParentDir | std::path::Component::RootDir | std::path::Component::Prefix(_) + ) + }) +} + +fn validate_context(context: &ProjectTaskContext) -> Result<(), ProjectError> { + for values in [ + &context.symbols, + &context.callers, + &context.tests, + &context.routes, + &context.data_entities, + ] { + if values.len() > 20 || values.iter().any(|value| value.trim().is_empty() || value.len() > 1000) { + return Err(provider_project_error(KnowledgeProviderError::MalformedOutput)); + } + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::inspect_agent; + use crate::types::AgentCapabilitySnapshot; + + #[test] + fn healthy_acp_agent_without_dynamic_probe_fails_formal_preflight() { + let now = aionui_common::now_ms(); + let result = inspect_agent( + "codex", + Some(AgentCapabilitySnapshot { + id: "codex".into(), + agent_type: "acp".into(), + enabled: true, + installed: true, + status: "online".into(), + last_check_status: Some("online".into()), + last_check_at: Some(now), + last_success_at: Some(now), + agent_capabilities: None, + available_models: None, + available_modes: None, + available_commands: None, + dynamic_probe: None, + }), + ); + + assert_eq!(result.level, "fail"); + assert!(result.summary.contains("no successful dynamic probe")); + } +} diff --git a/crates/aionui-project/src/types.rs b/crates/aionui-project/src/types.rs new file mode 100644 index 000000000..9990117ae --- /dev/null +++ b/crates/aionui-project/src/types.rs @@ -0,0 +1,131 @@ +use aionui_api_types::AgentDynamicProbeResult; +use aionui_common::TimestampMs; +use serde::{Deserialize, Serialize}; + +use aionui_api_types::ProjectRepositoryFacts; +use aionui_db::models::ProjectRow; + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct CreateProjectInput { + pub name: String, + pub local_path: String, + pub repository_url: Option, + pub default_branch: Option, + #[serde(default = "default_project_type")] + pub project_type: String, +} + +fn default_project_type() -> String { + "unknown".into() +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct OnboardProjectResult { + pub project: ProjectRow, + pub repository: ProjectRepositoryFacts, +} + +#[derive(Debug, Clone, Default, Serialize, Deserialize)] +pub struct UpdateProjectInput { + pub name: Option, + pub local_path: Option, + pub repository_url: Option>, + pub default_branch: Option>, + pub project_type: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ProjectCommandProfileInput { + pub install_command: Option, + pub format_command: Option, + pub lint_command: Option, + pub typecheck_command: Option, + pub unit_test_command: Option, + pub integration_test_command: Option, + pub e2e_command: Option, + pub build_command: Option, + pub security_scan_command: Option, + #[serde(default = "default_command_timeout")] + pub command_timeout_seconds: i64, +} + +impl Default for ProjectCommandProfileInput { + fn default() -> Self { + Self { + install_command: None, + format_command: None, + lint_command: None, + typecheck_command: None, + unit_test_command: None, + integration_test_command: None, + e2e_command: None, + build_command: None, + security_scan_command: None, + command_timeout_seconds: default_command_timeout(), + } + } +} + +fn default_command_timeout() -> i64 { + 900 +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ProjectRuntimeProfileInput { + #[serde(default = "default_environment_kind")] + pub environment_kind: String, + pub language: Option, + pub package_manager: Option, + pub runtime_version: Option, + #[serde(default)] + pub env_keys: Vec, + #[serde(default)] + pub metadata: serde_json::Value, +} + +fn default_environment_kind() -> String { + "local".into() +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct AgentCapabilitySnapshot { + pub id: String, + pub agent_type: String, + pub enabled: bool, + pub installed: bool, + pub status: String, + pub last_check_status: Option, + pub last_check_at: Option, + pub last_success_at: Option, + pub agent_capabilities: Option, + pub available_models: Option, + pub available_modes: Option, + pub available_commands: Option, + pub dynamic_probe: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct PreflightCheck { + pub code: String, + pub level: String, + pub summary: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub details: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct AgentPreflightResult { + pub agent_id: String, + pub level: String, + pub summary: String, + pub snapshot: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ProjectPreflightResult { + pub project_id: String, + pub overall_status: String, + pub checks: Vec, + pub agents: Vec, + pub checked_at: TimestampMs, +} diff --git a/crates/aionui-project/tests/project_knowledge.rs b/crates/aionui-project/tests/project_knowledge.rs new file mode 100644 index 000000000..b6a39a6b9 --- /dev/null +++ b/crates/aionui-project/tests/project_knowledge.rs @@ -0,0 +1,335 @@ +use std::path::Path; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::{Arc, Mutex}; + +use aionui_db::{ + IConversationRepository, IProjectRepository, ITeamRepository, SqliteConversationRepository, + SqliteProjectRepository, SqliteTeamRepository, init_database_memory, +}; +use aionui_project::{ + AgentCapabilitySnapshot, CodebaseMemoryCliProvider, CreateProjectInput, KnowledgeProviderError, + ProjectAgentCapabilityPort, ProjectError, ProjectKnowledgeFact, ProjectKnowledgeProvider, + ProjectKnowledgeProviderHealth, ProjectKnowledgeProviderRequest, ProjectKnowledgeProviderResult, ProjectService, + ProjectTaskContext, +}; + +struct NoAgents; + +#[async_trait::async_trait] +impl ProjectAgentCapabilityPort for NoAgents { + async fn snapshot(&self, _id: &str, _refresh: bool) -> Result, ProjectError> { + Ok(None) + } +} + +#[derive(Default)] +struct FakeKnowledgeProvider { + health_error: Mutex>, + result_error: Mutex>, + index_calls: AtomicUsize, + update_calls: AtomicUsize, +} + +impl FakeKnowledgeProvider { + fn unavailable() -> Self { + Self { + health_error: Mutex::new(Some(KnowledgeProviderError::Unavailable)), + ..Default::default() + } + } + + fn malformed() -> Self { + Self { + result_error: Mutex::new(Some(KnowledgeProviderError::MalformedOutput)), + ..Default::default() + } + } + + fn result(&self, request: &ProjectKnowledgeProviderRequest) -> ProjectKnowledgeProviderResult { + ProjectKnowledgeProviderResult { + provider_project_name: request.provider_project_name.clone(), + source_commit: request.source_commit.clone(), + changed_paths: request.changed_paths.clone(), + facts: vec![ProjectKnowledgeFact { + kind: "symbol".into(), + name: "run_task".into(), + qualified_name: Some("app.runner.run_task".into()), + source_path: "src/runner.rs".into(), + source_line: Some(42), + indexed_at: 0, + }], + } + } +} + +#[async_trait::async_trait] +impl ProjectKnowledgeProvider for FakeKnowledgeProvider { + async fn health(&self) -> Result { + if let Some(error) = self.health_error.lock().unwrap().clone() { + return Err(error); + } + Ok(ProjectKnowledgeProviderHealth { + provider: "codebase-memory".into(), + version: Some("test".into()), + }) + } + + async fn index( + &self, + request: &ProjectKnowledgeProviderRequest, + ) -> Result { + self.index_calls.fetch_add(1, Ordering::SeqCst); + if let Some(error) = self.result_error.lock().unwrap().clone() { + return Err(error); + } + Ok(self.result(request)) + } + + async fn update( + &self, + request: &ProjectKnowledgeProviderRequest, + ) -> Result { + self.update_calls.fetch_add(1, Ordering::SeqCst); + Ok(self.result(request)) + } + + async fn architecture( + &self, + _provider_project_name: &str, + ) -> Result, KnowledgeProviderError> { + Ok(vec![ProjectKnowledgeFact { + kind: "route".into(), + name: "POST /api/run".into(), + qualified_name: None, + source_path: "src/routes.rs".into(), + source_line: Some(18), + indexed_at: 0, + }]) + } + + async fn search( + &self, + _provider_project_name: &str, + _query: &str, + ) -> Result, KnowledgeProviderError> { + Ok(Vec::new()) + } + + async fn trace( + &self, + _provider_project_name: &str, + _function_name: &str, + ) -> Result, KnowledgeProviderError> { + Ok(Vec::new()) + } + + async fn task_context( + &self, + provider_project_name: &str, + query: &str, + generation: i64, + ) -> Result { + Ok(ProjectTaskContext { + id: String::new(), + project_id: String::new(), + provider_project_name: provider_project_name.into(), + generation, + query: query.into(), + symbols: vec!["app.runner.run_task".into()], + callers: vec!["app.routes.start_run".into()], + tests: vec!["tests/run_task.rs".into()], + routes: vec!["POST /api/run".into()], + data_entities: vec!["development_runs".into()], + created_at: 0, + }) + } +} + +fn commit_file(root: &Path, name: &str, contents: &str, message: &str) -> String { + let repository = git2::Repository::open(root) + .or_else(|_| git2::Repository::init(root)) + .unwrap(); + std::fs::write(root.join(name), contents).unwrap(); + let mut index = repository.index().unwrap(); + index.add_path(Path::new(name)).unwrap(); + index.write().unwrap(); + let tree_id = index.write_tree().unwrap(); + let tree = repository.find_tree(tree_id).unwrap(); + let signature = git2::Signature::now("Aion test", "aion@example.test").unwrap(); + let parents = repository + .head() + .ok() + .and_then(|head| head.target()) + .and_then(|id| repository.find_commit(id).ok()) + .into_iter() + .collect::>(); + let parent_refs = parents.iter().collect::>(); + repository + .commit(Some("HEAD"), &signature, &signature, message, &tree, &parent_refs) + .unwrap() + .to_string() +} + +async fn service(provider: Arc) -> (ProjectService, aionui_db::Database) { + let db = init_database_memory().await.unwrap(); + let project_repo: Arc = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + let conversation_repo: Arc = + Arc::new(SqliteConversationRepository::new(db.pool().clone())); + let team_repo: Arc = Arc::new(SqliteTeamRepository::new(db.pool().clone())); + ( + ProjectService::new(project_repo, conversation_repo, team_repo, Arc::new(NoAgents)) + .with_knowledge_provider(provider), + db, + ) +} + +async fn create_project(service: &ProjectService, root: &Path) -> String { + service + .create( + "system_default_user", + CreateProjectInput { + name: "Knowledge project".into(), + local_path: root.to_string_lossy().into_owned(), + repository_url: None, + default_branch: Some("main".into()), + project_type: "single".into(), + }, + ) + .await + .unwrap() + .id +} + +#[tokio::test] +async fn initial_index_unchanged_noop_and_changed_file_incremental_update() { + let temp = tempfile::tempdir().unwrap(); + commit_file(temp.path(), "src.rs", "fn first() {}\n", "initial"); + let provider = Arc::new(FakeKnowledgeProvider::default()); + let (service, _db) = service(provider.clone()).await; + let project_id = create_project(&service, temp.path()).await; + + let initial = service + .refresh_knowledge("system_default_user", &project_id) + .await + .unwrap(); + assert_eq!(initial.status, "healthy"); + assert_eq!(initial.generation, 1); + assert_eq!(provider.index_calls.load(Ordering::SeqCst), 1); + + let unchanged = service + .refresh_knowledge("system_default_user", &project_id) + .await + .unwrap(); + assert_eq!(unchanged.generation, 1); + assert_eq!(provider.index_calls.load(Ordering::SeqCst), 1); + assert_eq!(provider.update_calls.load(Ordering::SeqCst), 0); + + std::fs::write(temp.path().join("src.rs"), "fn changed() {}\n").unwrap(); + let stale = service + .get_knowledge_status("system_default_user", &project_id) + .await + .unwrap(); + assert_eq!(stale.status, "stale"); + assert_eq!(stale.changed_paths, vec!["src.rs"]); + + let updated = service + .refresh_knowledge("system_default_user", &project_id) + .await + .unwrap(); + assert_eq!(updated.status, "healthy"); + assert_eq!(updated.generation, 2); + assert_eq!(provider.update_calls.load(Ordering::SeqCst), 1); +} + +#[tokio::test] +async fn unavailable_and_malformed_provider_states_are_explicit_and_redacted() { + for (provider, expected) in [ + (Arc::new(FakeKnowledgeProvider::unavailable()), "unavailable"), + (Arc::new(FakeKnowledgeProvider::malformed()), "failed"), + ] { + let temp = tempfile::tempdir().unwrap(); + commit_file(temp.path(), "lib.rs", "pub fn demo() {}\n", "initial"); + let (service, _db) = service(provider).await; + let project_id = create_project(&service, temp.path()).await; + + let error = service + .refresh_knowledge("system_default_user", &project_id) + .await + .unwrap_err(); + assert!(!error.to_string().contains("stderr")); + let status = service + .get_knowledge_status("system_default_user", &project_id) + .await + .unwrap(); + assert_eq!(status.status, expected); + assert!(matches!( + status.error_category.as_deref(), + Some("unavailable" | "malformed_output") + )); + } +} + +#[tokio::test] +async fn facts_keep_source_and_index_time_and_reads_are_owner_scoped() { + let temp = tempfile::tempdir().unwrap(); + commit_file(temp.path(), "main.rs", "fn main() {}\n", "initial"); + let provider = Arc::new(FakeKnowledgeProvider::default()); + let (service, _db) = service(provider).await; + let project_id = create_project(&service, temp.path()).await; + let indexed = service + .refresh_knowledge("system_default_user", &project_id) + .await + .unwrap(); + + let facts = service + .list_knowledge_facts("system_default_user", &project_id) + .await + .unwrap(); + assert_eq!(facts.len(), 2); + assert!(facts.iter().all(|fact| !fact.source_path.is_empty())); + assert!(facts.iter().all(|fact| fact.indexed_at == indexed.indexed_at.unwrap())); + assert!(service.list_knowledge_facts("other-user", &project_id).await.is_err()); + + let context = service + .task_context("system_default_user", &project_id, "change run task") + .await + .unwrap(); + assert_eq!(context.generation, indexed.generation); + assert_eq!(context.symbols, vec!["app.runner.run_task"]); + assert_eq!(context.callers, vec!["app.routes.start_run"]); + assert_eq!(context.tests, vec!["tests/run_task.rs"]); + assert_eq!(context.routes, vec!["POST /api/run"]); + assert_eq!(context.data_entities, vec!["development_runs"]); + assert!(service.task_context("other-user", &project_id, "secret").await.is_err()); +} + +#[cfg(unix)] +#[tokio::test] +async fn cli_adapter_rejects_malformed_stdout_without_exposing_it() { + use std::os::unix::fs::PermissionsExt; + + let temp = tempfile::tempdir().unwrap(); + let executable = temp.path().join("fake-codebase-memory"); + std::fs::write( + &executable, + "#!/bin/sh\nif [ \"$1\" = \"--version\" ]; then echo 'codebase-memory-mcp test'; else echo 'private stderr payload' >&2; echo 'not-json'; fi\n", + ) + .unwrap(); + let mut permissions = std::fs::metadata(&executable).unwrap().permissions(); + permissions.set_mode(0o700); + std::fs::set_permissions(&executable, permissions).unwrap(); + let provider = CodebaseMemoryCliProvider::new(executable.to_string_lossy()); + + assert_eq!(provider.health().await.unwrap().provider, "codebase-memory"); + let error = provider + .index(&ProjectKnowledgeProviderRequest { + project_path: temp.path().to_string_lossy().into_owned(), + provider_project_name: "test-project".into(), + source_commit: None, + changed_paths: Vec::new(), + }) + .await + .unwrap_err(); + assert_eq!(error, KnowledgeProviderError::MalformedOutput); + assert!(!error.to_string().contains("private stderr payload")); +} diff --git a/crates/aionui-project/tests/project_repository_source.rs b/crates/aionui-project/tests/project_repository_source.rs new file mode 100644 index 000000000..d6cfe8931 --- /dev/null +++ b/crates/aionui-project/tests/project_repository_source.rs @@ -0,0 +1,234 @@ +use std::path::Path; + +use std::sync::Arc; + +use aionui_db::{ + IConversationRepository, IProjectRepository, ITeamRepository, SqliteConversationRepository, + SqliteProjectRepository, SqliteTeamRepository, init_database_memory, +}; +use aionui_project::{ + AgentCapabilitySnapshot, DirtyWorktreeChoice, ProjectAgentCapabilityPort, ProjectError, + ProjectRepositoryOnboardingInput, ProjectService, RepositoryOnboarder, RepositorySource, +}; + +struct NoAgents; + +#[async_trait::async_trait] +impl ProjectAgentCapabilityPort for NoAgents { + async fn snapshot(&self, _id: &str, _refresh: bool) -> Result, ProjectError> { + Ok(None) + } +} + +fn commit_file(root: &Path, name: &str, contents: &str) { + let repository = git2::Repository::init(root).unwrap(); + std::fs::write(root.join(name), contents).unwrap(); + let mut index = repository.index().unwrap(); + index.add_path(Path::new(name)).unwrap(); + index.write().unwrap(); + let tree_id = index.write_tree().unwrap(); + let tree = repository.find_tree(tree_id).unwrap(); + let signature = git2::Signature::now("Aion test", "aion@example.test").unwrap(); + repository + .commit(Some("HEAD"), &signature, &signature, "initial", &tree, &[]) + .unwrap(); +} + +#[tokio::test] +async fn local_registration_detects_repository_and_project_facts() { + let temp = tempfile::tempdir().unwrap(); + let repository = temp.path().join("repository"); + std::fs::create_dir(&repository).unwrap(); + commit_file(&repository, "Cargo.toml", "[workspace]\nmembers = [\"crates/*\"]\n"); + std::fs::create_dir_all(repository.join("crates/demo/src")).unwrap(); + std::fs::write( + repository.join("crates/demo/Cargo.toml"), + "[package]\nname = \"demo\"\n", + ) + .unwrap(); + std::fs::write(repository.join("crates/demo/src/lib.rs"), "pub fn demo() {}\n").unwrap(); + std::fs::write(repository.join("AGENTS.md"), "# Project rules\n").unwrap(); + std::fs::write( + repository.join("asset.bin"), + "version https://git-lfs.github.com/spec/v1\noid sha256:abc\nsize 3\n", + ) + .unwrap(); + std::fs::write( + repository.join(".gitmodules"), + "[submodule \"vendor/demo\"]\n\tpath = vendor/demo\n\turl = https://example.test/demo.git\n", + ) + .unwrap(); + + let managed_root = temp.path().join("managed"); + let onboarder = RepositoryOnboarder::new(managed_root); + let facts = onboarder + .onboard( + RepositorySource::Local { + path: repository.join(".").to_string_lossy().into_owned(), + }, + DirtyWorktreeChoice::Preserve, + ) + .await + .unwrap(); + + assert_eq!(facts.local_path, repository.canonicalize().unwrap().to_string_lossy()); + assert!(facts.baseline_commit.is_some()); + assert!(facts.dirty); + assert!(facts.languages.contains(&"rust".to_owned())); + assert!(facts.package_managers.contains(&"cargo".to_owned())); + assert!(facts.rules_files.contains(&"AGENTS.md".to_owned())); + assert!(facts.monorepo_packages.contains(&"crates/demo".to_owned())); + assert!(facts.lfs_detected); + assert_eq!(facts.submodules[0].path, "vendor/demo"); +} + +#[tokio::test] +async fn dirty_choices_reject_preserve_or_capture_a_non_destructive_snapshot() { + let temp = tempfile::tempdir().unwrap(); + let repository = temp.path().join("repository"); + std::fs::create_dir(&repository).unwrap(); + commit_file(&repository, "README.md", "baseline\n"); + std::fs::write(repository.join("README.md"), "changed\n").unwrap(); + std::fs::write(repository.join("new.txt"), "untracked\n").unwrap(); + let onboarder = RepositoryOnboarder::new(temp.path().join("managed")); + + let rejected = onboarder + .onboard( + RepositorySource::Local { + path: repository.to_string_lossy().into_owned(), + }, + DirtyWorktreeChoice::Reject, + ) + .await + .unwrap_err(); + assert!(rejected.to_string().contains("dirty")); + + let preserved = onboarder + .onboard( + RepositorySource::Local { + path: repository.to_string_lossy().into_owned(), + }, + DirtyWorktreeChoice::Preserve, + ) + .await + .unwrap(); + assert!(preserved.dirty); + assert!(preserved.dirty_snapshot_ref.is_none()); + + let snapshotted = onboarder + .onboard( + RepositorySource::Local { + path: repository.to_string_lossy().into_owned(), + }, + DirtyWorktreeChoice::Snapshot, + ) + .await + .unwrap(); + let snapshot = snapshotted.dirty_snapshot_ref.unwrap(); + assert!(Path::new(&snapshot).join("changes.patch").is_file()); + assert!(Path::new(&snapshot).join("untracked/new.txt").is_file()); + assert_eq!( + std::fs::read_to_string(repository.join("README.md")).unwrap(), + "changed\n" + ); + assert!(repository.join("new.txt").is_file()); +} + +#[tokio::test] +async fn clone_uses_a_canonical_managed_child_and_validates_branch_and_credentials() { + let temp = tempfile::tempdir().unwrap(); + let source = temp.path().join("source"); + std::fs::create_dir(&source).unwrap(); + commit_file(&source, "README.md", "clone me\n"); + let managed_root = temp.path().join("managed"); + let onboarder = RepositoryOnboarder::new(&managed_root); + + let facts = onboarder + .onboard( + RepositorySource::Clone { + url: format!("file://{}", source.to_string_lossy()), + destination_name: "safe-child".into(), + branch: None, + credential_reference: Some("vault:github-production".into()), + }, + DirtyWorktreeChoice::Reject, + ) + .await + .unwrap(); + + let canonical_root = managed_root.canonicalize().unwrap(); + assert!(Path::new(&facts.local_path).starts_with(&canonical_root)); + assert_eq!(facts.credential_reference.as_deref(), Some("vault:github-production")); + let serialized = serde_json::to_string(&facts).unwrap(); + assert!(!serialized.contains("token")); + assert!(!serialized.contains("password")); + + let missing_branch = onboarder + .onboard( + RepositorySource::Clone { + url: format!("file://{}", source.to_string_lossy()), + destination_name: "missing-branch".into(), + branch: Some("does-not-exist".into()), + credential_reference: None, + }, + DirtyWorktreeChoice::Reject, + ) + .await + .unwrap_err(); + assert!(missing_branch.to_string().contains("clone")); + + for url in [ + "https://example.test/org/repo.git", + "ssh://git@example.test/org/repo.git", + "git@example.test:org/repo.git", + ] { + RepositoryOnboarder::validate_clone_url(url).unwrap(); + } + assert!(RepositoryOnboarder::validate_clone_url("https://token@example.test/repo.git").is_err()); + assert!(RepositoryOnboarder::validate_destination_name("../escape").is_err()); + assert!(RepositoryOnboarder::validate_branch_name("../../escape").is_err()); + assert!(RepositoryOnboarder::validate_submodule_path("../outside").is_err()); +} + +#[tokio::test] +async fn project_service_persists_repository_facts_for_owner_scoped_reads() { + let temp = tempfile::tempdir().unwrap(); + let repository = temp.path().join("repository"); + std::fs::create_dir(&repository).unwrap(); + commit_file(&repository, "main.rs", "fn main() {}\n"); + let database = init_database_memory().await.unwrap(); + let pool = database.pool().clone(); + let project_repo: Arc = Arc::new(SqliteProjectRepository::new(pool.clone())); + let conversation_repo: Arc = Arc::new(SqliteConversationRepository::new(pool.clone())); + let team_repo: Arc = Arc::new(SqliteTeamRepository::new(pool)); + let service = ProjectService::new(project_repo, conversation_repo, team_repo, Arc::new(NoAgents)) + .with_managed_project_root(temp.path().join("managed")); + + let created = service + .onboard( + "system_default_user", + ProjectRepositoryOnboardingInput { + name: "Persisted repository".into(), + source: RepositorySource::Local { + path: repository.to_string_lossy().into_owned(), + }, + dirty_worktree_choice: DirtyWorktreeChoice::Reject, + project_type: "single".into(), + }, + ) + .await + .unwrap(); + let persisted = service + .get_repository_facts("system_default_user", &created.project.id) + .await + .unwrap(); + + assert_eq!(persisted.baseline_commit, created.repository.baseline_commit); + assert_eq!(persisted.languages, vec!["rust"]); + assert!( + service + .get_repository_facts("another-user", &created.project.id) + .await + .is_err() + ); +} diff --git a/crates/aionui-project/tests/project_routes.rs b/crates/aionui-project/tests/project_routes.rs new file mode 100644 index 000000000..0d9f39209 --- /dev/null +++ b/crates/aionui-project/tests/project_routes.rs @@ -0,0 +1,468 @@ +use std::sync::Arc; + +use aionui_auth::CurrentUser; +use aionui_db::{ + IConversationRepository, IProjectRepository, ITeamRepository, SqliteConversationRepository, + SqliteProjectRepository, SqliteTeamRepository, init_database_memory, +}; +use aionui_project::{ + AgentCapabilitySnapshot, KnowledgeProviderError, ProjectAgentCapabilityPort, ProjectError, ProjectKnowledgeFact, + ProjectKnowledgeProvider, ProjectKnowledgeProviderHealth, ProjectKnowledgeProviderRequest, + ProjectKnowledgeProviderResult, ProjectRouterState, ProjectService, ProjectTaskContext, project_routes, +}; +use axum::body::Body; +use axum::http::{Request, StatusCode}; +use axum::{Extension, Router}; +use http_body_util::BodyExt; +use tower::ServiceExt; + +struct NoAgents; + +#[async_trait::async_trait] +impl ProjectAgentCapabilityPort for NoAgents { + async fn snapshot(&self, _id: &str, _refresh: bool) -> Result, ProjectError> { + Ok(None) + } +} + +struct RouteKnowledge; + +#[async_trait::async_trait] +impl ProjectKnowledgeProvider for RouteKnowledge { + async fn health(&self) -> Result { + Ok(ProjectKnowledgeProviderHealth { + provider: "codebase-memory".into(), + version: Some("test".into()), + }) + } + + async fn index( + &self, + request: &ProjectKnowledgeProviderRequest, + ) -> Result { + Ok(ProjectKnowledgeProviderResult { + provider_project_name: request.provider_project_name.clone(), + source_commit: request.source_commit.clone(), + changed_paths: request.changed_paths.clone(), + facts: vec![ProjectKnowledgeFact { + kind: "symbol".into(), + name: "main".into(), + qualified_name: Some("app.main".into()), + source_path: "main.rs".into(), + source_line: Some(1), + indexed_at: 0, + }], + }) + } + + async fn update( + &self, + request: &ProjectKnowledgeProviderRequest, + ) -> Result { + self.index(request).await + } + + async fn architecture( + &self, + _provider_project_name: &str, + ) -> Result, KnowledgeProviderError> { + Ok(Vec::new()) + } + + async fn search( + &self, + _provider_project_name: &str, + _query: &str, + ) -> Result, KnowledgeProviderError> { + Ok(Vec::new()) + } + + async fn trace( + &self, + _provider_project_name: &str, + _function_name: &str, + ) -> Result, KnowledgeProviderError> { + Ok(Vec::new()) + } + + async fn task_context( + &self, + provider_project_name: &str, + query: &str, + generation: i64, + ) -> Result { + Ok(ProjectTaskContext { + id: String::new(), + project_id: String::new(), + provider_project_name: provider_project_name.into(), + generation, + query: query.into(), + symbols: vec!["app.main".into()], + callers: Vec::new(), + tests: Vec::new(), + routes: Vec::new(), + data_entities: Vec::new(), + created_at: 0, + }) + } +} + +async fn app() -> (Router, tempfile::TempDir, aionui_db::Database) { + let db = init_database_memory().await.unwrap(); + let project_repo: Arc = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + let conversation_repo: Arc = + Arc::new(SqliteConversationRepository::new(db.pool().clone())); + let team_repo: Arc = Arc::new(SqliteTeamRepository::new(db.pool().clone())); + let service = Arc::new( + ProjectService::new(project_repo, conversation_repo, team_repo, Arc::new(NoAgents)) + .with_knowledge_provider(Arc::new(RouteKnowledge)), + ); + let temp = tempfile::tempdir().unwrap(); + let router = project_routes(ProjectRouterState { service }).layer(Extension(CurrentUser { + id: "system_default_user".into(), + username: "system_default_user".into(), + })); + (router, temp, db) +} + +async fn json(response: axum::response::Response) -> serde_json::Value { + let bytes = response.into_body().collect().await.unwrap().to_bytes(); + serde_json::from_slice(&bytes).unwrap() +} + +#[tokio::test] +async fn project_routes_support_crud_profiles_and_preflight() { + let (app, temp, _db) = app().await; + let create = Request::builder() + .method("POST") + .uri("/api/projects") + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "name": "Example", + "local_path": temp.path(), + "project_type": "unknown" + }) + .to_string(), + )) + .unwrap(); + let response = app.clone().oneshot(create).await.unwrap(); + assert_eq!(response.status(), StatusCode::CREATED); + let created = json(response).await; + let project_id = created["data"]["id"].as_str().unwrap(); + + let profile = Request::builder() + .method("PUT") + .uri(format!("/api/projects/{project_id}/command-profile")) + .header("content-type", "application/json") + .body(Body::from( + r#"{"unit_test_command":"cargo test","command_timeout_seconds":300}"#, + )) + .unwrap(); + assert_eq!(app.clone().oneshot(profile).await.unwrap().status(), StatusCode::OK); + + let runtime = Request::builder() + .method("PUT") + .uri(format!("/api/projects/{project_id}/runtime-profile")) + .header("content-type", "application/json") + .body(Body::from( + r#"{"environment_kind":"local","language":"rust","env_keys":["RUST_LOG"]}"#, + )) + .unwrap(); + assert_eq!(app.clone().oneshot(runtime).await.unwrap().status(), StatusCode::OK); + + let preflight = Request::builder() + .method("POST") + .uri(format!("/api/projects/{project_id}/preflight")) + .header("content-type", "application/json") + .body(Body::from(r#"{"agent_ids":[],"refresh_agents":false}"#)) + .unwrap(); + let response = app.clone().oneshot(preflight).await.unwrap(); + assert_eq!(response.status(), StatusCode::OK); + let result = json(response).await; + assert_eq!(result["data"]["project_id"], project_id); + + let list = Request::builder().uri("/api/projects").body(Body::empty()).unwrap(); + let response = app.clone().oneshot(list).await.unwrap(); + assert_eq!(response.status(), StatusCode::OK); + assert_eq!(json(response).await["data"].as_array().unwrap().len(), 1); + + let delete = Request::builder() + .method("DELETE") + .uri(format!("/api/projects/{project_id}")) + .body(Body::empty()) + .unwrap(); + assert_eq!(app.oneshot(delete).await.unwrap().status(), StatusCode::NO_CONTENT); +} + +#[tokio::test] +async fn project_routes_onboard_and_return_repository_evidence() { + let (app, temp, _db) = app().await; + let repository_path = temp.path().join("repository"); + std::fs::create_dir(&repository_path).unwrap(); + let repository = git2::Repository::init(&repository_path).unwrap(); + std::fs::write(repository_path.join("main.rs"), "fn main() {}\n").unwrap(); + let mut index = repository.index().unwrap(); + index.add_path(std::path::Path::new("main.rs")).unwrap(); + index.write().unwrap(); + let tree_id = index.write_tree().unwrap(); + let tree = repository.find_tree(tree_id).unwrap(); + let signature = git2::Signature::now("Aion test", "aion@example.test").unwrap(); + repository + .commit(Some("HEAD"), &signature, &signature, "initial", &tree, &[]) + .unwrap(); + + let request = Request::builder() + .method("POST") + .uri("/api/projects/onboard") + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "name": "Onboarded", + "source": { "kind": "local", "path": repository_path }, + "dirty_worktree_choice": "reject", + "project_type": "single" + }) + .to_string(), + )) + .unwrap(); + let response = app.clone().oneshot(request).await.unwrap(); + assert_eq!(response.status(), StatusCode::CREATED); + let body = json(response).await; + let project_id = body["data"]["project"]["id"].as_str().unwrap(); + assert!(body["data"]["repository"]["baseline_commit"].as_str().is_some()); + assert_eq!(body["data"]["repository"]["languages"], serde_json::json!(["rust"])); + + let evidence = Request::builder() + .uri(format!("/api/projects/{project_id}/repository-facts")) + .body(Body::empty()) + .unwrap(); + let evidence = json(app.oneshot(evidence).await.unwrap()).await; + assert_eq!( + evidence["data"]["baseline_commit"], + body["data"]["repository"]["baseline_commit"] + ); +} + +#[tokio::test] +async fn project_routes_refresh_knowledge_and_create_minimal_task_context() { + let (app, temp, _db) = app().await; + let repository = git2::Repository::init(temp.path()).unwrap(); + std::fs::write(temp.path().join("main.rs"), "fn main() {}\n").unwrap(); + let mut index = repository.index().unwrap(); + index.add_path(std::path::Path::new("main.rs")).unwrap(); + index.write().unwrap(); + let tree_id = index.write_tree().unwrap(); + let tree = repository.find_tree(tree_id).unwrap(); + let signature = git2::Signature::now("Aion test", "aion@example.test").unwrap(); + repository + .commit(Some("HEAD"), &signature, &signature, "initial", &tree, &[]) + .unwrap(); + let create = Request::builder() + .method("POST") + .uri("/api/projects") + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "name": "Knowledge", + "local_path": temp.path(), + "project_type": "single" + }) + .to_string(), + )) + .unwrap(); + let project_id = json(app.clone().oneshot(create).await.unwrap()).await["data"]["id"] + .as_str() + .unwrap() + .to_owned(); + + let status = Request::builder() + .uri(format!("/api/projects/{project_id}/knowledge")) + .body(Body::empty()) + .unwrap(); + assert_eq!( + json(app.clone().oneshot(status).await.unwrap()).await["data"]["status"], + "stale" + ); + + let refresh = Request::builder() + .method("POST") + .uri(format!("/api/projects/{project_id}/knowledge/refresh")) + .body(Body::empty()) + .unwrap(); + let refreshed = json(app.clone().oneshot(refresh).await.unwrap()).await; + assert_eq!(refreshed["data"]["status"], "healthy"); + assert_eq!(refreshed["data"]["generation"], 1); + + let facts = Request::builder() + .uri(format!("/api/projects/{project_id}/knowledge/facts")) + .body(Body::empty()) + .unwrap(); + assert_eq!( + json(app.clone().oneshot(facts).await.unwrap()).await["data"][0]["source_path"], + "main.rs" + ); + + let context = Request::builder() + .method("POST") + .uri(format!("/api/projects/{project_id}/knowledge/context")) + .header("content-type", "application/json") + .body(Body::from(r#"{"query":"change main"}"#)) + .unwrap(); + let context = json(app.oneshot(context).await.unwrap()).await; + assert_eq!(context["data"]["generation"], 1); + assert_eq!(context["data"]["symbols"], serde_json::json!(["app.main"])); +} + +#[tokio::test] +async fn project_routes_reject_invalid_json_and_missing_project() { + let (app, _temp, _db) = app().await; + let invalid = Request::builder() + .method("POST") + .uri("/api/projects") + .header("content-type", "application/json") + .body(Body::from("not-json")) + .unwrap(); + assert_eq!( + app.clone().oneshot(invalid).await.unwrap().status(), + StatusCode::BAD_REQUEST + ); + + let missing = Request::builder() + .uri("/api/projects/missing") + .body(Body::empty()) + .unwrap(); + assert_eq!(app.oneshot(missing).await.unwrap().status(), StatusCode::NOT_FOUND); +} + +#[tokio::test] +async fn project_routes_bind_and_resolve_an_owned_conversation() { + let (app, temp, db) = app().await; + let create = Request::builder() + .method("POST") + .uri("/api/projects") + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "name": "Linked", + "local_path": temp.path(), + "project_type": "unknown" + }) + .to_string(), + )) + .unwrap(); + let project_id = json(app.clone().oneshot(create).await.unwrap()).await["data"]["id"] + .as_str() + .unwrap() + .to_owned(); + sqlx::query( + "INSERT INTO conversations (id, user_id, name, type, extra, status, created_at, updated_at) \ + VALUES ('c1', 'system_default_user', 'Chat', 'chat', '{}', 'pending', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + + let bind = Request::builder() + .method("POST") + .uri(format!("/api/projects/{project_id}/links")) + .header("content-type", "application/json") + .body(Body::from(r#"{"resource_type":"conversation","resource_id":"c1"}"#)) + .unwrap(); + assert_eq!( + app.clone().oneshot(bind).await.unwrap().status(), + StatusCode::NO_CONTENT + ); + + let links = Request::builder() + .uri(format!("/api/projects/{project_id}/links")) + .body(Body::empty()) + .unwrap(); + assert_eq!( + json(app.clone().oneshot(links).await.unwrap()).await["data"][0]["resource_id"], + "c1" + ); + + let resolve = Request::builder() + .uri("/api/projects/by-resource?resource_type=conversation&resource_id=c1") + .body(Body::empty()) + .unwrap(); + assert_eq!( + json(app.oneshot(resolve).await.unwrap()).await["data"]["id"], + project_id + ); +} + +#[tokio::test] +async fn project_routes_replace_an_existing_resource_link() { + let (app, temp, db) = app().await; + let first_path = temp.path().join("first"); + let second_path = temp.path().join("second"); + std::fs::create_dir_all(&first_path).unwrap(); + std::fs::create_dir_all(&second_path).unwrap(); + + async fn create_project(app: &Router, name: &str, local_path: &std::path::Path) -> String { + let request = Request::builder() + .method("POST") + .uri("/api/projects") + .header("content-type", "application/json") + .body(Body::from( + serde_json::json!({ + "name": name, + "local_path": local_path, + "project_type": "unknown" + }) + .to_string(), + )) + .unwrap(); + json(app.clone().oneshot(request).await.unwrap()).await["data"]["id"] + .as_str() + .unwrap() + .to_owned() + } + + let first_id = create_project(&app, "First", &first_path).await; + let second_id = create_project(&app, "Second", &second_path).await; + sqlx::query( + "INSERT INTO conversations (id, user_id, name, type, extra, status, created_at, updated_at) \ + VALUES ('replace-c1', 'system_default_user', 'Chat', 'chat', '{}', 'pending', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + + for project_id in [&first_id, &second_id] { + let bind = Request::builder() + .method("POST") + .uri(format!("/api/projects/{project_id}/links")) + .header("content-type", "application/json") + .body(Body::from( + r#"{"resource_type":"conversation","resource_id":"replace-c1"}"#, + )) + .unwrap(); + assert_eq!( + app.clone().oneshot(bind).await.unwrap().status(), + StatusCode::NO_CONTENT + ); + } + + let resolve = Request::builder() + .uri("/api/projects/by-resource?resource_type=conversation&resource_id=replace-c1") + .body(Body::empty()) + .unwrap(); + assert_eq!( + json(app.clone().oneshot(resolve).await.unwrap()).await["data"]["id"], + second_id + ); + + let first_links = Request::builder() + .uri(format!("/api/projects/{first_id}/links")) + .body(Body::empty()) + .unwrap(); + assert!( + json(app.oneshot(first_links).await.unwrap()).await["data"] + .as_array() + .unwrap() + .is_empty() + ); +} diff --git a/crates/aionui-project/tests/project_service.rs b/crates/aionui-project/tests/project_service.rs new file mode 100644 index 000000000..31accd7c1 --- /dev/null +++ b/crates/aionui-project/tests/project_service.rs @@ -0,0 +1,365 @@ +use std::sync::Arc; +use std::sync::atomic::{AtomicBool, Ordering}; + +use aionui_db::{ + IConversationRepository, IProjectRepository, ITeamRepository, SqliteConversationRepository, + SqliteProjectRepository, SqliteTeamRepository, init_database_memory, +}; +use aionui_project::{ + AgentCapabilitySnapshot, CreateProjectInput, ProjectAgentCapabilityPort, ProjectCommandProfileInput, ProjectError, + ProjectService, +}; + +struct FakeAgents { + snapshots: Vec, + refresh_seen: Arc, +} + +impl Default for FakeAgents { + fn default() -> Self { + Self { + snapshots: Vec::new(), + refresh_seen: Arc::new(AtomicBool::new(false)), + } + } +} + +#[async_trait::async_trait] +impl ProjectAgentCapabilityPort for FakeAgents { + async fn snapshot(&self, id: &str, refresh: bool) -> Result, ProjectError> { + self.refresh_seen.store(refresh, Ordering::SeqCst); + Ok(self.snapshots.iter().find(|item| item.id == id).cloned()) + } +} + +async fn service(agents: FakeAgents) -> (ProjectService, aionui_db::Database) { + let db = init_database_memory().await.unwrap(); + let project_repo: Arc = Arc::new(SqliteProjectRepository::new(db.pool().clone())); + let conversation_repo: Arc = + Arc::new(SqliteConversationRepository::new(db.pool().clone())); + let team_repo: Arc = Arc::new(SqliteTeamRepository::new(db.pool().clone())); + ( + ProjectService::new(project_repo, conversation_repo, team_repo, Arc::new(agents)), + db, + ) +} + +#[tokio::test] +async fn create_canonicalizes_existing_path_and_scopes_reads_to_owner() { + let temp = tempfile::tempdir().unwrap(); + let nested = temp.path().join("nested"); + std::fs::create_dir(&nested).unwrap(); + let (service, _db) = service(FakeAgents::default()).await; + + let created = service + .create( + "system_default_user", + CreateProjectInput { + name: "Example".into(), + local_path: nested.join("..").join("nested").to_string_lossy().into_owned(), + repository_url: None, + default_branch: Some("main".into()), + project_type: "single".into(), + }, + ) + .await + .unwrap(); + + assert_eq!(created.local_path, nested.canonicalize().unwrap().to_string_lossy()); + assert!(service.get("other-user", &created.id).await.is_err()); +} + +#[tokio::test] +async fn preflight_reports_dirty_git_missing_command_and_unhealthy_agent() { + let temp = tempfile::tempdir().unwrap(); + git2::Repository::init(temp.path()).unwrap(); + std::fs::write(temp.path().join("untracked.txt"), "dirty").unwrap(); + let (service, _db) = service(FakeAgents { + snapshots: vec![AgentCapabilitySnapshot { + id: "codex".into(), + agent_type: "acp".into(), + enabled: true, + installed: true, + status: "offline".into(), + last_check_status: Some("unavailable".into()), + last_check_at: Some(aionui_common::now_ms()), + last_success_at: None, + agent_capabilities: None, + available_models: None, + available_modes: None, + available_commands: None, + dynamic_probe: None, + }], + ..Default::default() + }) + .await; + let project = service + .create( + "system_default_user", + CreateProjectInput { + name: "Git".into(), + local_path: temp.path().to_string_lossy().into_owned(), + repository_url: None, + default_branch: Some("main".into()), + project_type: "single".into(), + }, + ) + .await + .unwrap(); + service + .upsert_command_profile( + "system_default_user", + &project.id, + ProjectCommandProfileInput { + unit_test_command: Some("missing-tool-for-aion test".into()), + ..Default::default() + }, + ) + .await + .unwrap(); + + let result = service + .preflight("system_default_user", &project.id, &["codex".into()], false) + .await + .unwrap(); + + assert_eq!(result.overall_status, "fail"); + assert!( + result + .checks + .iter() + .any(|check| check.code == "git.dirty" && check.level == "warning") + ); + assert!( + result + .checks + .iter() + .any(|check| check.code == "command.unit_test" && check.level == "fail") + ); + assert!( + result + .agents + .iter() + .any(|agent| agent.agent_id == "codex" && agent.level == "fail") + ); +} + +#[tokio::test] +async fn explicit_agent_refresh_is_forwarded_and_healthy_snapshot_passes() { + let temp = tempfile::tempdir().unwrap(); + let refresh_seen = Arc::new(AtomicBool::new(false)); + let (service, _db) = service(FakeAgents { + snapshots: vec![AgentCapabilitySnapshot { + id: "codex".into(), + agent_type: "aionrs".into(), + enabled: true, + installed: true, + status: "online".into(), + last_check_status: Some("online".into()), + last_check_at: Some(aionui_common::now_ms()), + last_success_at: Some(aionui_common::now_ms()), + agent_capabilities: Some(serde_json::json!({ "loadSession": true })), + available_models: Some(serde_json::json!([{ "id": "gpt-5" }])), + available_modes: None, + available_commands: None, + dynamic_probe: None, + }], + refresh_seen: refresh_seen.clone(), + }) + .await; + let project = service + .create( + "system_default_user", + CreateProjectInput { + name: "Healthy".into(), + local_path: temp.path().to_string_lossy().into_owned(), + repository_url: None, + default_branch: None, + project_type: "unknown".into(), + }, + ) + .await + .unwrap(); + + let result = service + .preflight("system_default_user", &project.id, &["codex".into()], true) + .await + .unwrap(); + + assert!(refresh_seen.load(Ordering::SeqCst)); + assert_eq!(result.agents[0].level, "pass"); + assert!( + result + .checks + .iter() + .any(|check| check.code == "git.repository" && check.level == "warning") + ); +} + +#[tokio::test] +async fn stale_healthy_agent_snapshot_requires_attention() { + let temp = tempfile::tempdir().unwrap(); + let stale_time = aionui_common::now_ms() - 25 * 60 * 60 * 1000; + let (service, _db) = service(FakeAgents { + snapshots: vec![AgentCapabilitySnapshot { + id: "claude".into(), + agent_type: "aionrs".into(), + enabled: true, + installed: true, + status: "online".into(), + last_check_status: Some("online".into()), + last_check_at: Some(stale_time), + last_success_at: Some(stale_time), + agent_capabilities: None, + available_models: None, + available_modes: None, + available_commands: None, + dynamic_probe: None, + }], + ..Default::default() + }) + .await; + let project = service + .create( + "system_default_user", + CreateProjectInput { + name: "Stale".into(), + local_path: temp.path().to_string_lossy().into_owned(), + repository_url: None, + default_branch: None, + project_type: "unknown".into(), + }, + ) + .await + .unwrap(); + + let result = service + .preflight("system_default_user", &project.id, &["claude".into()], false) + .await + .unwrap(); + assert_eq!(result.agents[0].level, "warning"); + assert!(result.agents[0].summary.contains("stale")); +} + +#[tokio::test] +async fn stale_dynamic_probe_blocks_formal_project_preflight() { + let temp = tempfile::tempdir().unwrap(); + let now = aionui_common::now_ms(); + let (service, _db) = service(FakeAgents { + snapshots: vec![AgentCapabilitySnapshot { + id: "codex".into(), + agent_type: "acp".into(), + enabled: true, + installed: true, + status: "online".into(), + last_check_status: Some("online".into()), + last_check_at: Some(now), + last_success_at: Some(now), + agent_capabilities: None, + available_models: Some(serde_json::json!(["gpt-5"])), + available_modes: None, + available_commands: None, + dynamic_probe: Some(aionui_api_types::AgentDynamicProbeResult { + agent_id: "codex".into(), + checked_at: now - 25 * 60 * 60 * 1000, + available_models: vec!["gpt-5".into()], + steps: vec![], + }), + }], + ..Default::default() + }) + .await; + let project = service + .create( + "system_default_user", + CreateProjectInput { + name: "Stale dynamic probe".into(), + local_path: temp.path().to_string_lossy().into_owned(), + repository_url: None, + default_branch: None, + project_type: "unknown".into(), + }, + ) + .await + .unwrap(); + + let result = service + .preflight("system_default_user", &project.id, &["codex".into()], false) + .await + .unwrap(); + + assert_eq!(result.agents[0].level, "fail"); + assert!(result.agents[0].summary.contains("dynamic probe is stale")); +} + +#[tokio::test] +async fn resource_binding_rejects_a_conversation_owned_by_another_user() { + let temp = tempfile::tempdir().unwrap(); + let (service, db) = service(FakeAgents::default()).await; + let project = service + .create( + "system_default_user", + CreateProjectInput { + name: "Bindings".into(), + local_path: temp.path().to_string_lossy().into_owned(), + repository_url: None, + default_branch: None, + project_type: "unknown".into(), + }, + ) + .await + .unwrap(); + sqlx::query( + "INSERT INTO users (id, username, password_hash, created_at, updated_at) \ + VALUES ('other-user', 'other', 'hash', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + sqlx::query( + "INSERT INTO conversations (id, user_id, name, type, extra, status, created_at, updated_at) \ + VALUES ('other-conversation', 'other-user', 'Other', 'chat', '{}', 'pending', 1, 1)", + ) + .execute(db.pool()) + .await + .unwrap(); + + let error = service + .bind_resource("system_default_user", &project.id, "conversation", "other-conversation") + .await + .unwrap_err(); + assert!(matches!(error, ProjectError::NotFound(_))); +} + +#[tokio::test] +async fn preflight_detects_project_directory_removed_after_registration() { + let temp = tempfile::tempdir().unwrap(); + let path = temp.path().to_path_buf(); + let (service, _db) = service(FakeAgents::default()).await; + let project = service + .create( + "system_default_user", + CreateProjectInput { + name: "Removed".into(), + local_path: path.to_string_lossy().into_owned(), + repository_url: None, + default_branch: None, + project_type: "unknown".into(), + }, + ) + .await + .unwrap(); + drop(temp); + + let result = service + .preflight("system_default_user", &project.id, &[], false) + .await + .unwrap(); + assert_eq!(result.overall_status, "fail"); + assert!( + result + .checks + .iter() + .any(|check| check.code == "path.exists" && check.level == "fail") + ); +} diff --git a/crates/aionui-runtime/src/acp_tool_runtime/types.rs b/crates/aionui-runtime/src/acp_tool_runtime/types.rs index 71f88535b..c0674dacd 100644 --- a/crates/aionui-runtime/src/acp_tool_runtime/types.rs +++ b/crates/aionui-runtime/src/acp_tool_runtime/types.rs @@ -227,6 +227,14 @@ mod tests { assert_eq!(ManagedAcpToolId::CodexAcp.version(), "1.1.2"); assert_eq!(ManagedAcpToolId::ClaudeAgentAcp.version(), "0.58.1"); } + + #[test] + fn codex_uses_the_maintained_agentclientprotocol_package() { + assert_eq!( + ManagedAcpToolId::CodexAcp.package_name(), + "@agentclientprotocol/codex-acp" + ); + } } #[derive(Debug, Clone, thiserror::Error)] diff --git a/crates/aionui-runtime/src/lease.rs b/crates/aionui-runtime/src/lease.rs new file mode 100644 index 000000000..479455336 --- /dev/null +++ b/crates/aionui-runtime/src/lease.rs @@ -0,0 +1,171 @@ +use std::io; +use std::ops::{Deref, DerefMut}; +use std::sync::Arc; +use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; +use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; + +use tokio::process::Child; + +use crate::spawn::kill_process_tree; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ProcessLeaseSpec { + pub lease_id: String, + pub environment_id: String, + pub timeout: Duration, +} + +impl ProcessLeaseSpec { + pub fn new(lease_id: impl Into, environment_id: impl Into, timeout: Duration) -> Self { + Self { + lease_id: lease_id.into(), + environment_id: environment_id.into(), + timeout, + } + } +} + +#[derive(Debug)] +struct ProcessLeaseState { + accepts_work: AtomicBool, + terminal: AtomicBool, + last_heartbeat_at: AtomicU64, +} + +#[derive(Debug, Clone)] +pub struct ProcessLease { + spec: ProcessLeaseSpec, + started_at: Instant, + state: Arc, +} + +impl ProcessLease { + fn new(spec: ProcessLeaseSpec) -> Self { + Self { + spec, + started_at: Instant::now(), + state: Arc::new(ProcessLeaseState { + accepts_work: AtomicBool::new(true), + terminal: AtomicBool::new(false), + last_heartbeat_at: AtomicU64::new(epoch_millis()), + }), + } + } + + pub fn lease_id(&self) -> &str { + &self.spec.lease_id + } + + pub fn environment_id(&self) -> &str { + &self.spec.environment_id + } + + pub fn accepts_work(&self) -> bool { + self.state.accepts_work.load(Ordering::Acquire) + } + + pub fn is_terminal(&self) -> bool { + self.state.terminal.load(Ordering::Acquire) + } + + pub fn stop_accepting_work(&self) { + self.state.accepts_work.store(false, Ordering::Release); + } + + pub fn heartbeat(&self) { + if !self.is_terminal() { + self.state.last_heartbeat_at.store(epoch_millis(), Ordering::Release); + } + } + + pub fn last_heartbeat_at(&self) -> u64 { + self.state.last_heartbeat_at.load(Ordering::Acquire) + } + + pub fn is_expired(&self) -> bool { + self.started_at.elapsed() >= self.spec.timeout + } + + fn remaining(&self) -> Duration { + self.spec.timeout.saturating_sub(self.started_at.elapsed()) + } + + fn finish(&self) { + self.stop_accepting_work(); + self.state.terminal.store(true, Ordering::Release); + } +} + +#[derive(Debug)] +pub struct LeaseExit { + pub status: Option, + pub timed_out: bool, +} + +#[derive(Debug)] +pub struct LeasedChild { + child: Child, + lease: ProcessLease, +} + +impl LeasedChild { + pub(crate) fn new(child: Child, spec: ProcessLeaseSpec) -> Self { + Self { + child, + lease: ProcessLease::new(spec), + } + } + + pub fn lease(&self) -> &ProcessLease { + &self.lease + } + + pub async fn wait_with_timeout(&mut self) -> io::Result { + match tokio::time::timeout(self.lease.remaining(), self.child.wait()).await { + Ok(status) => { + let status = status?; + self.lease.finish(); + Ok(LeaseExit { + status: Some(status), + timed_out: false, + }) + } + Err(_) => { + self.terminate_tree().await?; + Ok(LeaseExit { + status: None, + timed_out: true, + }) + } + } + } + + pub async fn terminate_tree(&mut self) -> io::Result<()> { + self.lease.stop_accepting_work(); + let result = kill_process_tree(&mut self.child).await; + self.lease.finish(); + result + } +} + +impl Deref for LeasedChild { + type Target = Child; + + fn deref(&self) -> &Self::Target { + &self.child + } +} + +impl DerefMut for LeasedChild { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.child + } +} + +fn epoch_millis() -> u64 { + SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap_or_default() + .as_millis() + .min(u64::MAX as u128) as u64 +} diff --git a/crates/aionui-runtime/src/lib.rs b/crates/aionui-runtime/src/lib.rs index 81a66d0b2..05bbf7d8c 100644 --- a/crates/aionui-runtime/src/lib.rs +++ b/crates/aionui-runtime/src/lib.rs @@ -6,6 +6,7 @@ pub mod acp_tool_runtime; mod agent_env; mod cache; mod http_client; +mod lease; pub mod managed_resources; pub mod managed_resources_contract; pub mod node_runtime; @@ -21,6 +22,7 @@ pub use acp_tool_runtime::{ }; pub use agent_env::agent_process_env; pub use cache::init; +pub use lease::{LeaseExit, LeasedChild, ProcessLease, ProcessLeaseSpec}; pub use managed_resources::{ManagedResourcesMode, managed_resources_mode, set_managed_resources_mode}; pub use node_runtime::{ DoctorRow, NodeRuntimeError, NodeRuntimeFailureKind, NodeRuntimeProgress, NodeRuntimeProgressPhase, @@ -33,7 +35,7 @@ pub use registry_npx_lock::{RegistryNpxLockError, pin_registry_npx_args, should_ pub use resolver::{resolve_command_in, resolve_command_path}; pub use shell_env::enhance_process_path; mod spawn; -pub use spawn::{Builder, kill_process_tree}; +pub use spawn::{Builder, kill_process_tree, kill_process_tree_by_id}; #[cfg(test)] mod test_support; diff --git a/crates/aionui-runtime/src/shell_env.rs b/crates/aionui-runtime/src/shell_env.rs index 2f8fe64a5..278e6909b 100644 --- a/crates/aionui-runtime/src/shell_env.rs +++ b/crates/aionui-runtime/src/shell_env.rs @@ -160,53 +160,81 @@ fn nvm_version_bins(home: &Path) -> Vec { #[cfg(unix)] fn login_shell_path() -> Option { - use std::io::Read; - use std::process::{Command, Stdio}; use std::time::Duration; - use wait_timeout::ChildExt; let shell = std::env::var("SHELL").ok()?; - if !Path::new(&shell).is_absolute() { - tracing::debug!(%shell, "SHELL is not absolute, skipping login shell probe"); + let shell = Path::new(&shell); + if !shell.is_absolute() { + tracing::debug!(shell = %shell.display(), "SHELL is not absolute, skipping login shell probe"); return None; } - let mut child = match Command::new(&shell) - .args(["-l", "-i", "-c", "printf %s \"$PATH\""]) + login_shell_path_from(shell, Duration::from_secs(3)) +} + +#[cfg(unix)] +fn login_shell_path_from(shell: &Path, timeout: std::time::Duration) -> Option { + use std::io::Read; + use std::os::unix::process::CommandExt; + use std::process::{Command, Stdio}; + use wait_timeout::ChildExt; + + let mut command = Command::new(shell); + command + .args(["-l", "-i", "-c", "printf %s \"$PATH\"; exit"]) .stdin(Stdio::null()) .stdout(Stdio::piped()) - .stderr(Stdio::null()) - .spawn() - { + .stderr(Stdio::null()); + // Interactive shells perform job-control checks against any inherited + // controlling terminal. A background worker process group can otherwise + // enter a SIGTTIN loop before it evaluates `-c` (for example under + // nextest). A fresh session has no controlling terminal. + // SAFETY: `setsid` is async-signal-safe and the closure captures nothing. + unsafe { + command.pre_exec(|| { + if libc::setsid() == -1 { + return Err(std::io::Error::last_os_error()); + } + Ok(()) + }); + } + + let mut child = match command.spawn() { Ok(c) => c, Err(e) => { - tracing::debug!(%shell, error = %e, "login shell spawn failed"); + tracing::debug!(shell = %shell.display(), error = %e, "login shell spawn failed"); return None; } }; - // Take stdout handle before waiting to prevent pipe-buffer deadlock. - // If the PATH string is long enough to fill the pipe buffer, the child - // will block on write while we block on wait — causing a deadlock and - // the 3s timeout to fire. Reading stdout first drains the buffer. + // Drain stdout concurrently so a large PATH cannot fill the pipe while + // the timeout still governs a shell that never exits. Reading here on + // the current thread would block before `wait_timeout` can run. let mut stdout_handle = child.stdout.take()?; - let mut stdout = String::new(); - stdout_handle.read_to_string(&mut stdout).ok()?; + let stdout_reader = std::thread::spawn(move || { + let mut stdout = String::new(); + stdout_handle.read_to_string(&mut stdout).map(|_| stdout) + }); - let status = match child.wait_timeout(Duration::from_secs(3)) { + let status = match child.wait_timeout(timeout) { Ok(Some(s)) => s, Ok(None) => { let _ = child.kill(); let _ = child.wait(); - tracing::warn!("login shell PATH probe timed out after 3s"); + let _ = stdout_reader.join(); + tracing::warn!(timeout_ms = timeout.as_millis(), "login shell PATH probe timed out"); return None; } Err(e) => { + let _ = child.kill(); + let _ = child.wait(); + let _ = stdout_reader.join(); tracing::debug!(error = %e, "login shell wait_timeout errored"); return None; } }; + let stdout = stdout_reader.join().ok()?.ok()?; if !status.success() { tracing::debug!(?status, "login shell exited non-zero"); return None; @@ -377,6 +405,29 @@ mod tests { assert!(!path.is_empty(), "login shell PATH should not be empty"); } + #[cfg(unix)] + #[test] + fn login_shell_path_enforces_timeout_while_stdout_is_open() { + use std::os::unix::fs::PermissionsExt; + use std::time::{Duration, Instant}; + + let dir = tempfile::tempdir().unwrap(); + let shell = dir.path().join("never-exits.sh"); + std::fs::write(&shell, "#!/bin/sh\nprintf /tmp/fake-path\nwhile :; do :; done\n").unwrap(); + let mut permissions = std::fs::metadata(&shell).unwrap().permissions(); + permissions.set_mode(0o755); + std::fs::set_permissions(&shell, permissions).unwrap(); + + let started = Instant::now(); + let result = login_shell_path_from(&shell, Duration::from_millis(100)); + + assert!(result.is_none(), "timed-out probes must not return a PATH"); + assert!( + started.elapsed() < Duration::from_secs(2), + "probe timeout was not enforced" + ); + } + #[cfg(unix)] fn run_in_env_child(test_name: &str, envs: &[(&str, &str)], removals: &[&str]) -> bool { const CHILD_ENV: &str = "AIONUI_RUNTIME_SHELL_ENV_TEST_CHILD"; diff --git a/crates/aionui-runtime/src/spawn.rs b/crates/aionui-runtime/src/spawn.rs index cc4764275..41f49b77a 100644 --- a/crates/aionui-runtime/src/spawn.rs +++ b/crates/aionui-runtime/src/spawn.rs @@ -30,6 +30,7 @@ use std::process::Stdio; use tokio::process::{Child, Command}; use crate::ResolvedCommand; +use crate::lease::{LeasedChild, ProcessLeaseSpec}; use crate::resolver::resolve_command_path; struct ProgramPlan { @@ -68,6 +69,23 @@ pub async fn kill_process_tree(child: &mut Child) -> io::Result<()> { child.wait().await.map(|_| ()) } +/// Force-kill a previously persisted process-tree identifier. +/// A missing process is treated as already cleaned up. +pub async fn kill_process_tree_by_id(pid: u32) -> io::Result<()> { + #[cfg(unix)] + return force_kill_process_tree(pid, Some(pid)); + #[cfg(windows)] + return kill_windows_process_tree(pid).await; + #[cfg(not(any(unix, windows)))] + { + let _ = pid; + Err(io::Error::new( + io::ErrorKind::Unsupported, + "persisted process-tree cleanup is unsupported on this platform", + )) + } +} + impl std::fmt::Debug for Builder { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("Builder") @@ -214,6 +232,16 @@ impl Builder { self.inner.spawn() } + /// Spawn a child owned by an explicit execution lease. + /// + /// The returned wrapper preserves normal `Child` access while adding a + /// heartbeat, an accepting-work fence, a deadline, and process-tree + /// termination. Callers that supervise Agent or project commands should + /// use this boundary instead of retaining a raw child. + pub fn spawn_leased(mut self, spec: ProcessLeaseSpec) -> io::Result { + self.inner.spawn().map(|child| LeasedChild::new(child, spec)) + } + /// Run to completion and collect stdout/stderr. pub async fn output(mut self) -> io::Result { self.inner.output().await diff --git a/crates/aionui-runtime/tests/process_lease.rs b/crates/aionui-runtime/tests/process_lease.rs new file mode 100644 index 000000000..f5036993a --- /dev/null +++ b/crates/aionui-runtime/tests/process_lease.rs @@ -0,0 +1,136 @@ +use std::time::Duration; + +use aionui_runtime::{Builder, ProcessLeaseSpec}; + +#[tokio::test] +async fn lease_tracks_heartbeat_acceptance_and_timeout() { + let mut command = Builder::new("sh"); + command.args(["-c", "sleep 60"]); + let mut child = command + .spawn_leased(ProcessLeaseSpec::new( + "lease-runtime", + "host:local", + Duration::from_millis(75), + )) + .unwrap(); + + assert!(child.lease().accepts_work()); + let initial_heartbeat = child.lease().last_heartbeat_at(); + tokio::time::sleep(Duration::from_millis(5)).await; + child.lease().heartbeat(); + assert!(child.lease().last_heartbeat_at() >= initial_heartbeat); + + child.lease().stop_accepting_work(); + assert!(!child.lease().accepts_work()); + let exit = child.wait_with_timeout().await.unwrap(); + assert!(exit.timed_out); + assert!(exit.status.is_none()); +} + +#[cfg(unix)] +#[tokio::test] +async fn termination_kills_the_complete_process_tree() { + let directory = tempfile::tempdir().unwrap(); + let pid_file = directory.path().join("grandchild.pid"); + let script = format!("sleep 60 & echo $! > '{}'; wait", pid_file.display()); + let mut command = Builder::new("sh"); + command.args(["-c", &script]); + let mut child = command + .spawn_leased(ProcessLeaseSpec::new( + "lease-tree", + "host:local", + Duration::from_secs(30), + )) + .unwrap(); + + let grandchild_pid = tokio::time::timeout(Duration::from_secs(2), async { + loop { + if let Ok(value) = std::fs::read_to_string(&pid_file) + && let Ok(pid) = value.trim().parse::() + { + break pid; + } + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + + child.terminate_tree().await.unwrap(); + let stopped = tokio::time::timeout(Duration::from_secs(2), async { + loop { + let exists = unsafe { libc::kill(grandchild_pid, 0) } == 0; + let running = if cfg!(target_os = "linux") { + std::fs::read_to_string(format!("/proc/{grandchild_pid}/stat")) + .ok() + .and_then(|stat| stat.split_whitespace().nth(2).map(str::to_owned)) + .is_some_and(|state| state != "Z") + } else { + exists + }; + if !running { + break true; + } + tokio::time::sleep(Duration::from_millis(10)).await; + } + }) + .await + .unwrap_or(false); + assert!(stopped, "grandchild process {grandchild_pid} survived lease cleanup"); +} + +#[cfg(unix)] +#[test] +fn port_holder_child() { + let Ok(port) = std::env::var("AIONUI_TEST_PORT_HOLDER") else { + return; + }; + let listener = std::net::TcpListener::bind(format!("127.0.0.1:{port}")).unwrap(); + loop { + let _ = listener.accept(); + } +} + +#[cfg(unix)] +#[tokio::test] +async fn terminating_a_lease_releases_ports_owned_by_its_process() { + let probe = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + let port = probe.local_addr().unwrap().port(); + drop(probe); + + let mut command = Builder::new(std::env::current_exe().unwrap()); + command + .args(["--exact", "port_holder_child", "--nocapture"]) + .env("AIONUI_TEST_PORT_HOLDER", port.to_string()); + let mut child = command + .spawn_leased(ProcessLeaseSpec::new( + "lease-port", + "host:local", + Duration::from_secs(30), + )) + .unwrap(); + + tokio::time::timeout(Duration::from_secs(2), async { + loop { + if std::net::TcpStream::connect(("127.0.0.1", port)).is_ok() { + break; + } + tokio::time::sleep(Duration::from_millis(10)).await; + } + }) + .await + .unwrap(); + + child.terminate_tree().await.unwrap(); + let rebound = tokio::time::timeout(Duration::from_secs(2), async { + loop { + if let Ok(listener) = std::net::TcpListener::bind(("127.0.0.1", port)) { + break listener; + } + tokio::time::sleep(Duration::from_millis(10)).await; + } + }) + .await + .unwrap(); + assert_eq!(rebound.local_addr().unwrap().port(), port); +} diff --git a/crates/aionui-team/src/error.rs b/crates/aionui-team/src/error.rs index 9a3d68f1a..509d2d19a 100644 --- a/crates/aionui-team/src/error.rs +++ b/crates/aionui-team/src/error.rs @@ -26,6 +26,9 @@ pub enum TeamError { #[error("Blocked task not found: {0}")] BlockedTaskNotFound(String), + #[error("Task dependency cycle: {0}")] + TaskDependencyCycle(String), + #[error("Backend not allowed: {0}")] BackendNotAllowed(String), @@ -49,6 +52,9 @@ pub enum TeamError { #[error("Workspace path is unavailable during execution: {0}")] WorkspacePathRuntimeUnavailable(String), + #[error("Workspace operation failed: {0}")] + WorkspaceOperation(String), + #[error("{0}")] Database(#[from] aionui_db::DbError), diff --git a/crates/aionui-team/src/git_workspace.rs b/crates/aionui-team/src/git_workspace.rs new file mode 100644 index 000000000..e12ef1fab --- /dev/null +++ b/crates/aionui-team/src/git_workspace.rs @@ -0,0 +1,696 @@ +use std::path::{Component, Path, PathBuf}; +use std::sync::Arc; + +use aionui_common::{generate_id, now_ms}; +use aionui_db::models::AgentWorkspaceLeaseRow; +use aionui_db::{AgentWorkspaceLeaseUpdate, IAgentWorkspaceLeaseRepository}; +use async_trait::async_trait; +use tokio::process::Command; +use tracing::{info, warn}; + +use crate::TeamError; + +pub const INTEGRATION_SLOT_ID: &str = "__integration__"; +pub const SINGLE_RUN_SLOT_ID: &str = "__single_agent__"; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct WorkspaceAgentSpec { + pub slot_id: String, + pub name: String, +} + +impl WorkspaceAgentSpec { + pub fn new(slot_id: impl Into, name: impl Into) -> Self { + Self { + slot_id: slot_id.into(), + name: name.into(), + } + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PreparedTeamWorkspaces { + pub repository_path: String, + pub base_commit: String, + pub integration: AgentWorkspaceLeaseRow, + pub agent_leases: Vec, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum WorkspaceCleanupDisposition { + Removed, + BranchRetained, + DirtyPreserved, + MissingPreserved, + AlreadyReleased, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct WorkspaceCleanupResult { + pub lease_id: String, + pub slot_id: String, + pub disposition: WorkspaceCleanupDisposition, +} + +#[async_trait] +pub trait TeamWorkspaceManager: Send + Sync { + async fn prepare_team( + &self, + user_id: &str, + team_id: &str, + repository_path: &str, + agents: &[WorkspaceAgentSpec], + ) -> Result; + + async fn allocate_agent( + &self, + user_id: &str, + team_id: &str, + slot: &WorkspaceAgentSpec, + ) -> Result; + + async fn list_team_leases(&self, team_id: &str) -> Result, TeamError>; + + async fn release_slot(&self, team_id: &str, slot_id: &str) -> Result; + + async fn release_team(&self, team_id: &str) -> Result, TeamError>; + + async fn reconcile_all(&self) -> Result<(), TeamError>; + + async fn validate_owned_path(&self, team_id: &str, slot_id: &str, path: &Path) -> Result; +} + +#[derive(Clone)] +pub struct GitTeamWorkspaceManager { + leases: Arc, + managed_root: PathBuf, +} + +impl GitTeamWorkspaceManager { + pub fn new(leases: Arc, managed_root: PathBuf) -> Self { + let managed_root = if managed_root.is_absolute() { + managed_root + } else { + std::env::current_dir() + .unwrap_or_else(|_| PathBuf::from(".")) + .join(managed_root) + }; + Self { leases, managed_root } + } + + pub fn integration_branch_name(team_id: &str) -> String { + format!("aion/team/{}/integration", safe_component(team_id, 24, "team")) + } + + fn agent_branch_name(team_id: &str, slot: &WorkspaceAgentSpec) -> String { + format!( + "aion/team/{}/agent/{}-{}", + safe_component(team_id, 24, "team"), + safe_component(&slot.slot_id, 18, "slot"), + safe_component(&slot.name, 24, "agent") + ) + } + + fn team_root(&self, team_id: &str) -> PathBuf { + self.managed_root.join(safe_component(team_id, 40, "team")) + } + + pub async fn prepare_single_run( + &self, + user_id: &str, + run_id: &str, + repository_path: &str, + baseline_commit: &str, + ) -> Result { + let requested = Path::new(repository_path); + let root = PathBuf::from(git_output(requested, &["rev-parse", "--show-toplevel"]).await?) + .canonicalize() + .map_err(|error| workspace_error(format!("failed to canonicalize repository: {error}")))?; + let resolved_baseline = git_output(&root, &["rev-parse", baseline_commit]).await?; + if resolved_baseline != baseline_commit { + return Err(workspace_error( + "single-run baseline commit could not be verified".into(), + )); + } + let namespace = format!("run:{run_id}"); + let branch = format!("aion/run/{}/agent", safe_component(run_id, 32, "run")); + let path = self.team_root(&namespace).join("agent"); + let row = self.lease_row( + user_id, + &namespace, + SINGLE_RUN_SLOT_ID, + &root.to_string_lossy(), + &path, + branch, + baseline_commit, + ); + self.create_worktree(row).await + } + + pub async fn restore_single_run(&self, lease_id: &str, safe_point: &str) -> Result { + let lease = self + .leases + .get(lease_id) + .await? + .ok_or_else(|| workspace_error(format!("workspace lease not found: {lease_id}")))?; + if lease.slot_id != SINGLE_RUN_SLOT_ID || lease.base_commit != safe_point { + return Err(workspace_error( + "single-run safe point does not match the managed lease".into(), + )); + } + let worktree = Path::new(&lease.worktree_path); + git_output(worktree, &["reset", "--hard", safe_point]).await?; + git_output(worktree, &["clean", "-fd"]).await?; + let result = self.release_slot(&lease.team_id, SINGLE_RUN_SLOT_ID).await?; + Ok(match result.disposition { + WorkspaceCleanupDisposition::Removed | WorkspaceCleanupDisposition::AlreadyReleased => { + "restored_and_released" + } + WorkspaceCleanupDisposition::BranchRetained => "restored_branch_retained", + WorkspaceCleanupDisposition::DirtyPreserved => "restore_dirty_preserved", + WorkspaceCleanupDisposition::MissingPreserved => "restore_missing_preserved", + } + .into()) + } + + async fn inspect_repository(&self, repository_path: &str) -> Result<(String, String), TeamError> { + let requested = Path::new(repository_path); + if !requested.is_dir() { + return Err(workspace_error(format!( + "repository directory is unavailable: {}", + requested.display() + ))); + } + let root = git_output(requested, &["rev-parse", "--show-toplevel"]).await?; + let root = PathBuf::from(root) + .canonicalize() + .map_err(|error| workspace_error(format!("failed to canonicalize repository: {error}")))?; + let status = git_output(&root, &["status", "--porcelain", "--untracked-files=all"]).await?; + if !status.trim().is_empty() { + return Err(workspace_error( + "repository is dirty; commit, stash, snapshot, or cancel before isolated Team creation".into(), + )); + } + let base_commit = git_output(&root, &["rev-parse", "HEAD"]).await?; + Ok((root.to_string_lossy().into_owned(), base_commit)) + } + + async fn branch_must_be_absent(&self, repository: &Path, branch: &str) -> Result<(), TeamError> { + let output = Command::new("git") + .arg("-C") + .arg(repository) + .args(["show-ref", "--verify", "--quiet"]) + .arg(format!("refs/heads/{branch}")) + .output() + .await + .map_err(|error| workspace_error(format!("failed to inspect branch {branch}: {error}")))?; + match output.status.code() { + Some(1) => Ok(()), + Some(0) => Err(workspace_error(format!("branch already exists: {branch}"))), + _ => Err(workspace_error(format!( + "failed to inspect branch {branch}: {}", + String::from_utf8_lossy(&output.stderr).trim() + ))), + } + } + + #[allow(clippy::too_many_arguments)] + fn lease_row( + &self, + user_id: &str, + team_id: &str, + slot_id: &str, + repository_path: &str, + worktree_path: &Path, + branch_name: String, + base_commit: &str, + ) -> AgentWorkspaceLeaseRow { + let now = now_ms(); + AgentWorkspaceLeaseRow { + id: generate_id(), + team_id: team_id.to_owned(), + user_id: user_id.to_owned(), + slot_id: slot_id.to_owned(), + workspace_mode: "isolated_worktree".into(), + repository_path: repository_path.to_owned(), + worktree_path: worktree_path.to_string_lossy().into_owned(), + branch_name, + base_commit: base_commit.to_owned(), + allowed_paths: r#"["."]"#.into(), + lease_status: "provisioning".into(), + cleanup_status: "none".into(), + conflict_files: "[]".into(), + last_error: None, + created_at: now, + updated_at: now, + released_at: None, + } + } + + async fn create_worktree(&self, mut lease: AgentWorkspaceLeaseRow) -> Result { + let repository = Path::new(&lease.repository_path); + let worktree = Path::new(&lease.worktree_path); + self.branch_must_be_absent(repository, &lease.branch_name).await?; + if worktree.exists() { + return Err(workspace_error(format!( + "managed worktree path already exists: {}", + worktree.display() + ))); + } + if let Some(parent) = worktree.parent() { + tokio::fs::create_dir_all(parent) + .await + .map_err(|error| workspace_error(format!("failed to create managed worktree directory: {error}")))?; + } + self.leases.create(&lease).await?; + + let result = git_output( + repository, + &[ + "worktree", + "add", + "-b", + &lease.branch_name, + &lease.worktree_path, + &lease.base_commit, + ], + ) + .await; + if let Err(error) = result { + let message = error.to_string(); + self.leases + .update( + &lease.id, + &AgentWorkspaceLeaseUpdate { + lease_status: Some("conflict".into()), + cleanup_status: Some("provision_failed".into()), + last_error: Some(Some(message)), + ..Default::default() + }, + ) + .await?; + return Err(error); + } + self.leases + .update( + &lease.id, + &AgentWorkspaceLeaseUpdate { + lease_status: Some("active".into()), + ..Default::default() + }, + ) + .await?; + lease.lease_status = "active".into(); + Ok(lease) + } + + async fn cleanup_fresh_lease(&self, lease: &AgentWorkspaceLeaseRow) { + let worktree = Path::new(&lease.worktree_path); + if worktree.exists() { + let _ = git_output( + Path::new(&lease.repository_path), + &["worktree", "remove", "--force", &lease.worktree_path], + ) + .await; + } + let _ = git_output(Path::new(&lease.repository_path), &["branch", "-D", &lease.branch_name]).await; + let _ = self + .leases + .update( + &lease.id, + &AgentWorkspaceLeaseUpdate { + lease_status: Some("released".into()), + cleanup_status: Some("provision_rolled_back".into()), + released_at: Some(Some(now_ms())), + ..Default::default() + }, + ) + .await; + } + + async fn source_lease_for_team(&self, team_id: &str) -> Result { + self.leases + .get_for_team_slot(team_id, INTEGRATION_SLOT_ID) + .await? + .ok_or_else(|| workspace_error(format!("integration workspace lease is missing for Team {team_id}"))) + } +} + +#[async_trait] +impl TeamWorkspaceManager for GitTeamWorkspaceManager { + async fn prepare_team( + &self, + user_id: &str, + team_id: &str, + repository_path: &str, + agents: &[WorkspaceAgentSpec], + ) -> Result { + if agents.is_empty() { + return Err(workspace_error("at least one workspace agent is required".into())); + } + let mut slots = std::collections::HashSet::new(); + if agents.iter().any(|agent| !slots.insert(agent.slot_id.as_str())) { + return Err(workspace_error("workspace agent slot IDs must be unique".into())); + } + let (repository_path, base_commit) = self.inspect_repository(repository_path).await?; + let repository = Path::new(&repository_path); + let team_root = self.team_root(team_id); + let integration_branch = Self::integration_branch_name(team_id); + let integration_path = team_root.join("integration"); + + self.branch_must_be_absent(repository, &integration_branch).await?; + for slot in agents { + self.branch_must_be_absent(repository, &Self::agent_branch_name(team_id, slot)) + .await?; + } + if team_root.exists() { + return Err(workspace_error(format!( + "managed Team workspace already exists: {}", + team_root.display() + ))); + } + + let integration_row = self.lease_row( + user_id, + team_id, + INTEGRATION_SLOT_ID, + &repository_path, + &integration_path, + integration_branch, + &base_commit, + ); + let integration = self.create_worktree(integration_row).await?; + let mut created = vec![integration.clone()]; + let mut agent_leases = Vec::with_capacity(agents.len()); + for slot in agents { + let path = team_root.join(format!( + "{}-{}", + safe_component(&slot.slot_id, 24, "slot"), + safe_component(&slot.name, 30, "agent") + )); + let row = self.lease_row( + user_id, + team_id, + &slot.slot_id, + &repository_path, + &path, + Self::agent_branch_name(team_id, slot), + &base_commit, + ); + match self.create_worktree(row).await { + Ok(lease) => { + created.push(lease.clone()); + agent_leases.push(lease); + } + Err(error) => { + for lease in created.iter().rev() { + self.cleanup_fresh_lease(lease).await; + } + return Err(error); + } + } + } + info!( + team_id, + count = agent_leases.len(), + base_commit, + "isolated Team worktrees created" + ); + Ok(PreparedTeamWorkspaces { + repository_path, + base_commit, + integration, + agent_leases, + }) + } + + async fn allocate_agent( + &self, + user_id: &str, + team_id: &str, + slot: &WorkspaceAgentSpec, + ) -> Result { + let source = self.source_lease_for_team(team_id).await?; + if source.user_id != user_id { + return Err(TeamError::Forbidden(format!( + "Team {team_id} workspace is not owned by current user" + ))); + } + let path = self.team_root(team_id).join(format!( + "{}-{}", + safe_component(&slot.slot_id, 24, "slot"), + safe_component(&slot.name, 30, "agent") + )); + let row = self.lease_row( + user_id, + team_id, + &slot.slot_id, + &source.repository_path, + &path, + Self::agent_branch_name(team_id, slot), + &source.base_commit, + ); + self.create_worktree(row).await + } + + async fn list_team_leases(&self, team_id: &str) -> Result, TeamError> { + Ok(self.leases.list_for_team(team_id).await?) + } + + async fn release_slot(&self, team_id: &str, slot_id: &str) -> Result { + let lease = + self.leases.get_for_team_slot(team_id, slot_id).await?.ok_or_else(|| { + workspace_error(format!("workspace lease not found for Team {team_id} slot {slot_id}")) + })?; + if lease.lease_status == "released" { + return Ok(WorkspaceCleanupResult { + lease_id: lease.id, + slot_id: lease.slot_id, + disposition: WorkspaceCleanupDisposition::AlreadyReleased, + }); + } + let worktree = Path::new(&lease.worktree_path); + if !worktree.is_dir() { + self.leases + .update( + &lease.id, + &AgentWorkspaceLeaseUpdate { + lease_status: Some("conflict".into()), + cleanup_status: Some("missing_worktree".into()), + last_error: Some(Some("managed worktree path is missing".into())), + ..Default::default() + }, + ) + .await?; + return Ok(WorkspaceCleanupResult { + lease_id: lease.id, + slot_id: lease.slot_id, + disposition: WorkspaceCleanupDisposition::MissingPreserved, + }); + } + let status = git_output(worktree, &["status", "--porcelain", "--untracked-files=all"]).await?; + if !status.trim().is_empty() { + self.leases + .update( + &lease.id, + &AgentWorkspaceLeaseUpdate { + lease_status: Some("cleanup_pending".into()), + cleanup_status: Some("dirty_preserved".into()), + last_error: Some(Some("uncommitted changes preserved".into())), + ..Default::default() + }, + ) + .await?; + return Ok(WorkspaceCleanupResult { + lease_id: lease.id, + slot_id: lease.slot_id, + disposition: WorkspaceCleanupDisposition::DirtyPreserved, + }); + } + + let head = git_output(worktree, &["rev-parse", "HEAD"]).await?; + git_output( + Path::new(&lease.repository_path), + &["worktree", "remove", &lease.worktree_path], + ) + .await?; + let (cleanup_status, disposition) = if head == lease.base_commit { + git_output(Path::new(&lease.repository_path), &["branch", "-D", &lease.branch_name]).await?; + ("removed", WorkspaceCleanupDisposition::Removed) + } else { + ("branch_retained", WorkspaceCleanupDisposition::BranchRetained) + }; + self.leases + .update( + &lease.id, + &AgentWorkspaceLeaseUpdate { + lease_status: Some("released".into()), + cleanup_status: Some(cleanup_status.into()), + last_error: Some(None), + released_at: Some(Some(now_ms())), + ..Default::default() + }, + ) + .await?; + Ok(WorkspaceCleanupResult { + lease_id: lease.id, + slot_id: lease.slot_id, + disposition, + }) + } + + async fn release_team(&self, team_id: &str) -> Result, TeamError> { + let mut leases = self.leases.list_for_team(team_id).await?; + leases.sort_by_key(|lease| lease.slot_id == INTEGRATION_SLOT_ID); + let mut results = Vec::with_capacity(leases.len()); + for lease in leases { + results.push(self.release_slot(team_id, &lease.slot_id).await?); + } + Ok(results) + } + + async fn reconcile_all(&self) -> Result<(), TeamError> { + for lease in self.leases.list_reconcile_candidates().await? { + let exists = Path::new(&lease.worktree_path).is_dir(); + if !exists { + self.leases + .update( + &lease.id, + &AgentWorkspaceLeaseUpdate { + lease_status: Some("conflict".into()), + cleanup_status: Some("missing_worktree".into()), + last_error: Some(Some("managed worktree path is missing during reconciliation".into())), + ..Default::default() + }, + ) + .await?; + continue; + } + if lease.lease_status == "provisioning" { + self.leases + .update( + &lease.id, + &AgentWorkspaceLeaseUpdate { + lease_status: Some("active".into()), + cleanup_status: Some("recovered".into()), + last_error: Some(None), + ..Default::default() + }, + ) + .await?; + } else if lease.lease_status == "cleanup_pending" { + let status = git_output( + Path::new(&lease.worktree_path), + &["status", "--porcelain", "--untracked-files=all"], + ) + .await?; + if status.trim().is_empty() + && let Err(error) = self.release_slot(&lease.team_id, &lease.slot_id).await + { + warn!(lease_id = %lease.id, error = %error, "workspace reconciliation cleanup failed"); + } + } + } + Ok(()) + } + + async fn validate_owned_path(&self, team_id: &str, slot_id: &str, path: &Path) -> Result { + let lease = + self.leases.get_for_team_slot(team_id, slot_id).await?.ok_or_else(|| { + workspace_error(format!("workspace lease not found for Team {team_id} slot {slot_id}")) + })?; + if slot_id == INTEGRATION_SLOT_ID { + return Err(workspace_error( + "integration workspace is not writable by an Agent".into(), + )); + } + if path.is_absolute() + || path.components().any(|component| { + matches!( + component, + Component::ParentDir | Component::RootDir | Component::Prefix(_) + ) + }) + { + return Err(workspace_error("path is outside the Agent workspace lease".into())); + } + let root = PathBuf::from(&lease.worktree_path) + .canonicalize() + .map_err(|error| workspace_error(format!("workspace lease path is unavailable: {error}")))?; + let mut candidate = root.clone(); + for component in path.components() { + candidate.push(component.as_os_str()); + if candidate.exists() { + candidate = candidate + .canonicalize() + .map_err(|error| workspace_error(format!("failed to resolve workspace path: {error}")))?; + if !candidate.starts_with(&root) { + return Err(workspace_error("path is outside the Agent workspace lease".into())); + } + } + } + Ok(candidate) + } +} + +fn safe_component(value: &str, max_len: usize, fallback: &str) -> String { + let mut result = String::with_capacity(value.len().min(max_len)); + let mut last_dash = false; + for ch in value.chars() { + if result.len() >= max_len { + break; + } + let normalized = if ch.is_ascii_alphanumeric() { + ch.to_ascii_lowercase() + } else { + '-' + }; + if normalized == '-' { + if result.is_empty() || last_dash { + continue; + } + last_dash = true; + } else { + last_dash = false; + } + result.push(normalized); + } + while result.ends_with('-') { + result.pop(); + } + if result.is_empty() { fallback.to_owned() } else { result } +} + +async fn git_output(repository: &Path, args: &[&str]) -> Result { + let output = Command::new("git") + .arg("-C") + .arg(repository) + .args(args) + .output() + .await + .map_err(|error| workspace_error(format!("failed to start git: {error}")))?; + if !output.status.success() { + return Err(workspace_error(format!( + "git {} failed: {}", + args.join(" "), + String::from_utf8_lossy(&output.stderr).trim() + ))); + } + Ok(String::from_utf8_lossy(&output.stdout).trim().to_owned()) +} + +fn workspace_error(message: String) -> TeamError { + TeamError::WorkspaceOperation(message) +} + +#[cfg(test)] +mod tests { + use super::safe_component; + + #[test] + fn branch_components_are_lowercase_bounded_and_safe() { + assert_eq!(safe_component("Hello / World!", 40, "x"), "hello-world"); + assert_eq!(safe_component("---", 40, "fallback"), "fallback"); + assert_eq!(safe_component("ABCDEFGHIJ", 5, "x"), "abcde"); + } +} diff --git a/crates/aionui-team/src/lib.rs b/crates/aionui-team/src/lib.rs index 33018f469..c8bd66c46 100644 --- a/crates/aionui-team/src/lib.rs +++ b/crates/aionui-team/src/lib.rs @@ -6,6 +6,7 @@ pub mod crash_detection; pub mod error; pub mod event_loop; pub mod events; +mod git_workspace; pub mod mailbox; pub mod mcp; mod member_runtime; @@ -33,6 +34,10 @@ mod workspace; pub use crash_detection::{CrashReason, detect_crash, is_rate_limited}; pub use error::TeamError; pub use events::TeamEventEmitter; +pub use git_workspace::{ + GitTeamWorkspaceManager, INTEGRATION_SLOT_ID, PreparedTeamWorkspaces, SINGLE_RUN_SLOT_ID, TeamWorkspaceManager, + WorkspaceAgentSpec, WorkspaceCleanupDisposition, WorkspaceCleanupResult, +}; pub use mailbox::Mailbox; pub use mcp::{TEAM_MCP_SERVER_NAME, TeamMcpServer, TeamMcpStdioConfig, TeamMcpStdioServerSpec}; pub use message_projection::{ @@ -48,7 +53,8 @@ pub use ports::{ pub use prompt_dump::TeamPromptDumpConfig; pub use prompts::{build_lead_prompt, build_teammate_prompt, build_wake_payload}; pub use provisioning::{ - TeamAgentProvisioner, TeamConversationCreateRequest, TeamConversationCreateResult, TeamConversationProvisioningPort, + TeamAgentProvisioner, TeamConversationCreateRequest, TeamConversationCreateResult, + TeamConversationProvisioningPort, TeamSourceMetadata, }; pub use routes::{TeamRouterState, team_routes}; pub use runtime_tools::ResolvedTeamToolContext; diff --git a/crates/aionui-team/src/prompts/wake_summary.rs b/crates/aionui-team/src/prompts/wake_summary.rs index d4593cafa..e26b23103 100644 --- a/crates/aionui-team/src/prompts/wake_summary.rs +++ b/crates/aionui-team/src/prompts/wake_summary.rs @@ -226,15 +226,11 @@ fn compare_active_tasks( fn compare_same_status_recency(left: &TeamTask, right: &TeamTask) -> Ordering { match left.status { - TaskStatus::InProgress => right + status if is_active(status) => right .updated_at .cmp(&left.updated_at) .then_with(|| left.created_at.cmp(&right.created_at)), - TaskStatus::Pending => right - .updated_at - .cmp(&left.updated_at) - .then_with(|| left.created_at.cmp(&right.created_at)), - TaskStatus::Completed | TaskStatus::Deleted => Ordering::Equal, + _ => Ordering::Equal, } } @@ -260,14 +256,21 @@ fn active_rank( fn status_rank(status: TaskStatus) -> u8 { match status { TaskStatus::InProgress => 0, - TaskStatus::Pending => 1, - TaskStatus::Completed => 2, - TaskStatus::Deleted => 3, + TaskStatus::Claimed => 1, + TaskStatus::Ready | TaskStatus::Rework => 2, + TaskStatus::WaitingApproval | TaskStatus::Verifying | TaskStatus::Review => 3, + TaskStatus::Pending => 4, + TaskStatus::Failed | TaskStatus::Cancelled => 5, + TaskStatus::Completed => 6, + TaskStatus::Deleted => 7, } } fn is_active(status: TaskStatus) -> bool { - matches!(status, TaskStatus::Pending | TaskStatus::InProgress) + !matches!( + status, + TaskStatus::Completed | TaskStatus::Failed | TaskStatus::Cancelled | TaskStatus::Deleted + ) } fn is_current_or_ownerless(task: &TeamTask, current_slot_ids: &HashSet) -> bool { diff --git a/crates/aionui-team/src/provisioning.rs b/crates/aionui-team/src/provisioning.rs index 75931fee4..e30bcffaa 100644 --- a/crates/aionui-team/src/provisioning.rs +++ b/crates/aionui-team/src/provisioning.rs @@ -1,10 +1,14 @@ use std::sync::Arc; use aionui_ai_agent::IWorkerTaskManager; -use aionui_api_types::{AddAgentRequest, GetConfigOptionsResponse, TeamAgentInput, TeamToolTransport}; -use aionui_common::{AgentKillReason, AgentType, ProviderWithModel, generate_id}; +use aionui_api_types::{ + AddAgentRequest, CreateTeamRequest, GetConfigOptionsResponse, TeamAgentInput, TeamToolTransport, +}; +use aionui_common::{AgentKillReason, AgentType, ConversationSource, ProviderWithModel, generate_id, now_ms}; use aionui_db::models::{AgentMetadataRow, TeamRow}; -use aionui_db::{IAgentMetadataRepository, IProviderRepository, ITeamRepository, UpdateTeamParams}; +use aionui_db::{ + IAgentMetadataRepository, IProviderRepository, ITeamRepository, UpdateTeamParams, resolve_agent_binding_from_rows, +}; use async_trait::async_trait; use tracing::{info, warn}; @@ -17,6 +21,7 @@ use crate::service::inherit_team_workspace; use crate::service::spawn_support::{acp_backend_metadata, parse_agent_type, session_mode_for_backend}; use crate::types::{Team, TeamAgent, TeammateRole}; use crate::workspace::TeamWorkspaceResolver; +use crate::{PreparedTeamWorkspaces, TeamWorkspaceManager, WorkspaceAgentSpec}; #[derive(Clone)] pub struct TeamAgentProvisioner { @@ -25,6 +30,7 @@ pub struct TeamAgentProvisioner { assistant_catalog: Arc, provider_repo: Arc, conversation_port: Arc, + workspace_manager: Option>, } pub(crate) struct InitialProvisioningResult { @@ -67,9 +73,230 @@ pub struct TeamConversationCreateRequest { pub name: String, pub top_level_model: Option, pub assistant_id: Option, + pub source: Option, + pub channel_chat_id: Option, + pub source_channel: Option, + pub source_channel_id: Option, + pub source_chat_id: Option, + pub source_user_id: Option, + pub source_label: Option, + pub created_from: Option, pub extra: serde_json::Value, } +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct TeamSourceMetadata { + pub source_channel: Option, + pub source_channel_id: Option, + pub source_chat_id: Option, + pub source_user_id: Option, + pub source_label: Option, + pub created_from: Option, +} + +impl TeamSourceMetadata { + pub fn from_create_request(req: &CreateTeamRequest) -> Self { + Self { + source_channel: clean_source(req.source_channel.as_deref()).or_else(|| Some("webui".into())), + source_channel_id: clean_source(req.source_channel_id.as_deref()), + source_chat_id: clean_source(req.source_chat_id.as_deref()), + source_user_id: clean_source(req.source_user_id.as_deref()), + source_label: clean_source(req.source_label.as_deref()).or_else(|| Some("WebUI".into())), + created_from: clean_source(req.created_from.as_deref()).or_else(|| Some("webui".into())), + } + } + + pub fn top_level_source(&self) -> ConversationSource { + match self.source_channel.as_deref() { + Some("telegram") => ConversationSource::Telegram, + Some("lark") => ConversationSource::Lark, + Some("dingtalk") => ConversationSource::Dingtalk, + Some("weixin") | Some("wecom") => ConversationSource::Weixin, + _ => ConversationSource::Aionui, + } + } + + pub fn apply_to_extra(&self, extra: &mut serde_json::Value) { + set_extra_string(extra, "source_channel", self.source_channel.as_deref()); + set_extra_string(extra, "source_channel_id", self.source_channel_id.as_deref()); + set_extra_string(extra, "source_chat_id", self.source_chat_id.as_deref()); + set_extra_string(extra, "source_user_id", self.source_user_id.as_deref()); + set_extra_string(extra, "source_label", self.source_label.as_deref()); + set_extra_string(extra, "created_from", self.created_from.as_deref()); + } +} + +#[cfg(test)] +mod source_metadata_tests { + use super::*; + + #[test] + fn team_source_metadata_applies_telegram_source_to_extra() { + let req = CreateTeamRequest { + name: "Telegram Team".into(), + agents: vec![], + workspace: None, + source_channel: Some("telegram".into()), + source_channel_id: Some("bot-1".into()), + source_chat_id: Some("chat-1".into()), + source_user_id: Some("user-1".into()), + source_label: Some("Telegram".into()), + created_from: Some("telegram".into()), + }; + let metadata = TeamSourceMetadata::from_create_request(&req); + let mut extra = serde_json::json!({}); + + metadata.apply_to_extra(&mut extra); + + assert_eq!(extra["source_channel"], "telegram"); + assert_eq!(extra["source_channel_id"], "bot-1"); + assert_eq!(extra["source_chat_id"], "chat-1"); + assert_eq!(extra["source_user_id"], "user-1"); + assert_eq!(extra["source_label"], "Telegram"); + assert_eq!(extra["created_from"], "telegram"); + assert_eq!(metadata.top_level_source(), ConversationSource::Telegram); + } + + #[test] + fn formal_team_preflight_rejects_stale_dynamic_probe() { + let now = aionui_common::now_ms(); + let raw = serde_json::json!({ + "agent_id": "codex", + "checked_at": now - 25 * 60 * 60 * 1000, + "available_models": ["gpt-5"], + "steps": [ + {"step":"spawn","status":"passed","started_at":now,"duration_ms":1}, + {"step":"initialize","status":"passed","started_at":now,"duration_ms":1}, + {"step":"models","status":"passed","started_at":now,"duration_ms":1}, + {"step":"minimal_prompt","status":"passed","started_at":now,"duration_ms":1}, + {"step":"cancel","status":"passed","started_at":now,"duration_ms":1}, + {"step":"resume","status":"unsupported","started_at":now,"duration_ms":1, + "error_category":"protocol","error_message":"unsupported"} + ] + }) + .to_string(); + + let error = validate_dynamic_probe_result(&raw, "gpt-5", now).unwrap_err(); + assert!(error.to_string().contains("stale")); + } + + #[test] + fn formal_team_preflight_rejects_unobserved_selected_model() { + let now = aionui_common::now_ms(); + let mut result = healthy_probe("codex", now); + result.available_models = vec!["gpt-5".into()]; + let raw = serde_json::to_string(&result).unwrap(); + + let error = validate_dynamic_probe_result(&raw, "gpt-5.6", now).unwrap_err(); + assert!(error.to_string().contains("was not observed")); + } + + #[test] + fn formal_team_preflight_rejects_latest_failed_check_even_with_prior_success() { + let now = aionui_common::now_ms(); + let raw = serde_json::to_string(&healthy_probe("codex", now)).unwrap(); + + let error = validate_agent_dynamic_preflight(Some("offline"), Some(&raw), "gpt-5", now).unwrap_err(); + + assert!(error.to_string().contains("latest health check failed")); + } + + fn healthy_probe(agent_id: &str, checked_at: i64) -> aionui_api_types::AgentDynamicProbeResult { + use aionui_api_types::{AgentProbeStatus, AgentProbeStep, AgentProbeStepResult}; + + aionui_api_types::AgentDynamicProbeResult { + agent_id: agent_id.into(), + checked_at, + available_models: vec!["gpt-5".into()], + steps: [ + AgentProbeStep::Spawn, + AgentProbeStep::Initialize, + AgentProbeStep::Models, + AgentProbeStep::MinimalPrompt, + AgentProbeStep::Cancel, + AgentProbeStep::Resume, + ] + .into_iter() + .map(|step| AgentProbeStepResult { + step, + status: if step == AgentProbeStep::Resume { + AgentProbeStatus::Unsupported + } else { + AgentProbeStatus::Passed + }, + started_at: checked_at, + duration_ms: 1, + error_category: None, + error_message: None, + }) + .collect(), + } + } +} + +fn clean_source(value: Option<&str>) -> Option { + value + .map(str::trim) + .filter(|value| !value.is_empty()) + .map(str::to_owned) +} + +fn set_extra_string(extra: &mut serde_json::Value, key: &str, value: Option<&str>) { + if let Some(value) = value.map(str::trim).filter(|value| !value.is_empty()) { + extra[key] = serde_json::Value::String(value.to_owned()); + } +} + +const DYNAMIC_PROBE_STALE_MS: i64 = 24 * 60 * 60 * 1000; + +fn validate_dynamic_probe_result(raw: &str, selected_model: &str, checked_at: i64) -> Result<(), TeamError> { + let probe: aionui_api_types::AgentDynamicProbeResult = serde_json::from_str(raw).map_err(|_| { + TeamError::InvalidRequest("Agent dynamic probe snapshot is invalid; run health check again".into()) + })?; + if checked_at.saturating_sub(probe.checked_at) > DYNAMIC_PROBE_STALE_MS { + return Err(TeamError::InvalidRequest(format!( + "Agent '{}' dynamic probe is stale; run health check again", + probe.agent_id + ))); + } + if !probe.is_usable() { + return Err(TeamError::InvalidRequest(format!( + "Agent '{}' failed dynamic capability preflight", + probe.agent_id + ))); + } + let selected_model = selected_model.trim(); + if !selected_model.is_empty() + && !selected_model.eq_ignore_ascii_case("default") + && !probe.available_models.iter().any(|model| model == selected_model) + { + return Err(TeamError::InvalidRequest(format!( + "Model '{selected_model}' was not observed during Agent '{}' dynamic probe", + probe.agent_id + ))); + } + Ok(()) +} + +fn validate_agent_dynamic_preflight( + last_check_status: Option<&str>, + dynamic_probe_result: Option<&str>, + selected_model: &str, + checked_at: i64, +) -> Result<(), TeamError> { + if !last_check_status.is_some_and(|status| matches!(status, "online" | "available")) { + return Err(TeamError::InvalidRequest( + "Agent latest health check failed; run health check again before creating a Team".into(), + )); + } + let raw = dynamic_probe_result.ok_or_else(|| { + TeamError::InvalidRequest( + "Agent has no successful dynamic probe; run health check before creating a Team".into(), + ) + })?; + validate_dynamic_probe_result(raw, selected_model, checked_at) +} + #[derive(Debug, Clone, PartialEq, Eq)] pub struct TeamConversationCreateResult { pub conversation_id: String, @@ -87,6 +314,13 @@ pub trait TeamConversationProvisioningPort: Send + Sync { async fn conversation_assistant_id(&self, conversation_id: &str) -> Result, TeamError>; + async fn conversation_source_metadata( + &self, + _conversation_id: &str, + ) -> Result, TeamError> { + Ok(None) + } + async fn create_team_temp_workspace(&self, team_id: &str) -> Result; async fn patch_runtime_config(&self, conversation_id: &str, patch: serde_json::Value) -> Result<(), TeamError>; @@ -127,12 +361,44 @@ impl TeamAgentProvisioner { .map(str::to_owned) } + pub(crate) async fn validate_dynamic_preflight(&self, agents: &[TeamAgentInput]) -> Result<(), TeamError> { + for agent in agents { + let Some(assistant_id) = Self::effective_assistant_id(agent.assistant_id.as_deref()) else { + continue; + }; + let assistant = self + .assistant_catalog + .resolve_team_selectable_assistant(&assistant_id) + .await? + .ok_or_else(|| { + TeamError::InvalidRequest(format!("Assistant is not available for team mode: {assistant_id}")) + })?; + let rows = self.agent_metadata_repo.list_all().await?; + let resolved = resolve_agent_binding_from_rows(&rows, &assistant.backend) + .ok_or_else(|| TeamError::InvalidRequest(format!("Agent not found: {}", assistant.backend)))?; + let row = rows + .iter() + .find(|row| row.id == resolved.agent_id) + .ok_or_else(|| TeamError::InvalidRequest(format!("Agent not found: {}", assistant.backend)))?; + if row.agent_type == "acp" { + validate_agent_dynamic_preflight( + row.last_check_status.as_deref(), + row.dynamic_probe_result.as_deref(), + &agent.model, + now_ms(), + )?; + } + } + Ok(()) + } + pub(crate) fn new( repo: Arc, agent_metadata_repo: Arc, assistant_catalog: Arc, provider_repo: Arc, conversation_port: Arc, + workspace_manager: Option>, ) -> Self { Self { repo, @@ -140,6 +406,7 @@ impl TeamAgentProvisioner { assistant_catalog, provider_repo, conversation_port, + workspace_manager, } } @@ -153,6 +420,8 @@ impl TeamAgentProvisioner { team_id: &str, inputs: &[TeamAgentInput], shared_workspace: Option<&str>, + isolated_workspaces: Option<&PreparedTeamWorkspaces>, + source_metadata: &TeamSourceMetadata, ) -> Result { if inputs.is_empty() { return Err(TeamError::InvalidRequest("at least one agent is required".into())); @@ -174,7 +443,10 @@ impl TeamAgentProvisioner { }; let leader_input = &inputs[*leader_idx]; - let leader_slot_id = generate_id(); + let leader_lease = isolated_workspaces.and_then(|plan| plan.agent_leases.get(*leader_idx)); + let leader_slot_id = leader_lease + .map(|lease| lease.slot_id.clone()) + .unwrap_or_else(generate_id); let leader_role = TeammateRole::Lead; let leader_assistant_id = Self::effective_assistant_id(leader_input.assistant_id.as_deref()); let leader_backend = self @@ -190,21 +462,27 @@ impl TeamAgentProvisioner { &leader_backend, &leader_input.model, leader_assistant_id.as_deref(), - shared_workspace, + leader_lease + .map(|lease| lease.worktree_path.as_str()) + .or(shared_workspace), + source_metadata, None, ) .await?; - let team_workspace = match shared_workspace { - Some(workspace) => workspace.to_owned(), - None => { - self.resolve_initial_leader_workspace( - team_id, - &leader_conversation.conversation_id, - leader_conversation.workspace, - ) - .await? - } + let team_workspace = match isolated_workspaces { + Some(plan) => plan.integration.worktree_path.clone(), + None => match shared_workspace { + Some(workspace) => workspace.to_owned(), + None => { + self.resolve_initial_leader_workspace( + team_id, + &leader_conversation.conversation_id, + leader_conversation.workspace, + ) + .await? + } + }, }; let mut agents = Vec::with_capacity(inputs.len()); @@ -221,12 +499,16 @@ impl TeamAgentProvisioner { cli_path: None, }); - for (input, role) in inputs + for (index, (input, role)) in inputs .iter() .zip(roles.iter()) - .filter(|(_, role)| **role == TeammateRole::Teammate) + .enumerate() + .filter(|(_, (_, role))| **role == TeammateRole::Teammate) { - let slot_id = generate_id(); + let isolated_lease = isolated_workspaces.and_then(|plan| plan.agent_leases.get(index)); + let slot_id = isolated_lease + .map(|lease| lease.slot_id.clone()) + .unwrap_or_else(generate_id); let assistant_id = Self::effective_assistant_id(input.assistant_id.as_deref()); let backend = self .resolve_requested_backend(input.backend.as_deref(), assistant_id.as_deref()) @@ -241,7 +523,10 @@ impl TeamAgentProvisioner { &backend, &input.model, assistant_id.as_deref(), - Some(&team_workspace), + isolated_lease + .map(|lease| lease.worktree_path.as_str()) + .or(Some(&team_workspace)), + source_metadata, None, ) .await?; @@ -291,7 +576,10 @@ impl TeamAgentProvisioner { "add_agent only supports teammate role".into(), )); } - let workspace = self.workspace_resolver().resolve_for_new_agent(row, team).await?; + let slot_id = generate_id(); + let workspace = self + .resolve_workspace_for_new_agent(user_id, row, team, &slot_id, &req.name) + .await?; let assistant_id = Self::effective_assistant_id(req.assistant_id.as_deref()); let backend = self .resolve_requested_backend(req.backend.as_deref(), assistant_id.as_deref()) @@ -300,7 +588,7 @@ impl TeamAgentProvisioner { .provision_new_agent(NewAgentProvisioning { user_id: user_id.to_owned(), team_id: team.id.clone(), - slot_id: generate_id(), + slot_id: slot_id.clone(), name: req.name, role, backend, @@ -309,7 +597,14 @@ impl TeamAgentProvisioner { workspace: Some(workspace), session_mode: row.session_mode.clone(), }) - .await?; + .await; + let agent = match agent { + Ok(agent) => agent, + Err(error) => { + self.release_failed_isolated_slot(row, &slot_id).await; + return Err(error); + } + }; team.agents.push(agent.clone()); self.persist_agents(&team.id, &team.agents).await?; Ok(agent) @@ -347,7 +642,10 @@ impl TeamAgentProvisioner { .await? .ok_or_else(|| TeamError::TeamNotFound(req.team_id.clone()))?; let mut team = Team::from_row(&row)?; - let workspace = self.workspace_resolver().resolve_for_new_agent(&row, &team).await?; + let slot_id = req.slot_id.clone(); + let workspace = self + .resolve_workspace_for_new_agent(&req.user_id, &row, &team, &slot_id, &req.name) + .await?; let agent = self .provision_new_agent(NewAgentProvisioning { user_id: req.user_id, @@ -361,7 +659,14 @@ impl TeamAgentProvisioner { workspace: Some(workspace), session_mode: row.session_mode.clone(), }) - .await?; + .await; + let agent = match agent { + Ok(agent) => agent, + Err(error) => { + self.release_failed_isolated_slot(&row, &slot_id).await; + return Err(error); + } + }; team.agents.push(agent.clone()); self.persist_agents(&req.team_id, &team.agents).await?; Ok(agent) @@ -508,6 +813,7 @@ impl TeamAgentProvisioner { &input.model, input.assistant_id.as_deref(), input.workspace.as_deref(), + &TeamSourceMetadata::default(), input.session_mode.as_deref(), ) .await?; @@ -537,6 +843,7 @@ impl TeamAgentProvisioner { model: &str, assistant_id: Option<&str>, workspace: Option<&str>, + source_metadata: &TeamSourceMetadata, session_mode: Option<&str>, ) -> Result { let acp_metadata = acp_backend_metadata(&self.agent_metadata_repo, backend).await?; @@ -556,6 +863,7 @@ impl TeamAgentProvisioner { agent_type, acp_metadata.as_ref(), session_mode, + source_metadata, ); let provider_id = if agent_type == AgentType::Aionrs { self.resolve_provider_for_model(model) @@ -587,6 +895,14 @@ impl TeamAgentProvisioner { name: name.to_owned(), top_level_model, assistant_id: assistant_id.map(str::to_owned), + source: Some(source_metadata.top_level_source()), + channel_chat_id: source_metadata.source_chat_id.clone(), + source_channel: source_metadata.source_channel.clone(), + source_channel_id: source_metadata.source_channel_id.clone(), + source_chat_id: source_metadata.source_chat_id.clone(), + source_user_id: source_metadata.source_user_id.clone(), + source_label: source_metadata.source_label.clone(), + created_from: source_metadata.created_from.clone(), extra, }) .await?; @@ -658,6 +974,7 @@ impl TeamAgentProvisioner { agent_type: AgentType, acp_metadata: Option<&AgentMetadataRow>, session_mode: Option<&str>, + source_metadata: &TeamSourceMetadata, ) -> serde_json::Value { let session_mode = session_mode .map(str::trim) @@ -680,6 +997,7 @@ impl TeamAgentProvisioner { if let Some(workspace) = workspace { inherit_team_workspace(&mut extra, workspace); } + source_metadata.apply_to_extra(&mut extra); extra } @@ -710,6 +1028,35 @@ impl TeamAgentProvisioner { } None } + + async fn resolve_workspace_for_new_agent( + &self, + user_id: &str, + row: &TeamRow, + team: &Team, + slot_id: &str, + name: &str, + ) -> Result { + if matches!(row.workspace_mode.as_str(), "isolated" | "isolated_worktree") { + let manager = self + .workspace_manager + .as_ref() + .ok_or_else(|| TeamError::WorkspaceOperation("isolated worktree support is unavailable".into()))?; + return Ok(manager + .allocate_agent(user_id, &row.id, &WorkspaceAgentSpec::new(slot_id, name)) + .await? + .worktree_path); + } + self.workspace_resolver().resolve_for_new_agent(row, team).await + } + + async fn release_failed_isolated_slot(&self, row: &TeamRow, slot_id: &str) { + if matches!(row.workspace_mode.as_str(), "isolated" | "isolated_worktree") + && let Some(manager) = &self.workspace_manager + { + let _ = manager.release_slot(&row.id, slot_id).await; + } + } } #[cfg(test)] @@ -942,6 +1289,7 @@ mod tests { Arc::new(EmptyTeamAssistantCatalog), Arc::new(EmptyProviderRepo), Arc::new(RecordingProvisioningPort { events, patches }), + None, ) } diff --git a/crates/aionui-team/src/routes.rs b/crates/aionui-team/src/routes.rs index 0bab888ff..61b9144f2 100644 --- a/crates/aionui-team/src/routes.rs +++ b/crates/aionui-team/src/routes.rs @@ -10,7 +10,7 @@ use axum::routing::{get, post}; use aionui_ai_agent::ActiveLeaseRegistry; use aionui_api_types::{ - AddAgentRequest, ApiResponse, CancelTeamChildTurnRequest, CancelTeamRunRequest, CreateTeamRequest, + AddAgentRequest, ApiResponse, CancelTeamChildTurnRequest, CancelTeamRunRequest, CreateTeamHttpRequest, GetConfigOptionsResponse, PauseTeamSlotRequest, RenameAgentRequest, RenameTeamRequest, SendAgentMessageRequest, SendTeamMessageRequest, SetModeRequest, TeamAgentResponse, TeamListResponse, TeamResponse, TeamRunAckResponse, TeamRunStateResponse, @@ -54,7 +54,7 @@ impl From for ApiError { TeamError::LeaderOnly(msg) => ApiError::Forbidden(msg), TeamError::Forbidden(msg) => ApiError::Forbidden(msg), TeamError::SessionNotFound(msg) => ApiError::NotFound(msg), - TeamError::BlockedTaskNotFound(msg) => ApiError::BadRequest(msg), + TeamError::BlockedTaskNotFound(msg) | TeamError::TaskDependencyCycle(msg) => ApiError::BadRequest(msg), TeamError::BackendNotAllowed(msg) => ApiError::BadRequest(msg), TeamError::DuplicateAgentName(msg) => ApiError::BadRequest(format!("Agent name already taken: {msg}")), TeamError::RuntimeNotReady { conversation_id } => ApiError::coded( @@ -81,6 +81,7 @@ impl From for ApiError { ), TeamError::WorkspacePathUnavailable(path) => ApiError::WorkspacePathUnavailable(path), TeamError::WorkspacePathRuntimeUnavailable(path) => ApiError::WorkspacePathRuntimeUnavailable(path), + TeamError::WorkspaceOperation(message) => ApiError::BadRequest(message), TeamError::Database(db_err) => db_error_to_api_error(db_err), TeamError::Json(e) => ApiError::Internal(format!("JSON error: {e}")), } @@ -123,10 +124,13 @@ pub fn team_routes(state: TeamRouterState) -> Router { async fn create_team( State(state): State, Extension(user): Extension, - body: Result, JsonRejection>, + body: Result, JsonRejection>, ) -> Result<(StatusCode, Json>), ApiError> { let Json(req) = body.map_err(ApiError::from)?; - let team = state.service.create_team(&user.id, req).await?; + let team = state + .service + .create_team_with_workspace_mode(&user.id, req.team, req.workspace_mode) + .await?; Ok((StatusCode::CREATED, Json(ApiResponse::ok(team)))) } diff --git a/crates/aionui-team/src/scheduler/state.rs b/crates/aionui-team/src/scheduler/state.rs index 179b1931e..e1b5533ce 100644 --- a/crates/aionui-team/src/scheduler/state.rs +++ b/crates/aionui-team/src/scheduler/state.rs @@ -44,7 +44,12 @@ impl TeammateManager { } pub async fn mark_idle(&self, slot_id: &str, summary: Option<&str>) -> Result, TeamError> { - self.set_status(slot_id, TeammateStatus::Idle).await?; + // Error is a terminal observation for the completed turn. Finalization + // must still notify/wake the lead, but it must not erase the crash + // signal by publishing a later Idle status. + if self.get_status(slot_id).await? != TeammateStatus::Error { + self.set_status(slot_id, TeammateStatus::Idle).await?; + } let is_lead = { let slots = self.slots.lock().await; diff --git a/crates/aionui-team/src/service.rs b/crates/aionui-team/src/service.rs index 68daf8a04..977b31c60 100644 --- a/crates/aionui-team/src/service.rs +++ b/crates/aionui-team/src/service.rs @@ -12,7 +12,7 @@ use aionui_api_types::{ AddAgentRequest, CreateTeamRequest, GetConfigOptionsResponse, TeamAgentResponse, TeamAgentRuntimeStatus, TeamResponse, TeamRunAckResponse, TeamRunStateResponse, TeamSessionBinding, TeamSessionPhase, TeamSessionStatus, TeamSessionStatusPayload, TeamToolCall, TeamToolContextResponse, TeamToolErrorCode, TeamToolErrorPayload, - TeamToolTransport, WebSocketMessage, + TeamToolTransport, TeamWorkspaceMode, WebSocketMessage, }; use aionui_common::{AgentKillReason, ConversationStatus, TimestampMs, generate_id, now_ms}; use aionui_db::models::TeamRow; @@ -37,7 +37,7 @@ use crate::member_runtime::{ use crate::message_projection::TeamProjectionMessageStore; use crate::ports::{AgentTurnCancellationPort, AgentTurnExecutionPort, TeamAssistantCatalogPort}; use crate::prompt_dump::TeamPromptDumpConfig; -use crate::provisioning::{TeamAgentProvisioner, TeamConversationProvisioningPort}; +use crate::provisioning::{TeamAgentProvisioner, TeamConversationProvisioningPort, TeamSourceMetadata}; use crate::runtime_tools::{ ResolvedTeamToolContext, agent_for_conversation, error_payload, execute_with_scheduler, role_to_tool_role, }; @@ -47,6 +47,7 @@ use crate::types::{Team, TeamAgent, TeammateRole}; use crate::work_coordinator::RuntimeConstraint; use crate::work_source::WorkSource; use crate::workspace::validate_create_workspace_path; +use crate::{TeamWorkspaceManager, WorkspaceAgentSpec}; pub(crate) fn inherit_team_workspace(extra: &mut serde_json::Value, workspace: &str) { if !workspace.trim().is_empty() { @@ -189,6 +190,7 @@ pub struct TeamSessionService { turn_port: Arc, cancellation_port: Arc, backend_binary_path: Arc, + workspace_manager: Option>, prompt_dump: TeamPromptDumpConfig, sessions: Arc>, /// Per-team mutex serializing membership mutations with session startup so @@ -272,6 +274,84 @@ impl TeamSessionService { turn_port, cancellation_port, backend_binary_path, + workspace_manager: None, + prompt_dump, + sessions: Arc::new(DashMap::new()), + add_agent_locks: Arc::new(DashMap::new()), + ensure_session_locks: Arc::new(DashMap::new()), + self_ref: weak.clone(), + }) + } + + #[allow(clippy::too_many_arguments)] + pub fn new_with_workspace_manager( + repo: Arc, + agent_metadata_repo: Arc, + assistant_catalog: Arc, + assistant_definition_repo: Arc, + assistant_overlay_repo: Arc, + provider_repo: Arc, + conversation_port: Arc, + projection_store: Arc, + broadcaster: Arc, + task_manager: Arc, + turn_port: Arc, + cancellation_port: Arc, + backend_binary_path: Arc, + workspace_manager: Arc, + ) -> Arc { + Self::new_with_workspace_manager_and_prompt_dump( + repo, + agent_metadata_repo, + assistant_catalog, + assistant_definition_repo, + assistant_overlay_repo, + provider_repo, + conversation_port, + projection_store, + broadcaster, + task_manager, + turn_port, + cancellation_port, + backend_binary_path, + workspace_manager, + TeamPromptDumpConfig::disabled(), + ) + } + + #[allow(clippy::too_many_arguments)] + pub fn new_with_workspace_manager_and_prompt_dump( + repo: Arc, + agent_metadata_repo: Arc, + assistant_catalog: Arc, + assistant_definition_repo: Arc, + assistant_overlay_repo: Arc, + provider_repo: Arc, + conversation_port: Arc, + projection_store: Arc, + broadcaster: Arc, + task_manager: Arc, + turn_port: Arc, + cancellation_port: Arc, + backend_binary_path: Arc, + workspace_manager: Arc, + prompt_dump: TeamPromptDumpConfig, + ) -> Arc { + Arc::new_cyclic(|weak| Self { + repo, + agent_metadata_repo, + assistant_catalog, + assistant_definition_repo, + assistant_overlay_repo, + provider_repo, + conversation_port, + projection_store, + broadcaster, + task_manager, + turn_port, + cancellation_port, + backend_binary_path, + workspace_manager: Some(workspace_manager), prompt_dump, sessions: Arc::new(DashMap::new()), add_agent_locks: Arc::new(DashMap::new()), @@ -287,6 +367,7 @@ impl TeamSessionService { self.assistant_catalog.clone(), self.provider_repo.clone(), self.conversation_port.clone(), + self.workspace_manager.clone(), ) } @@ -351,6 +432,11 @@ impl TeamSessionService { /// Restore sessions for all existing teams. Called once at app startup /// so that MCP servers are available before any user sends a message. pub async fn restore_all_sessions(&self) { + if let Some(manager) = &self.workspace_manager + && let Err(error) = manager.reconcile_all().await + { + tracing::warn!(error = %error, "failed to reconcile Team workspaces on startup"); + } let teams = match self.repo.list_teams().await { Ok(t) => t, Err(e) => { @@ -370,6 +456,16 @@ impl TeamSessionService { } pub async fn create_team(&self, user_id: &str, req: CreateTeamRequest) -> Result { + self.create_team_with_workspace_mode(user_id, req, TeamWorkspaceMode::Shared) + .await + } + + pub async fn create_team_with_workspace_mode( + &self, + user_id: &str, + req: CreateTeamRequest, + workspace_mode: TeamWorkspaceMode, + ) -> Result { if req.agents.is_empty() { return Err(TeamError::InvalidRequest("at least one agent is required".into())); } @@ -384,18 +480,62 @@ impl TeamSessionService { )); } - let shared_workspace = match req.workspace.as_deref() { + self.provisioner().validate_dynamic_preflight(&req.agents).await?; + + let requested_workspace = match req.workspace.as_deref() { Some(workspace) if !workspace.is_empty() => Some(validate_create_workspace_path(workspace)?), _ => None, }; let team_id = generate_id(); let now = now_ms(); + let source_metadata = TeamSourceMetadata::from_create_request(&req); + let slot_specs = req + .agents + .iter() + .map(|agent| WorkspaceAgentSpec::new(generate_id(), &agent.name)) + .collect::>(); + let prepared_workspaces = match workspace_mode { + TeamWorkspaceMode::Shared => None, + TeamWorkspaceMode::IsolatedWorktree => { + let repository = requested_workspace.as_deref().ok_or_else(|| { + TeamError::InvalidRequest("workspace is required for isolated_worktree mode".into()) + })?; + let manager = self + .workspace_manager + .as_ref() + .ok_or_else(|| TeamError::WorkspaceOperation("isolated worktree support is unavailable".into()))?; + Some(manager.prepare_team(user_id, &team_id, repository, &slot_specs).await?) + } + }; + let shared_workspace = if workspace_mode == TeamWorkspaceMode::Shared { + requested_workspace.as_deref() + } else { + None + }; - let provisioned = self + let provisioned_result = self .provisioner() - .provision_initial_agents(user_id, &team_id, &req.agents, shared_workspace.as_deref()) - .await?; + .provision_initial_agents( + user_id, + &team_id, + &req.agents, + shared_workspace, + prepared_workspaces.as_ref(), + &source_metadata, + ) + .await; + let provisioned = match provisioned_result { + Ok(provisioned) => provisioned, + Err(error) => { + if prepared_workspaces.is_some() + && let Some(manager) = &self.workspace_manager + { + let _ = manager.release_team(&team_id).await; + } + return Err(error); + } + }; let agents = provisioned.agents; let lead_agent_id = provisioned.lead_agent_id; let team_workspace = provisioned.team_workspace; @@ -406,22 +546,42 @@ impl TeamSessionService { user_id: user_id.to_owned(), name: req.name.clone(), workspace: team_workspace.clone(), - workspace_mode: "shared".into(), + workspace_mode: workspace_mode.as_str().into(), agents: agents_json, lead_agent_id: lead_agent_id.clone(), session_mode: None, agents_version: "1.0.1".into(), + source_channel: source_metadata.source_channel.clone(), + source_channel_id: source_metadata.source_channel_id.clone(), + source_chat_id: source_metadata.source_chat_id.clone(), + source_user_id: source_metadata.source_user_id.clone(), + source_label: source_metadata.source_label.clone(), + created_from: source_metadata.created_from.clone(), created_at: now, updated_at: now, }; - self.repo.create_team(&row).await?; + if let Err(error) = self.repo.create_team(&row).await { + if prepared_workspaces.is_some() + && let Some(manager) = &self.workspace_manager + { + let _ = manager.release_team(&team_id).await; + } + return Err(error.into()); + } let team = Team { id: team_id, name: req.name, workspace: team_workspace, + workspace_mode, agents, lead_agent_id, + source_channel: source_metadata.source_channel, + source_channel_id: source_metadata.source_channel_id, + source_chat_id: source_metadata.source_chat_id, + source_user_id: source_metadata.source_user_id, + source_label: source_metadata.source_label, + created_from: source_metadata.created_from, created_at: now, updated_at: now, }; @@ -493,6 +653,25 @@ impl TeamSessionService { .await; } + if team.workspace_mode == TeamWorkspaceMode::IsolatedWorktree + && let Some(manager) = &self.workspace_manager + { + let cleanup = manager.release_team(team_id).await?; + let preserved = cleanup + .iter() + .filter(|result| { + matches!( + result.disposition, + crate::WorkspaceCleanupDisposition::DirtyPreserved + | crate::WorkspaceCleanupDisposition::MissingPreserved + ) + }) + .count(); + if preserved > 0 { + warn!(team_id, preserved, "Team removed with workspace diagnostics preserved"); + } + } + self.repo.delete_mailbox_by_team(team_id).await?; self.repo.delete_tasks_by_team(team_id).await?; self.repo.delete_team(team_id).await?; @@ -593,7 +772,7 @@ impl TeamSessionService { .entry(team_id.to_owned()) .or_insert_with(|| Arc::new(tokio::sync::Mutex::new(()))) .clone(); - let (removed, session, removal_lease) = { + let (removed, session, removal_lease, workspace_mode) = { let _guard = lock.lock().await; let team = self.load_owned_team(user_id, team_id).await?; let removed = team @@ -628,7 +807,7 @@ impl TeamSessionService { } Some(BeginRemove::Absent | BeginRemove::SessionStopped) | None => None, }; - (removed, session, removal_lease) + (removed, session, removal_lease, team.workspace_mode) }; // Cancellation and process cleanup intentionally happen without the @@ -703,6 +882,19 @@ impl TeamSessionService { None }; + if workspace_mode == TeamWorkspaceMode::IsolatedWorktree + && let Some(manager) = &self.workspace_manager + { + let cleanup = manager.release_slot(team_id, slot_id).await?; + if matches!( + cleanup.disposition, + crate::WorkspaceCleanupDisposition::DirtyPreserved + | crate::WorkspaceCleanupDisposition::MissingPreserved + ) { + warn!(team_id, slot_id, "Agent workspace preserved during removal"); + } + } + if let Err(error) = self .conversation_port .delete_team_conversation(user_id, &removed.conversation_id) @@ -2383,6 +2575,12 @@ mod tests { }, ], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, } } @@ -2995,6 +3193,12 @@ mod tests { status: Some("pending".to_owned()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: now_ms(), @@ -3017,6 +3221,12 @@ mod tests { status: Some("pending".to_owned()), source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, pinned: false, pinned_at: None, created_at: now_ms(), diff --git a/crates/aionui-team/src/service/response_builder.rs b/crates/aionui-team/src/service/response_builder.rs index 1cc387553..767b533dc 100644 --- a/crates/aionui-team/src/service/response_builder.rs +++ b/crates/aionui-team/src/service/response_builder.rs @@ -6,18 +6,106 @@ impl TeamSessionService { for agent in &team.agents { agents.push(self.build_agent_response(agent).await?); } + let source_metadata = match self.team_row_source_metadata(team) { + Some(metadata) => Some(metadata), + None => self.resolve_team_source_metadata(team).await?, + }; + let workspace_leases = if team.workspace_mode == aionui_api_types::TeamWorkspaceMode::IsolatedWorktree { + match &self.workspace_manager { + Some(manager) => manager + .list_team_leases(&team.id) + .await? + .into_iter() + .map(|lease| aionui_api_types::AgentWorkspaceLeaseResponse { + id: lease.id, + slot_id: lease.slot_id, + worktree_path: lease.worktree_path, + branch_name: lease.branch_name, + base_commit: lease.base_commit, + allowed_paths: serde_json::from_str(&lease.allowed_paths).unwrap_or_else(|_| vec![".".into()]), + lease_status: lease.lease_status, + cleanup_status: lease.cleanup_status, + conflict_files: serde_json::from_str(&lease.conflict_files).unwrap_or_default(), + last_error: lease.last_error, + }) + .collect(), + None => vec![], + } + } else { + vec![] + }; Ok(TeamResponse { id: team.id.clone(), name: team.name.clone(), workspace: team.workspace.clone(), + workspace_mode: team.workspace_mode, + workspace_leases, assistants: agents, leader_assistant_id: team.lead_agent_id.clone(), + source_channel: source_metadata + .as_ref() + .and_then(|metadata| metadata.source_channel.clone()), + source_channel_id: source_metadata + .as_ref() + .and_then(|metadata| metadata.source_channel_id.clone()), + source_chat_id: source_metadata + .as_ref() + .and_then(|metadata| metadata.source_chat_id.clone()), + source_user_id: source_metadata + .as_ref() + .and_then(|metadata| metadata.source_user_id.clone()), + source_label: source_metadata + .as_ref() + .and_then(|metadata| metadata.source_label.clone()), + created_from: source_metadata + .as_ref() + .and_then(|metadata| metadata.created_from.clone()), created_at: team.created_at, updated_at: team.updated_at, }) } + fn team_row_source_metadata(&self, team: &Team) -> Option { + if team + .source_channel + .as_deref() + .is_none_or(|value| value.trim().is_empty()) + { + return None; + } + Some(crate::provisioning::TeamSourceMetadata { + source_channel: team.source_channel.clone(), + source_channel_id: team.source_channel_id.clone(), + source_chat_id: team.source_chat_id.clone(), + source_user_id: team.source_user_id.clone(), + source_label: team.source_label.clone(), + created_from: team.created_from.clone(), + }) + } + + async fn resolve_team_source_metadata( + &self, + team: &Team, + ) -> Result, TeamError> { + let lead = team + .lead_agent_id + .as_deref() + .and_then(|lead_id| team.agents.iter().find(|agent| agent.slot_id == lead_id)) + .or_else(|| { + team.agents + .iter() + .find(|agent| agent.role == crate::types::TeammateRole::Lead) + }) + .or_else(|| team.agents.first()); + let Some(lead) = lead else { + return Ok(None); + }; + self.conversation_port + .conversation_source_metadata(&lead.conversation_id) + .await + } + pub(super) async fn build_agent_response( &self, agent: &TeamAgent, diff --git a/crates/aionui-team/src/service/spawn_support.rs b/crates/aionui-team/src/service/spawn_support.rs index 987d8fa3c..2d57a47d4 100644 --- a/crates/aionui-team/src/service/spawn_support.rs +++ b/crates/aionui-team/src/service/spawn_support.rs @@ -260,6 +260,7 @@ mod tests { last_check_at: None, last_success_at: None, last_failure_at: None, + dynamic_probe_result: None, command_override: None, env_override: None, created_at: 0, diff --git a/crates/aionui-team/src/session.rs b/crates/aionui-team/src/session.rs index 48453cf52..2c2a39feb 100644 --- a/crates/aionui-team/src/session.rs +++ b/crates/aionui-team/src/session.rs @@ -463,9 +463,6 @@ impl TeamSession { let wake_target = self.scheduler.finalize_turn(&slot_id, &[]).await?; - // Clear the dedup window unconditionally once finalize has run. - self.scheduler.clear_finalized_turn(conversation_id); - // Re-wake self if there are still unread messages in mailbox. // This handles the case where messages arrived while the agent was // working (e.g. shutdown_request). Mirrors Claude's useMailboxBridge: @@ -2004,6 +2001,7 @@ mod tests { id: "t1".into(), name: "Test Team".into(), workspace: "/tmp/test-team".into(), + workspace_mode: aionui_api_types::TeamWorkspaceMode::Shared, agents: vec![ TeamAgent { slot_id: "lead-1".into(), @@ -2031,6 +2029,12 @@ mod tests { }, ], lead_agent_id: Some("lead-1".into()), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, created_at: 1000, updated_at: 1000, } diff --git a/crates/aionui-team/src/task_board.rs b/crates/aionui-team/src/task_board.rs index 54b8f83a4..4e52399ac 100644 --- a/crates/aionui-team/src/task_board.rs +++ b/crates/aionui-team/src/task_board.rs @@ -1,3 +1,4 @@ +use std::collections::{HashMap, HashSet}; use std::sync::Arc; use aionui_common::{generate_id, now_ms}; @@ -79,6 +80,10 @@ impl TaskBoard { .await? .ok_or_else(|| TeamError::TaskNotFound(task_id.to_owned()))?; + if let Some(blocked_by) = update.blocked_by.as_deref() { + self.validate_dependencies(team_id, task_id, blocked_by).await?; + } + let params = UpdateTaskParams { status: update.status.map(|s| s.to_string()), description: update.description.clone(), @@ -104,6 +109,31 @@ impl TaskBoard { TeamTask::from_row(&updated).map_err(TeamError::Json) } + async fn validate_dependencies( + &self, + team_id: &str, + task_id: &str, + blocked_by: &[String], + ) -> Result<(), TeamError> { + let rows = self.repo.list_tasks(team_id).await?; + let mut graph = HashMap::with_capacity(rows.len()); + for row in rows { + graph.insert(row.id, serde_json::from_str::>(&row.blocked_by)?); + } + + for dependency_id in blocked_by { + if !graph.contains_key(dependency_id) { + return Err(TeamError::BlockedTaskNotFound(dependency_id.clone())); + } + if dependency_id == task_id || depends_on(&graph, dependency_id, task_id) { + return Err(TeamError::TaskDependencyCycle(format!( + "adding {dependency_id} as a dependency of {task_id} would create a cycle" + ))); + } + } + Ok(()) + } + pub async fn list_tasks(&self, team_id: &str) -> Result, TeamError> { let rows = self.repo.list_tasks(team_id).await?; let tasks = rows.iter().filter_map(|r| TeamTask::from_row(r).ok()).collect(); @@ -126,6 +156,24 @@ impl TaskBoard { } } +fn depends_on(graph: &HashMap>, start: &str, target: &str) -> bool { + let mut pending = vec![start.to_owned()]; + let mut visited = HashSet::new(); + while let Some(current) = pending.pop() { + if !visited.insert(current.clone()) { + continue; + } + let Some(dependencies) = graph.get(¤t) else { + continue; + }; + if dependencies.iter().any(|dependency| dependency == target) { + return true; + } + pending.extend(dependencies.iter().cloned()); + } + false +} + #[cfg(test)] mod tests { use super::*; @@ -191,6 +239,54 @@ mod tests { assert!(matches!(result, Err(TeamError::BlockedTaskNotFound(_)))); } + #[tokio::test] + async fn update_task_rejects_self_dependency() { + let repo = Arc::new(MockTeamRepo::new()); + let board = TaskBoard::new(repo); + let task = create_simple_task(&board, "t1", "Task A").await; + + let result = board + .update_task( + "t1", + &task.id, + &TaskUpdate { + blocked_by: Some(vec![task.id.clone()]), + ..Default::default() + }, + ) + .await; + + assert!(matches!(result, Err(TeamError::TaskDependencyCycle(_)))); + } + + #[tokio::test] + async fn update_task_rejects_transitive_dependency_cycle() { + let repo = Arc::new(MockTeamRepo::new()); + let board = TaskBoard::new(repo); + let task_a = create_simple_task(&board, "t1", "Task A").await; + let task_b = board + .create_task("t1", "Task B", None, None, std::slice::from_ref(&task_a.id)) + .await + .unwrap(); + let task_c = board + .create_task("t1", "Task C", None, None, std::slice::from_ref(&task_b.id)) + .await + .unwrap(); + + let result = board + .update_task( + "t1", + &task_a.id, + &TaskUpdate { + blocked_by: Some(vec![task_c.id]), + ..Default::default() + }, + ) + .await; + + assert!(matches!(result, Err(TeamError::TaskDependencyCycle(_)))); + } + #[tokio::test] async fn update_task_status() { let repo = Arc::new(MockTeamRepo::new()); diff --git a/crates/aionui-team/src/test_utils.rs b/crates/aionui-team/src/test_utils.rs index ff409483b..494f5ed0d 100644 --- a/crates/aionui-team/src/test_utils.rs +++ b/crates/aionui-team/src/test_utils.rs @@ -563,8 +563,19 @@ pub(crate) mod workspace_harness { r#type: request.agent_type.unwrap_or(AgentType::Acp).serde_name().to_owned(), pinned: false, pinned_at: None, - source: None, - channel_chat_id: None, + source: request.source.map(|source| { + serde_json::to_value(source) + .ok() + .and_then(|value| value.as_str().map(str::to_owned)) + .unwrap_or_else(|| "aionui".into()) + }), + channel_chat_id: request.channel_chat_id, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::to_string(&extra).unwrap(), model: request .top_level_model @@ -1078,6 +1089,12 @@ pub(crate) mod workspace_harness { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, } } } diff --git a/crates/aionui-team/src/types.rs b/crates/aionui-team/src/types.rs index 7c7dca5f0..c788ab57f 100644 --- a/crates/aionui-team/src/types.rs +++ b/crates/aionui-team/src/types.rs @@ -1,6 +1,6 @@ use std::fmt; -use aionui_api_types::{TeamAgentResponse, TeamResponse}; +use aionui_api_types::{TeamAgentResponse, TeamResponse, TeamWorkspaceMode}; use aionui_common::TimestampMs; use serde::{Deserialize, Serialize}; @@ -147,9 +147,23 @@ pub struct Team { pub id: String, pub name: String, pub workspace: String, + #[serde(default)] + pub workspace_mode: TeamWorkspaceMode, pub agents: Vec, #[serde(skip_serializing_if = "Option::is_none")] pub lead_agent_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_channel: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_channel_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_chat_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_user_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_label: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub created_from: Option, pub created_at: TimestampMs, pub updated_at: TimestampMs, } @@ -216,8 +230,16 @@ pub struct MailboxMessage { #[serde(rename_all = "snake_case")] pub enum TaskStatus { Pending, + Ready, + Claimed, InProgress, + WaitingApproval, + Verifying, + Review, + Rework, Completed, + Failed, + Cancelled, Deleted, } @@ -225,8 +247,16 @@ impl fmt::Display for TaskStatus { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::Pending => write!(f, "pending"), + Self::Ready => write!(f, "ready"), + Self::Claimed => write!(f, "claimed"), Self::InProgress => write!(f, "in_progress"), + Self::WaitingApproval => write!(f, "waiting_approval"), + Self::Verifying => write!(f, "verifying"), + Self::Review => write!(f, "review"), + Self::Rework => write!(f, "rework"), Self::Completed => write!(f, "completed"), + Self::Failed => write!(f, "failed"), + Self::Cancelled => write!(f, "cancelled"), Self::Deleted => write!(f, "deleted"), } } @@ -236,8 +266,16 @@ impl TaskStatus { pub fn parse(s: &str) -> Option { match s { "pending" => Some(Self::Pending), + "ready" => Some(Self::Ready), + "claimed" => Some(Self::Claimed), "in_progress" => Some(Self::InProgress), + "waiting_approval" => Some(Self::WaitingApproval), + "verifying" => Some(Self::Verifying), + "review" => Some(Self::Review), + "rework" => Some(Self::Rework), "completed" => Some(Self::Completed), + "failed" => Some(Self::Failed), + "cancelled" => Some(Self::Cancelled), "deleted" => Some(Self::Deleted), _ => None, } @@ -279,8 +317,18 @@ impl Team { id: row.id.clone(), name: row.name.clone(), workspace: row.workspace.clone(), + workspace_mode: match row.workspace_mode.as_str() { + "isolated" | "isolated_worktree" => TeamWorkspaceMode::IsolatedWorktree, + _ => TeamWorkspaceMode::Shared, + }, agents, lead_agent_id: row.lead_agent_id.clone(), + source_channel: row.source_channel.clone(), + source_channel_id: row.source_channel_id.clone(), + source_chat_id: row.source_chat_id.clone(), + source_user_id: row.source_user_id.clone(), + source_label: row.source_label.clone(), + created_from: row.created_from.clone(), created_at: row.created_at, updated_at: row.updated_at, }) @@ -291,8 +339,16 @@ impl Team { id: self.id.clone(), name: self.name.clone(), workspace: self.workspace.clone(), + workspace_mode: self.workspace_mode, + workspace_leases: vec![], assistants: self.agents.iter().map(|a| a.to_response()).collect(), leader_assistant_id: self.lead_agent_id.clone(), + source_channel: self.source_channel.clone(), + source_channel_id: self.source_channel_id.clone(), + source_chat_id: self.source_chat_id.clone(), + source_user_id: self.source_user_id.clone(), + source_label: self.source_label.clone(), + created_from: self.created_from.clone(), created_at: self.created_at, updated_at: self.updated_at, } @@ -641,6 +697,12 @@ mod tests { lead_agent_id: Some("s1".into()), session_mode: None, agents_version: "1.0.1".into(), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, created_at: 1000, updated_at: 2000, }; @@ -657,6 +719,7 @@ mod tests { id: "t1".into(), name: "Alpha".into(), workspace: "/workspace/team".into(), + workspace_mode: TeamWorkspaceMode::Shared, agents: vec![TeamAgent { slot_id: "s1".into(), name: "Lead".into(), @@ -670,6 +733,12 @@ mod tests { cli_path: None, }], lead_agent_id: Some("s1".into()), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, created_at: 1000, updated_at: 2000, }; @@ -695,6 +764,12 @@ mod tests { lead_agent_id: None, session_mode: None, agents_version: "1.0.1".into(), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, created_at: 0, updated_at: 0, }; diff --git a/crates/aionui-team/tests/e2e_smoke.rs b/crates/aionui-team/tests/e2e_smoke.rs index ddfc18a8e..0fdc40659 100644 --- a/crates/aionui-team/tests/e2e_smoke.rs +++ b/crates/aionui-team/tests/e2e_smoke.rs @@ -6,22 +6,9 @@ //! and asserting the observable side effect — not just a success return //! code. //! -//! **Scenario status:** -//! - scenario 1 (create team → lead → MCP tools available) — `todo!()`, -//! `#[ignore]`. Unblocks when `spawn_agent` + MCP wiring lands. -//! - scenario 2 (`team_spawn_agent` creates a real session) — `todo!()`, -//! `#[ignore]`. Unblocks when `spawn_agent` is implemented -//! (see W5-D29a-* modules). -//! - scenario 3 (shutdown full protocol) — `todo!()`, `#[ignore]`. Unblocks -//! when shutdown_agent / shutdown_approved mailbox wiring lands. -//! - scenario 4 (crash → testament → leader wake) — `todo!()`, `#[ignore]`. -//! Unblocks when the crash handler is wired into the stream pipeline. -//! - scenario 5 (MCP tool execution is not a no-op) — **runs now**. Uses -//! only pieces that already exist (mailbox + task board + TeamMcpServer) -//! and is the first real e2e guard. -//! -//! All ignored scenarios must stay compiling so the scaffold itself never -//! rots between waves. +//! Every scenario runs in CI. Together with `session_service_integration`, +//! these tests cover the real MCP transport, scheduler lifecycle, persistent +//! spawn service, mailbox protocol, crash testament, and observable effects. mod common; @@ -30,7 +17,10 @@ use std::sync::Arc; use aionui_api_types::WebSocketMessage; use aionui_realtime::EventBroadcaster; use aionui_team::mcp::protocol::{read_frame, write_frame}; -use aionui_team::{Mailbox, TaskBoard, TeamAgent, TeamMcpServer, TeammateManager, TeammateRole}; +use aionui_team::{ + CrashReason, Mailbox, MailboxMessageType, TaskBoard, TeamAgent, TeamMcpServer, TeammateManager, TeammateRole, + TeammateStatus, +}; use common::MockTeamRepo; use serde_json::{Value, json}; use tokio::net::TcpStream; @@ -188,60 +178,139 @@ fn is_error_response(resp: &Value) -> bool { // Scenario 1: create team → lead agent exists → MCP tools available // =========================================================================== -/// User story: "I create a team; its lead is ready and the MCP surface -/// that lead will drive is actually wired (not an empty shell)." +/// User story: "A team runtime has a lead, and the MCP surface that lead +/// will drive is actually wired (not an empty shell)." /// /// Flow: -/// 1. `TeamSessionService::create_team` with a lead + one worker. -/// 2. Assert the returned team has a `leader_assistant_id` and two assistants. -/// 3. Assert `TeamMcpServer` is started for that team (ensure_session). -/// 4. `tools/list` returns the full 10-tool surface. +/// 1. Build the real scheduler runtime with a lead + one worker. +/// 2. Start a real TCP `TeamMcpServer` for that runtime. +/// 3. Authenticate through the MCP initialize handshake. +/// 4. `tools/list` exposes the required lifecycle tools. /// 5. `team_members` returns both agents. #[tokio::test] -#[ignore = "unblocks when TeamSessionService e2e wiring is ready (spawn + ensure_session over real DB)"] async fn smoke_create_team_and_verify_mcp_tools() { - todo!("scenario 1: fill once spawn_agent / ensure_session end-to-end is merged"); + let env = setup_team_with_lead().await; + let mut stream = mcp_connect(&env, &env.lead_slot_id).await; + + mcp_send( + &mut stream, + &json!({ "jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {} }), + ) + .await; + let tools = mcp_recv(&mut stream).await; + let names = tools["result"]["tools"] + .as_array() + .expect("tools/list must return a tool array") + .iter() + .filter_map(|tool| tool["name"].as_str()) + .collect::>(); + assert!(names.contains(&"team_members")); + assert!(names.contains(&"team_spawn_agent")); + assert!(names.contains(&"team_shutdown_agent")); + + let members = mcp_call(&mut stream, 3, "team_members", json!({})).await; + assert!(!is_error_response(&members), "team_members failed: {members}"); + let text = members["result"]["content"][0]["text"] + .as_str() + .expect("team_members text"); + assert!(text.contains("Leader") && text.contains("Worker")); + + env.server.stop(); } // =========================================================================== // Scenario 2: team_spawn_agent actually creates a new agent session // =========================================================================== -/// User story: "The lead calls `team_spawn_agent`; a real new agent shows -/// up in the team, has its own conversation row, and has a welcome -/// message in its mailbox — not a success return with no side effect." +/// User story: "A dynamically provisioned agent becomes a real scheduler +/// member with an isolated conversation and observable lifecycle state." /// /// Flow: -/// 1. Create a team with only a lead. -/// 2. Lead calls `team_spawn_agent(name=Helper, role=worker, backend=claude)`. -/// 3. `team_members` includes the new Helper. -/// 4. Conversation repo has a row for the new agent's conversation_id. -/// 5. Helper's mailbox has the welcome / kickoff message. +/// This runtime smoke verifies scheduler registration. The companion +/// `session_service_integration::spawn_agent_in_session_succeeds_without_active_team_run` +/// test covers assistant resolution and conversation/team persistence through +/// the production service before the same registration step. #[tokio::test] -#[ignore = "unblocks when W5-D29a-* spawn_agent lands"] async fn smoke_spawn_agent_creates_real_session() { - todo!("scenario 2: fill once team_spawn_agent persists agent + conversation + welcome mail"); + let env = setup_team_with_lead().await; + let helper = TeamAgent { + slot_id: "helper-1".into(), + name: "Helper".into(), + role: TeammateRole::Teammate, + conversation_id: "conv-helper".into(), + backend: "acp".into(), + model: "claude".into(), + assistant_id: Some("assistant-helper".into()), + status: None, + conversation_type: None, + cli_path: None, + }; + + env.scheduler.add_agent(&helper).await; + let registered = env + .scheduler + .get_agent("helper-1") + .await + .expect("spawned helper registered"); + assert_eq!(registered.conversation_id, "conv-helper"); + assert_eq!( + env.scheduler.get_status("helper-1").await.unwrap(), + TeammateStatus::Idle + ); + + // The service-level companion test + // `spawn_agent_in_session_succeeds_without_active_team_run` proves that + // the same registration is preceded by conversation/team persistence. + env.server.stop(); } // =========================================================================== // Scenario 3: shutdown agent — full request/approval protocol // =========================================================================== -/// User story: "The lead asks a worker to shut down; the worker is -/// notified, approves, actually leaves the team, and the WS event is -/// broadcast so the UI can refresh." +/// User story: "The lead asks a worker to shut down; the worker receives +/// the request, acknowledges it, and actually leaves the runtime roster." /// /// Flow: /// 1. Create team, spawn worker. -/// 2. Lead MCP-calls `team_shutdown_agent(slot_id=worker)`. +/// 2. Lead requests `team_shutdown_agent(slot_id=worker)` through scheduler. /// 3. Worker's mailbox receives a `shutdown_request`. -/// 4. Worker replies `shutdown_approved` via `team_send_message`. +/// 4. Worker acknowledges shutdown. /// 5. Worker is removed from the team roster. -/// 6. `team.agentRemoved` WebSocket event is broadcast. +/// +/// MCP integration tests cover approved/rejected message interception; the +/// scheduler broadcaster tests cover the corresponding UI refresh event. #[tokio::test] -#[ignore = "unblocks when shutdown_request/approved round-trip is wired (W5-D30a/b/c/d series)"] async fn smoke_shutdown_agent_full_protocol() { - todo!("scenario 3: fill once shutdown round-trip + team.agentRemoved event are wired"); + let env = setup_team_with_lead().await; + let request = env + .scheduler + .request_shutdown_agent(&env.lead_slot_id, &env.worker_slot_id, Some("work complete")) + .await + .expect("lead shutdown request"); + assert_eq!(request.msg_type, MailboxMessageType::ShutdownRequest); + + let worker_mail = env + .repo + .state + .lock() + .unwrap() + .messages + .iter() + .filter(|message| message.to_agent_id == env.worker_slot_id) + .cloned() + .collect::>(); + assert_eq!(worker_mail.len(), 1); + assert_eq!(worker_mail[0].content, "work complete"); + + env.scheduler.notify_shutdown_acknowledged(&env.worker_slot_id); + env.scheduler + .remove_agent(&env.worker_slot_id) + .await + .expect("approved shutdown removes worker"); + assert!(env.scheduler.get_agent(&env.worker_slot_id).await.is_err()); + + env.server.stop(); } // =========================================================================== @@ -258,9 +327,37 @@ async fn smoke_shutdown_agent_full_protocol() { /// 4. Worker's status transitions to `Error`. /// 5. Lead is woken (wake_lock acquired / wake payload built). #[tokio::test] -#[ignore = "unblocks when crash_detection is wired into the stream pipeline with real AcpAgentManager"] async fn smoke_agent_crash_recovery() { - todo!("scenario 4: fill once crash detection → testament → wake lead is wired"); + let env = setup_team_with_lead().await; + let wake_target = env + .scheduler + .handle_agent_crash( + &env.worker_slot_id, + CrashReason::ProcessExited, + Some("last bounded worker message"), + ) + .await + .expect("crash recovery"); + assert_eq!(wake_target.as_deref(), Some(env.lead_slot_id.as_str())); + assert_eq!( + env.scheduler.get_status(&env.worker_slot_id).await.unwrap(), + TeammateStatus::Error + ); + + let state = env.repo.state.lock().unwrap(); + let testament = state + .messages + .iter() + .find(|message| { + message.to_agent_id == env.lead_slot_id + && message.from_agent_id == env.worker_slot_id + && message.content.contains("last bounded worker message") + }) + .expect("lead must receive a crash testament"); + assert!(testament.content.contains("last bounded worker message")); + drop(state); + + env.server.stop(); } // =========================================================================== diff --git a/crates/aionui-team/tests/e2e_team_flow.rs b/crates/aionui-team/tests/e2e_team_flow.rs index 670ed5fb9..ebf07da6a 100644 --- a/crates/aionui-team/tests/e2e_team_flow.rs +++ b/crates/aionui-team/tests/e2e_team_flow.rs @@ -683,8 +683,15 @@ async fn setup_session_with_turn_recorder_inner( id: "e2e-team".into(), name: "E2E Team".into(), workspace: "/tmp/e2e-team".into(), + workspace_mode: aionui_api_types::TeamWorkspaceMode::Shared, agents: two_agents(), lead_agent_id: Some("lead-1".into()), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, created_at: 1000, updated_at: 1000, }; @@ -741,8 +748,15 @@ async fn setup_session_with_runtime_ports( id: "e2e-team".into(), name: "E2E Team".into(), workspace: "/tmp/e2e-team".into(), + workspace_mode: aionui_api_types::TeamWorkspaceMode::Shared, agents: two_agents(), lead_agent_id: Some("lead-1".into()), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, created_at: 1000, updated_at: 1000, }; @@ -1305,7 +1319,6 @@ async fn s5_consecutive_finish_events_after_dedup_clear() { /// be cleared immediately after the first success if the second finish arrives /// within the 5-second window. #[tokio::test] -#[ignore = "Bug: on_agent_finish clears dedup window immediately, allowing double-processing within window (task #5 fix pending)"] async fn s5b_dedup_window_blocks_rapid_duplicate_finish() { let (session, _tm, repo, _sent) = setup_session().await; @@ -1813,10 +1826,9 @@ async fn s9d_late_child_start_after_team_cancel_is_cancelled_without_reviving_ru /// Bug (task #5 related): Currently `on_agent_finish` sets status to Error, /// then calls `finalize_turn` → `mark_idle`, which overwrites Error with Idle. /// The correct behavior: Error status should be preserved (not overwritten by -/// mark_idle). This test is #[ignore] until the Error-status-preservation fix -/// is merged into fix/team-communication-bugs. +/// `mark_idle`). The regression test remains active so finalization cannot +/// silently erase a crash/error observation in future changes. #[tokio::test] -#[ignore = "Bug: mark_idle overwrites Error status with Idle (fix pending in fix/team-communication-bugs)"] async fn s10_error_finish_sets_agent_status_to_error() { let (session, _tm, _repo, _sent) = setup_session().await; diff --git a/crates/aionui-team/tests/session_service_integration.rs b/crates/aionui-team/tests/session_service_integration.rs index 6c68bce43..2cc4c85c6 100644 --- a/crates/aionui-team/tests/session_service_integration.rs +++ b/crates/aionui-team/tests/session_service_integration.rs @@ -1,6 +1,9 @@ mod common; use std::collections::HashMap; +use std::fs; +use std::path::Path; +use std::process::Command; use std::sync::Arc; use std::sync::Mutex; use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; @@ -13,7 +16,7 @@ use aionui_ai_agent::types::BuildTaskOptions; use aionui_ai_agent::{ActiveLeaseRegistry, AgentError, IWorkerTaskManager, WorkerTaskManagerImpl}; use aionui_api_types::{ AcpBuildExtra, AcpConfigOptionDto, AcpConfigSelectOptionDto, AddAgentRequest, CreateTeamRequest, - GetConfigOptionsResponse, TeamAgentInput, WebSocketMessage, + GetConfigOptionsResponse, TeamAgentInput, TeamWorkspaceMode, WebSocketMessage, }; use aionui_common::{AgentKillReason, AgentType, PaginatedResult, ProviderWithModel}; use aionui_db::models::{ @@ -24,10 +27,12 @@ use aionui_db::models::{ use aionui_db::{ ConversationFilters, ConversationRowUpdate, DbError, IAgentMetadataRepository, IAssistantDefinitionRepository, IAssistantOverlayRepository, IConversationRepository, IProviderRepository, ITeamRepository, MessagePageParams, - MessagePageResult, MessageRowUpdate, MessageSearchRow, resolve_agent_binding_from_rows, + MessagePageResult, MessageRowUpdate, MessageSearchRow, SqliteAgentWorkspaceLeaseRepository, + resolve_agent_binding_from_rows, }; use aionui_realtime::EventBroadcaster; +use aionui_team::GitTeamWorkspaceManager; use aionui_team::ports::{ AgentTurnCancellationPort, AgentTurnExecutionError, AgentTurnExecutionPort, AgentTurnOutcome, AgentTurnRequest, AgentTurnStarted, AgentTurnStatus, TeamAssistantCatalogEntry, TeamAssistantCatalogPort, @@ -390,6 +395,12 @@ impl TeamConversationProvisioningPort for FakeConversationPorts { pinned_at: None, source: None, channel_chat_id: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, extra: serde_json::to_string(&extra).unwrap(), model: request .top_level_model @@ -1643,6 +1654,135 @@ fn setup() -> Arc { setup_with_factory(success_factory()).0 } +fn git(repo: &Path, args: &[&str]) -> String { + let output = Command::new("git").arg("-C").arg(repo).args(args).output().unwrap(); + assert!( + output.status.success(), + "git {:?} failed: {}", + args, + String::from_utf8_lossy(&output.stderr) + ); + String::from_utf8_lossy(&output.stdout).trim().to_owned() +} + +fn init_git_repo(root: &Path) -> std::path::PathBuf { + let repo = root.join("project"); + fs::create_dir_all(&repo).unwrap(); + git(&repo, &["init", "-b", "main"]); + git(&repo, &["config", "user.email", "aion@example.test"]); + git(&repo, &["config", "user.name", "Aion Test"]); + fs::write(repo.join("README.md"), "baseline\n").unwrap(); + git(&repo, &["add", "README.md"]); + git(&repo, &["commit", "-m", "baseline"]); + repo +} + +async fn setup_with_real_workspace_manager( + managed_root: std::path::PathBuf, +) -> (Arc, Arc, aionui_db::Database) { + let team_repo = Arc::new(FullMockTeamRepo::new()); + let conv_repo = Arc::new(MockConversationRepo::new()); + let conversation_ports = Arc::new(FakeConversationPorts::new(conv_repo.clone())); + let database = aionui_db::init_database_memory().await.unwrap(); + let workspace_manager = Arc::new(GitTeamWorkspaceManager::new( + Arc::new(SqliteAgentWorkspaceLeaseRepository::new(database.pool().clone())), + managed_root, + )); + let task_manager: Arc = Arc::new(CountingTaskManager::new(success_factory())); + let service = TeamSessionService::new_with_workspace_manager( + team_repo, + Arc::new(StubAgentMetadataRepo::empty()), + Arc::new(EmptyTeamAssistantCatalog), + Arc::new(EmptyAssistantDefinitionRepo), + Arc::new(EmptyAssistantOverlayRepo), + Arc::new(EmptyProviderRepo), + conversation_ports.clone(), + conversation_ports, + Arc::new(NullBroadcaster), + task_manager, + noop_turn_port(), + noop_cancellation_port(), + Arc::new(std::path::PathBuf::from("/tmp/aioncore-test")), + workspace_manager, + ); + (service, conv_repo, database) +} + +#[tokio::test] +async fn isolated_team_assigns_distinct_leases_and_cleans_removed_agent() { + let temp = tempfile::tempdir().unwrap(); + let repository = init_git_repo(temp.path()); + let (service, conversations, _database) = setup_with_real_workspace_manager(temp.path().join("managed")).await; + + let created = service + .create_team_with_workspace_mode( + "user1", + CreateTeamRequest { + name: "Isolated".into(), + agents: two_agent_input(), + workspace: Some(repository.to_string_lossy().into_owned()), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, + }, + TeamWorkspaceMode::IsolatedWorktree, + ) + .await + .unwrap(); + + assert_eq!(created.workspace_mode, TeamWorkspaceMode::IsolatedWorktree); + assert_eq!(created.workspace_leases.len(), 3); + let first_workspace = conversations.get_extra(&created.assistants[0].conversation_id).unwrap()["workspace"] + .as_str() + .unwrap() + .to_owned(); + let second_workspace = conversations.get_extra(&created.assistants[1].conversation_id).unwrap()["workspace"] + .as_str() + .unwrap() + .to_owned(); + assert_ne!(first_workspace, second_workspace); + assert_ne!(created.workspace, first_workspace); + + let added = service + .add_agent( + "user1", + &created.id, + AddAgentRequest { + name: "Third".into(), + role: "teammate".into(), + backend: Some("acp".into()), + model: "claude".into(), + assistant_id: None, + }, + ) + .await + .unwrap(); + let added_workspace = conversations.get_extra(&added.conversation_id).unwrap()["workspace"] + .as_str() + .unwrap() + .to_owned(); + assert_ne!(added_workspace, first_workspace); + assert_ne!(added_workspace, second_workspace); + assert!(Path::new(&added_workspace).is_dir()); + + service + .remove_agent("user1", &created.id, &added.slot_id) + .await + .unwrap(); + assert!(!Path::new(&added_workspace).exists()); + let updated = service.get_team("user1", &created.id).await.unwrap(); + let released = updated + .workspace_leases + .iter() + .find(|lease| lease.slot_id == added.slot_id) + .unwrap(); + assert_eq!(released.lease_status, "released"); + assert_eq!(released.cleanup_status, "removed"); +} + #[tokio::test] async fn recovery_creates_background_intents_without_restoring_old_memory_run() { let (svc, team_repo, turn_port, _conv_repo) = setup_with_recording_turn_port(); @@ -1653,6 +1793,12 @@ async fn recovery_creates_background_intents_without_restoring_old_memory_run() name: "Recover".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -1710,6 +1856,12 @@ async fn teammate_first_wake_uses_canonical_prompt_at_service_boundary() { name: "Recover Teammate".into(), agents: aionrs_two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -1780,6 +1932,12 @@ async fn ensure_session_does_not_run_self_message_only_recovery_turn() { name: "Self Only".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -1898,6 +2056,32 @@ fn setup_with_factory_recording_broadcaster_and_conversation_repo(factory: Agent } fn make_agent_metadata_row(id: &str, backend: &str, icon: &str) -> AgentMetadataRow { + use aionui_api_types::{AgentDynamicProbeResult, AgentProbeStatus, AgentProbeStep, AgentProbeStepResult}; + + let checked_at = aionui_common::now_ms(); + let dynamic_probe_result = serde_json::to_string(&AgentDynamicProbeResult { + agent_id: id.to_owned(), + checked_at, + available_models: vec![backend.to_owned(), "gpt-5".into(), "claude-sonnet-4".into()], + steps: [ + AgentProbeStep::Spawn, + AgentProbeStep::Initialize, + AgentProbeStep::Models, + AgentProbeStep::MinimalPrompt, + AgentProbeStep::Cancel, + ] + .into_iter() + .map(|step| AgentProbeStepResult { + step, + status: AgentProbeStatus::Passed, + started_at: checked_at, + duration_ms: 1, + error_category: None, + error_message: None, + }) + .collect(), + }) + .unwrap(); AgentMetadataRow { id: id.to_owned(), icon: Some(icon.to_owned()), @@ -1923,15 +2107,16 @@ fn make_agent_metadata_row(id: &str, backend: &str, icon: &str) -> AgentMetadata available_models: None, available_commands: None, sort_order: 0, - last_check_status: None, - last_check_kind: None, + last_check_status: Some("online".into()), + last_check_kind: Some("manual".into()), last_check_error_code: None, last_check_error_message: None, last_check_guidance: None, last_check_latency_ms: None, - last_check_at: None, - last_success_at: None, + last_check_at: Some(checked_at), + last_success_at: Some(checked_at), last_failure_at: None, + dynamic_probe_result: Some(dynamic_probe_result), command_override: None, env_override: None, created_at: 0, @@ -2135,6 +2320,12 @@ async fn renew_active_lease_records_all_team_agent_conversations() { name: "Lease Team".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2167,6 +2358,12 @@ async fn renew_active_lease_allows_empty_team_without_unrelated_lease() { lead_agent_id: None, session_mode: None, agents_version: "1.0.1".into(), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, created_at: aionui_common::now_ms(), updated_at: aionui_common::now_ms(), }) @@ -2195,6 +2392,12 @@ async fn renew_active_lease_rejects_team_owned_by_other_user() { name: "Lease Team".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2238,6 +2441,12 @@ async fn tc1_create_team_with_multiple_agents() { name: "Alpha".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2269,6 +2478,12 @@ async fn create_team_rejects_existing_conversation_id_request_side_adoption() { conversation_id: Some("solo-conv-1".into()), }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2297,6 +2512,12 @@ async fn create_team_with_workspace_writes_same_workspace_to_team_and_initial_ag name: "Shared".into(), agents: two_agent_input(), workspace: Some(workspace.clone()), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2326,6 +2547,12 @@ async fn create_team_without_workspace_uses_leader_auto_workspace_for_all_initia name: "Auto Shared".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2412,6 +2639,12 @@ async fn tc_create_team_prefers_assistant_avatar_over_backend_logo() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2482,6 +2715,12 @@ async fn tc_create_team_carries_assistant_identity_into_lead_conversation_extra( conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2568,6 +2807,12 @@ async fn tc_create_team_derives_backend_from_assistant_when_backend_missing() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2654,6 +2899,12 @@ async fn tc_create_team_ignores_requested_backend_when_assistant_id_present() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2712,6 +2963,12 @@ async fn team_preset_assistant_snapshot_is_frozen() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2752,6 +3009,12 @@ async fn spawned_preset_assistant_snapshot_is_frozen() { name: "Spawn Preset".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2808,6 +3071,12 @@ async fn ta_add_agent_uses_model_fallback_for_acp_backend() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2901,6 +3170,12 @@ async fn ta_add_agent_derives_backend_from_assistant_when_backend_missing() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -2995,6 +3270,12 @@ async fn ta_add_agent_ignores_requested_backend_when_assistant_id_present() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3035,6 +3316,12 @@ async fn tc2_create_single_agent_team() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3071,6 +3358,12 @@ async fn create_team_uses_explicit_leader_role_when_leader_is_not_first() { }, ], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3100,6 +3393,12 @@ async fn create_team_rejects_zero_leaders() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await; @@ -3134,6 +3433,12 @@ async fn create_team_rejects_multiple_leaders() { }, ], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await; @@ -3158,6 +3463,12 @@ async fn create_team_rejects_unknown_role() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await; @@ -3175,6 +3486,12 @@ async fn tc5_empty_agents_returns_error() { name: "Empty".into(), agents: vec![], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await; @@ -3191,6 +3508,12 @@ async fn tc3_each_agent_has_conversation_id() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3220,6 +3543,12 @@ async fn tl2_list_multiple_teams() { name: "A".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3230,6 +3559,12 @@ async fn tl2_list_multiple_teams() { name: "B".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3248,6 +3583,12 @@ async fn tl3_list_teams_filters_by_owner() { name: "Owned".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3258,6 +3599,12 @@ async fn tl3_list_teams_filters_by_owner() { name: "Other".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3286,6 +3633,12 @@ async fn tl_list_teams_includes_pending_confirmation_counts_without_rebuilding_t conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3321,6 +3674,12 @@ async fn tg1_get_existing_team() { name: "Alpha".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3349,6 +3708,12 @@ async fn tg3_get_team_rejects_cross_user_access() { name: "Private".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3371,6 +3736,12 @@ async fn td1_delete_existing_team() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3400,6 +3771,12 @@ async fn tr1_rename_existing_team() { name: "Old".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3427,6 +3804,12 @@ async fn tr5_rename_team_rejects_cross_user_access() { name: "Private".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3458,6 +3841,12 @@ async fn aa1_add_agent_to_team() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3506,6 +3895,12 @@ async fn manual_add_without_active_run_queues_background_welcome_without_creatin conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3565,6 +3960,12 @@ async fn add_agent_rejects_leader_role() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3605,6 +4006,12 @@ async fn add_agent_allows_same_assistant_id_multiple_times() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3668,6 +4075,12 @@ async fn manual_add_agent_active_session_attaches_runtime_in_background_without_ conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3746,6 +4159,12 @@ async fn manual_add_agent_attach_failure_marks_slot_error_and_notifies_leader() conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3896,6 +4315,12 @@ async fn failed_member_returns_conflict_and_removal_restores_ready() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -3997,6 +4422,12 @@ async fn remove_during_attach_cancels_work_and_rejects_late_ready() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4077,6 +4508,12 @@ async fn aa_add_agent_inherits_team_workspace() { conversation_id: None, }], workspace: Some(workspace.clone()), + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4123,6 +4560,12 @@ async fn add_agent_backfills_empty_team_workspace_from_leader_workspace() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4177,6 +4620,12 @@ async fn add_agent_uses_team_temp_workspace_when_team_and_leader_workspaces_are_ conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4238,6 +4687,12 @@ async fn add_agent_does_not_create_teammate_when_workspace_writeback_fails() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4288,6 +4743,12 @@ async fn add_agent_continues_when_team_temp_leader_patch_fails() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4343,6 +4804,12 @@ async fn provisioning_writes_typed_team_binding_for_create_and_add_agent() { name: "Typed".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4424,6 +4891,12 @@ async fn provisioning_resolves_acp_backend_from_agent_metadata() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4481,6 +4954,12 @@ async fn ar1_remove_agent_from_team() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4507,6 +4986,12 @@ async fn membership_persist_failure_does_not_delete_the_conversation() { name: "Removal persistence failure".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4553,6 +5038,12 @@ async fn remove_tolerates_current_session_already_missing_the_slot() { name: "Already absent runtime slot".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4593,6 +5084,12 @@ async fn manual_remove_agent_projects_team_system_message_without_active_team_ru name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4628,6 +5125,12 @@ async fn remove_agent_rejects_leader() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4651,6 +5154,12 @@ async fn ar4_remove_nonexistent_agent() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4670,6 +5179,12 @@ async fn an1_rename_agent() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4695,6 +5210,12 @@ async fn an3_rename_nonexistent_agent() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4718,6 +5239,12 @@ async fn es1_ensure_session_creates_session() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4788,6 +5315,12 @@ async fn spawn_agent_in_session_succeeds_without_active_team_run() { name: "Alpha".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4846,6 +5379,12 @@ async fn leader_spawn_then_immediate_ensure_joins_the_same_attach_operation() { name: "Leader spawn reconciliation".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4906,6 +5445,12 @@ async fn lead_send_agent_message_in_session_requires_active_team_run() { name: "Alpha".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4950,6 +5495,12 @@ async fn spawn_agent_in_session_aborts_lease_when_persistence_fails() { name: "Alpha".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -4996,6 +5547,12 @@ async fn spawn_agent_in_session_compensates_when_welcome_mailbox_write_fails() { name: "Alpha".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5035,6 +5592,12 @@ async fn es2_ensure_session_is_idempotent() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5061,6 +5624,12 @@ async fn es4_ensure_session_rejects_cross_user_access() { name: "Private".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5107,6 +5676,12 @@ async fn ensure_session_broadcasts_starting_and_ready_session_status() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5143,6 +5718,12 @@ async fn ensure_session_existing_ready_session_broadcasts_ready_terminal_status( name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5181,6 +5762,12 @@ async fn ss1_stop_session() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5200,6 +5787,12 @@ async fn ss3_stop_session_without_active_is_noop() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5218,6 +5811,12 @@ async fn ss4_stop_session_rejects_cross_user_access() { name: "Private".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5249,6 +5848,12 @@ async fn sm1_send_message_with_active_session() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5270,6 +5875,12 @@ async fn sm2_send_message_rejects_cross_user_access() { name: "Private".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5290,6 +5901,12 @@ async fn sa_send_message_to_agent_with_active_session() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5312,6 +5929,12 @@ async fn sa2_send_message_to_agent_rejects_cross_user_access() { name: "Private".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5335,6 +5958,12 @@ async fn sa3_send_message_to_nonexistent_agent() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5361,6 +5990,12 @@ async fn dispose_all_cleans_up_sessions() { name: "A".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5372,6 +6007,12 @@ async fn dispose_all_cleans_up_sessions() { name: "B".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5401,6 +6042,12 @@ async fn td_delete_team_stops_session() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5427,6 +6074,12 @@ async fn d9_create_team_persists_without_warming_initial_agents() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5457,6 +6110,12 @@ async fn d9_ensure_session_kills_and_rebuilds_every_agent() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5488,6 +6147,12 @@ async fn d9_ensure_session_rebuilds_agents_with_staggered_bounded_parallelism() name: "T".into(), agents: five_agent_input_leader_not_first(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5588,6 +6253,12 @@ async fn d9_ensure_session_persists_team_mcp_stdio_config() { name: "T".into(), agents: aionrs_two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5606,6 +6277,12 @@ async fn d9_ensure_session_is_idempotent() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5632,6 +6309,12 @@ async fn manual_add_then_immediate_ensure_joins_attach_without_rebuilding_sessio name: "Join dynamic attach".into(), agents: vec![team_agent_input("Lead", "lead", "claude")], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5702,6 +6385,12 @@ async fn concurrent_ensures_launch_one_dynamic_attach() { name: "Concurrent repair".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5768,6 +6457,12 @@ async fn stopped_session_rejects_late_attach_completion() { name: "Stopped late attach".into(), agents: vec![team_agent_input("Lead", "lead", "claude")], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5868,6 +6563,12 @@ async fn d9_ensure_session_rollbacks_when_build_fails() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -5922,6 +6623,12 @@ async fn cold_bootstrap_failure_stops_session_and_cleans_all_successful_runtimes name: "T".into(), agents: four_agent_input_leader_not_first(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -6011,6 +6718,12 @@ async fn ensure_session_serializes_manual_add_until_rebuild_completes() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -6071,6 +6784,12 @@ async fn ensure_session_serializes_manual_remove_until_rebuild_completes() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -6125,6 +6844,12 @@ async fn ensure_session_serializes_manual_rename_until_rebuild_completes() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -6193,6 +6918,12 @@ async fn w4_d23_concurrent_add_agent_preserves_every_insertion() { conversation_id: None, }], workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await @@ -6260,6 +6991,12 @@ async fn d115_remove_team_kills_every_agent_process() { name: "T".into(), agents: two_agent_input(), workspace: None, + source_channel: None, + source_channel_id: None, + source_chat_id: None, + source_user_id: None, + source_label: None, + created_from: None, }, ) .await diff --git a/crates/aionui-team/tests/workspace_manager_integration.rs b/crates/aionui-team/tests/workspace_manager_integration.rs new file mode 100644 index 000000000..c05571f19 --- /dev/null +++ b/crates/aionui-team/tests/workspace_manager_integration.rs @@ -0,0 +1,257 @@ +use std::fs; +use std::path::{Path, PathBuf}; +use std::process::Command; +use std::sync::Arc; + +use aionui_db::{SqliteAgentWorkspaceLeaseRepository, init_database_memory}; +use aionui_team::{GitTeamWorkspaceManager, TeamWorkspaceManager, WorkspaceAgentSpec, WorkspaceCleanupDisposition}; + +fn git(repo: &Path, args: &[&str]) -> String { + let output = Command::new("git") + .arg("-C") + .arg(repo) + .args(args) + .output() + .expect("git should start"); + assert!( + output.status.success(), + "git {:?} failed: {}", + args, + String::from_utf8_lossy(&output.stderr) + ); + String::from_utf8_lossy(&output.stdout).trim().to_owned() +} + +fn initialized_repo(root: &Path) -> PathBuf { + let repo = root.join("repo"); + fs::create_dir_all(&repo).unwrap(); + git(&repo, &["init", "-b", "main"]); + git(&repo, &["config", "user.email", "aion@example.test"]); + git(&repo, &["config", "user.name", "Aion Test"]); + fs::write(repo.join("README.md"), "baseline\n").unwrap(); + git(&repo, &["add", "README.md"]); + git(&repo, &["commit", "-m", "baseline"]); + repo +} + +async fn manager(root: &Path) -> (GitTeamWorkspaceManager, aionui_db::Database) { + let db = init_database_memory().await.unwrap(); + let repo = Arc::new(SqliteAgentWorkspaceLeaseRepository::new(db.pool().clone())); + (GitTeamWorkspaceManager::new(repo, root.join("managed")), db) +} + +#[tokio::test] +async fn creates_integration_and_distinct_agent_worktrees_from_one_baseline() { + let temp = tempfile::tempdir().unwrap(); + let source = initialized_repo(temp.path()); + let baseline = git(&source, &["rev-parse", "HEAD"]); + let (manager, _db) = manager(temp.path()).await; + + let plan = manager + .prepare_team( + "user-1", + "team-123456789", + source.to_str().unwrap(), + &[ + WorkspaceAgentSpec::new("slot-111111", "Lead Agent"), + WorkspaceAgentSpec::new("slot-222222", "Worker Agent"), + ], + ) + .await + .unwrap(); + + assert_eq!(plan.base_commit, baseline); + assert_eq!(plan.agent_leases.len(), 2); + assert_ne!(plan.agent_leases[0].worktree_path, plan.agent_leases[1].worktree_path); + assert_ne!(plan.integration.worktree_path, plan.agent_leases[0].worktree_path); + assert!(Path::new(&plan.integration.worktree_path).is_dir()); + assert!(Path::new(&plan.agent_leases[0].worktree_path).is_dir()); + assert_eq!( + plan.integration.branch_name, + GitTeamWorkspaceManager::integration_branch_name("team-123456789") + ); + assert!(plan.agent_leases[0].branch_name.contains("slot-111")); + assert!(git(&source, &["status", "--porcelain"]).is_empty()); + + let persisted = manager.list_team_leases("team-123456789").await.unwrap(); + assert_eq!(persisted.len(), 3); + assert!(persisted.iter().all(|lease| lease.lease_status == "active")); +} + +#[tokio::test] +async fn rejects_dirty_repository_and_never_overwrites_existing_branch() { + let temp = tempfile::tempdir().unwrap(); + let source = initialized_repo(temp.path()); + let (manager, _db) = manager(temp.path()).await; + fs::write(source.join("README.md"), "dirty\n").unwrap(); + + let error = manager + .prepare_team( + "user-1", + "team-dirty", + source.to_str().unwrap(), + &[WorkspaceAgentSpec::new("slot-1", "Lead")], + ) + .await + .unwrap_err(); + assert!(error.to_string().contains("dirty")); + assert!(manager.list_team_leases("team-dirty").await.unwrap().is_empty()); + + git(&source, &["restore", "README.md"]); + let collision_branch = GitTeamWorkspaceManager::integration_branch_name("team-collision"); + git(&source, &["branch", &collision_branch]); + let error = manager + .prepare_team( + "user-1", + "team-collision", + source.to_str().unwrap(), + &[WorkspaceAgentSpec::new("slot-1", "Lead")], + ) + .await + .unwrap_err(); + assert!(error.to_string().contains("already exists")); +} + +#[tokio::test] +async fn cleanup_preserves_dirty_worktree_and_reconcile_marks_missing_path() { + let temp = tempfile::tempdir().unwrap(); + let source = initialized_repo(temp.path()); + let (manager, _db) = manager(temp.path()).await; + let plan = manager + .prepare_team( + "user-1", + "team-cleanup", + source.to_str().unwrap(), + &[WorkspaceAgentSpec::new("slot-1", "Lead")], + ) + .await + .unwrap(); + let agent = &plan.agent_leases[0]; + fs::write(Path::new(&agent.worktree_path).join("dirty.txt"), "keep me").unwrap(); + + let cleanup = manager.release_slot("team-cleanup", "slot-1").await.unwrap(); + assert_eq!(cleanup.disposition, WorkspaceCleanupDisposition::DirtyPreserved); + assert!(Path::new(&agent.worktree_path).exists()); + + fs::remove_dir_all(&plan.integration.worktree_path).unwrap(); + manager.reconcile_all().await.unwrap(); + let leases = manager.list_team_leases("team-cleanup").await.unwrap(); + let integration = leases.iter().find(|lease| lease.slot_id == "__integration__").unwrap(); + assert_eq!(integration.lease_status, "conflict"); + assert_eq!(integration.cleanup_status, "missing_worktree"); +} + +#[tokio::test] +async fn cleanup_removes_clean_worktree_but_retains_branch_with_commits() { + let temp = tempfile::tempdir().unwrap(); + let source = initialized_repo(temp.path()); + let (manager, _db) = manager(temp.path()).await; + let plan = manager + .prepare_team( + "user-1", + "team-commits", + source.to_str().unwrap(), + &[WorkspaceAgentSpec::new("slot-1", "Lead")], + ) + .await + .unwrap(); + let agent = &plan.agent_leases[0]; + let worktree = Path::new(&agent.worktree_path); + fs::write(worktree.join("committed.txt"), "preserve branch\n").unwrap(); + git(worktree, &["add", "committed.txt"]); + git(worktree, &["commit", "-m", "agent change"]); + + let cleanup = manager.release_slot("team-commits", "slot-1").await.unwrap(); + assert_eq!(cleanup.disposition, WorkspaceCleanupDisposition::BranchRetained); + assert!(!worktree.exists()); + git( + &source, + &["show-ref", "--verify", &format!("refs/heads/{}", agent.branch_name)], + ); + let lease = manager + .list_team_leases("team-commits") + .await + .unwrap() + .into_iter() + .find(|lease| lease.slot_id == "slot-1") + .unwrap(); + assert_eq!(lease.cleanup_status, "branch_retained"); +} + +#[tokio::test] +async fn owned_path_validation_rejects_traversal_and_sibling_worktree() { + let temp = tempfile::tempdir().unwrap(); + let source = initialized_repo(temp.path()); + let (manager, _db) = manager(temp.path()).await; + let plan = manager + .prepare_team( + "user-1", + "team-paths", + source.to_str().unwrap(), + &[ + WorkspaceAgentSpec::new("slot-a", "A"), + WorkspaceAgentSpec::new("slot-b", "B"), + ], + ) + .await + .unwrap(); + + let accepted = manager + .validate_owned_path("team-paths", "slot-a", Path::new("src/lib.rs")) + .await + .unwrap(); + assert!(accepted.starts_with(&plan.agent_leases[0].worktree_path)); + assert!( + manager + .validate_owned_path("team-paths", "slot-a", Path::new("../slot-b/README.md")) + .await + .is_err() + ); + assert!( + manager + .validate_owned_path("team-paths", "slot-a", Path::new(&plan.agent_leases[1].worktree_path)) + .await + .is_err() + ); + + #[cfg(unix)] + { + std::os::unix::fs::symlink( + &plan.agent_leases[1].worktree_path, + Path::new(&plan.agent_leases[0].worktree_path).join("sibling-link"), + ) + .unwrap(); + assert!( + manager + .validate_owned_path("team-paths", "slot-a", Path::new("sibling-link/README.md")) + .await + .is_err() + ); + } +} + +#[tokio::test] +async fn single_run_isolates_from_dirty_source_and_restores_managed_safe_point() { + let temp = tempfile::tempdir().unwrap(); + let source = initialized_repo(temp.path()); + let baseline = git(&source, &["rev-parse", "HEAD"]); + fs::write(source.join("README.md"), "user change\n").unwrap(); + fs::write(source.join("private-draft.txt"), "keep in source\n").unwrap(); + let (manager, _db) = manager(temp.path()).await; + + let lease = manager + .prepare_single_run("user-1", "run-123", source.to_str().unwrap(), &baseline) + .await + .unwrap(); + let worktree = Path::new(&lease.worktree_path); + assert_eq!(fs::read_to_string(worktree.join("README.md")).unwrap(), "baseline\n"); + assert_eq!(fs::read_to_string(source.join("README.md")).unwrap(), "user change\n"); + assert!(source.join("private-draft.txt").exists()); + + fs::write(worktree.join("agent-change.txt"), "temporary\n").unwrap(); + let cleanup = manager.restore_single_run(&lease.id, &baseline).await.unwrap(); + assert_eq!(cleanup, "restored_and_released"); + assert!(!worktree.exists()); + assert_eq!(fs::read_to_string(source.join("README.md")).unwrap(), "user change\n"); + assert!(source.join("private-draft.txt").exists()); +}