cleaning up

Author: michaelneale

crates/goose-cli/src/commands/gateway.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 pub async fn handle_gateway_status() -> Result<()> {
     let agent_manager = AgentManager::instance().await?;
-    let gateway_manager = Arc::new(GatewayManager::new(agent_manager));
+    let gateway_manager = Arc::new(GatewayManager::new(agent_manager)?);
     let statuses = gateway_manager.status().await;
 
     if statuses.is_empty() {
@@ -39,7 +39,7 @@ pub async fn handle_gateway_start(
     platform_config: serde_json::Value,
 ) -> Result<()> {
     let agent_manager = AgentManager::instance().await?;
-    let gateway_manager = Arc::new(GatewayManager::new(agent_manager));
+    let gateway_manager = Arc::new(GatewayManager::new(agent_manager)?);
 
     let mut config = goose::gateway::GatewayConfig {
         gateway_type,
@@ -60,15 +60,15 @@ pub async fn handle_gateway_start(
 
 pub async fn handle_gateway_stop(gateway_type: String) -> Result<()> {
     let agent_manager = AgentManager::instance().await?;
-    let gateway_manager = Arc::new(GatewayManager::new(agent_manager));
+    let gateway_manager = Arc::new(GatewayManager::new(agent_manager)?);
     gateway_manager.stop_gateway(&gateway_type).await?;
     println!("Gateway '{}' stopped.", gateway_type);
     Ok(())
 }
 
 pub async fn handle_gateway_pair(gateway_type: String) -> Result<()> {
     let agent_manager = AgentManager::instance().await?;
-    let gateway_manager = Arc::new(GatewayManager::new(agent_manager));
+    let gateway_manager = Arc::new(GatewayManager::new(agent_manager)?);
     let (code, expires_at) = gateway_manager.generate_pairing_code(&gateway_type).await?;
 
     let expires = chrono::DateTime::from_timestamp(expires_at, 0)

crates/goose-server/src/state.rs

@@ -51,7 +51,7 @@ impl AppState {
 
         let agent_manager = AgentManager::instance().await?;
         let tunnel_manager = Arc::new(TunnelManager::new());
-        let gateway_manager = Arc::new(GatewayManager::new(agent_manager.clone()));
+        let gateway_manager = Arc::new(GatewayManager::new(agent_manager.clone())?);
 
         Ok(Arc::new(Self {
             agent_manager,

crates/goose/src/gateway/manager.rs

@@ -61,15 +61,15 @@ pub struct GatewayManager {
 }
 
 impl GatewayManager {
-    pub fn new(agent_manager: Arc<AgentManager>) -> Self {
+    pub fn new(agent_manager: Arc<AgentManager>) -> anyhow::Result<Self> {
         let db_path = Paths::data_dir().join("gateway").join("pairings.db");
-        let pairing_store = Arc::new(PairingStore::new(&db_path));
+        let pairing_store = Arc::new(PairingStore::new(&db_path)?);
 
-        Self {
+        Ok(Self {
             gateways: RwLock::new(HashMap::new()),
             pairing_store,
             agent_manager,
-        }
+        })
     }
 
     #[allow(dead_code)]

crates/goose/src/gateway/mod.rs

@@ -12,13 +12,28 @@ use utoipa::ToSchema;
 
 use handler::GatewayHandler;
 
-#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PlatformUser {
     pub platform: String,
     pub user_id: String,
     pub display_name: Option<String>,
 }
 
+impl PartialEq for PlatformUser {
+    fn eq(&self, other: &Self) -> bool {
+        self.platform == other.platform && self.user_id == other.user_id
+    }
+}
+
+impl Eq for PlatformUser {}
+
+impl std::hash::Hash for PlatformUser {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.platform.hash(state);
+        self.user_id.hash(state);
+    }
+}
+
 #[derive(Debug, Clone)]
 #[allow(dead_code)]
 pub struct IncomingMessage {

crates/goose/src/gateway/pairing.rs

@@ -14,9 +14,9 @@ pub struct PairingStore {
 }
 
 impl PairingStore {
-    pub fn new(db_path: &Path) -> Self {
+    pub fn new(db_path: &Path) -> anyhow::Result<Self> {
         if let Some(parent) = db_path.parent() {
-            std::fs::create_dir_all(parent).expect("Failed to create pairing database directory");
+            std::fs::create_dir_all(parent)?;
         }
 
         let options = SqliteConnectOptions::new()
@@ -27,11 +27,11 @@ impl PairingStore {
 
         let pool = SqlitePoolOptions::new().connect_lazy_with(options);
 
-        Self {
+        Ok(Self {
             pairings: RwLock::new(HashMap::new()),
             pool,
             initialized: OnceCell::new(),
-        }
+        })
     }
 
     async fn ensure_initialized(&self) -> anyhow::Result<&Pool<Sqlite>> {
@@ -343,7 +343,7 @@ mod tests {
     #[tokio::test]
     async fn test_pairing_lifecycle() {
         let tmp = TempDir::new().unwrap();
-        let store = PairingStore::new(&tmp.path().join("test.db"));
+        let store = PairingStore::new(&tmp.path().join("test.db")).unwrap();
         let user = test_user("telegram", "12345");
 
         let state = store.get(&user).await.unwrap();
@@ -381,7 +381,7 @@ mod tests {
     #[tokio::test]
     async fn test_pending_code_flow() {
         let tmp = TempDir::new().unwrap();
-        let store = PairingStore::new(&tmp.path().join("test.db"));
+        let store = PairingStore::new(&tmp.path().join("test.db")).unwrap();
 
         let expires = chrono::Utc::now().timestamp() + 300;
         store
@@ -399,7 +399,7 @@ mod tests {
     #[tokio::test]
     async fn test_expired_code() {
         let tmp = TempDir::new().unwrap();
-        let store = PairingStore::new(&tmp.path().join("test.db"));
+        let store = PairingStore::new(&tmp.path().join("test.db")).unwrap();
 
         let expired = chrono::Utc::now().timestamp() - 10;
         store
@@ -427,7 +427,7 @@ mod tests {
         let user = test_user("discord", "user42");
 
         {
-            let store = PairingStore::new(&db_path);
+            let store = PairingStore::new(&db_path).unwrap();
             store
                 .set(
                     &user,
@@ -440,7 +440,7 @@ mod tests {
                 .unwrap();
         }
 
-        let store2 = PairingStore::new(&db_path);
+        let store2 = PairingStore::new(&db_path).unwrap();
         let state = store2.get(&user).await.unwrap();
         match state {
             PairingState::Paired { session_id, .. } => assert_eq!(session_id, "s-42"),
@@ -451,7 +451,7 @@ mod tests {
     #[tokio::test]
     async fn test_remove_all_for_platform() {
         let tmp = TempDir::new().unwrap();
-        let store = PairingStore::new(&tmp.path().join("test.db"));
+        let store = PairingStore::new(&tmp.path().join("test.db")).unwrap();
 
         let tg1 = test_user("telegram", "111");
         let tg2 = test_user("telegram", "222");

crates/goose/src/gateway/telegram_format.rs

@@ -76,12 +76,12 @@ fn collapse_newlines(text: &str) -> String {
     let mut chars = text.chars().peekable();
 
     while let Some(ch) = chars.next() {
-        if !in_pre && ch == '<' {
+        if ch == '<' {
             let rest: String = chars.clone().take(4).collect();
-            if rest.starts_with("pre>") || rest.starts_with("pre ") {
+            if !in_pre && (rest.starts_with("pre>") || rest.starts_with("pre ")) {
                 in_pre = true;
             }
-            if rest.starts_with("/pre") {
+            if in_pre && rest.starts_with("/pre") {
                 in_pre = false;
             }
             result.push(ch);
@@ -106,6 +106,7 @@ fn escape_html(text: &str) -> String {
     text.replace('&', "&amp;")
         .replace('<', "&lt;")
         .replace('>', "&gt;")
+        .replace('"', "&quot;")
 }
 
 #[cfg(test)]
@@ -231,7 +232,7 @@ That's all!"#;
         assert!(html.contains("1. "));
         assert!(html.contains("2. "));
         assert!(html.contains("<pre><code>"));
-        assert!(html.contains("print(\"hello\")"));
+        assert!(html.contains("print(&quot;hello&quot;)"));
         assert!(html.contains("<a href="));
         assert!(html.contains("<blockquote>"));
         assert!(html.contains("That's all!"));