86 lines
3.2 KiB
Rust
86 lines
3.2 KiB
Rust
use crate::agents::{AgentPool, ReconciliationEvent};
|
|
use crate::io::watcher::WatcherEvent;
|
|
use crate::state::SessionState;
|
|
use crate::store::JsonFileStore;
|
|
use crate::workflow::WorkflowState;
|
|
use poem::http::StatusCode;
|
|
use std::sync::Arc;
|
|
use tokio::sync::{broadcast, mpsc, oneshot};
|
|
|
|
/// A permission request forwarded from the MCP `prompt_permission` tool to the
|
|
/// active WebSocket session. The MCP handler blocks on `response_tx` until the
|
|
/// user approves or denies via the frontend dialog.
|
|
pub struct PermissionForward {
|
|
pub request_id: String,
|
|
pub tool_name: String,
|
|
pub tool_input: serde_json::Value,
|
|
pub response_tx: oneshot::Sender<bool>,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct AppContext {
|
|
pub state: Arc<SessionState>,
|
|
pub store: Arc<JsonFileStore>,
|
|
pub workflow: Arc<std::sync::Mutex<WorkflowState>>,
|
|
pub agents: Arc<AgentPool>,
|
|
/// Broadcast channel for filesystem watcher events. WebSocket handlers
|
|
/// subscribe to this to push lifecycle notifications to connected clients.
|
|
pub watcher_tx: broadcast::Sender<WatcherEvent>,
|
|
/// Broadcast channel for startup reconciliation progress events.
|
|
/// WebSocket handlers subscribe to this to push real-time reconciliation
|
|
/// updates to connected clients.
|
|
pub reconciliation_tx: broadcast::Sender<ReconciliationEvent>,
|
|
/// Sender for permission requests originating from the MCP
|
|
/// `prompt_permission` tool. The MCP handler sends a [`PermissionForward`]
|
|
/// and awaits the oneshot response.
|
|
pub perm_tx: mpsc::UnboundedSender<PermissionForward>,
|
|
/// Receiver for permission requests. The active WebSocket handler locks
|
|
/// this and polls for incoming permission forwards.
|
|
pub perm_rx: Arc<tokio::sync::Mutex<mpsc::UnboundedReceiver<PermissionForward>>>,
|
|
}
|
|
|
|
#[cfg(test)]
|
|
impl AppContext {
|
|
pub fn new_test(project_root: std::path::PathBuf) -> Self {
|
|
let state = SessionState::default();
|
|
*state.project_root.lock().unwrap() = Some(project_root.clone());
|
|
let store_path = project_root.join(".story_kit_store.json");
|
|
let (watcher_tx, _) = broadcast::channel(64);
|
|
let (reconciliation_tx, _) = broadcast::channel(64);
|
|
let (perm_tx, perm_rx) = mpsc::unbounded_channel();
|
|
Self {
|
|
state: Arc::new(state),
|
|
store: Arc::new(JsonFileStore::new(store_path).unwrap()),
|
|
workflow: Arc::new(std::sync::Mutex::new(WorkflowState::default())),
|
|
agents: Arc::new(AgentPool::new(3001, watcher_tx.clone())),
|
|
watcher_tx,
|
|
reconciliation_tx,
|
|
perm_tx,
|
|
perm_rx: Arc::new(tokio::sync::Mutex::new(perm_rx)),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type OpenApiResult<T> = poem::Result<T>;
|
|
|
|
pub fn bad_request(message: String) -> poem::Error {
|
|
poem::Error::from_string(message, StatusCode::BAD_REQUEST)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn bad_request_returns_400_status() {
|
|
let err = bad_request("something went wrong".to_string());
|
|
assert_eq!(err.status(), StatusCode::BAD_REQUEST);
|
|
}
|
|
|
|
#[test]
|
|
fn bad_request_accepts_empty_message() {
|
|
let err = bad_request(String::new());
|
|
assert_eq!(err.status(), StatusCode::BAD_REQUEST);
|
|
}
|
|
}
|