feat(dashboard): extract inline script to standalone dashboard.ts/js, add UI build/check recipes, and add route unit tests

server/src/handlers/notes.rs

@@ -91,130 +91,7 @@ impl McpTool for StickyNotesHandler {
     }
 }
 
-pub struct AddStickyNoteHandler;
 
-#[async_trait]
-impl McpTool for AddStickyNoteHandler {
-    fn name(&self) -> &'static str {
-        "add_sticky_note"
-    }
-
-    fn schema(&self) -> Value {
-        crate::mcp::tool_def::<AddStickyNoteTool>("add_sticky_note", "Execute add_sticky_note")
-    }
-
-    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let req: AddStickyNoteTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
-        let now = crate::handlers::utils::now_secs();
-        let expires_at = if let Some(ttl) = req.ttl_seconds {
-            Some(now + ttl)
-        } else if req.session_only.unwrap_or(false) {
-            Some(now + 14400) // Default 4-hour session TTL
-        } else {
-            None
-        };
-
-        state.code.sticky.modify(|notes| {
-            notes.push(StickyNote {
-                timestamp: now,
-                content: req.content,
-                expires_at,
-            });
-        });
-        Ok("Sticky note added.".to_string())
-    }
-}
-
-pub struct ReadStickyNotesHandler;
-
-#[async_trait]
-impl McpTool for ReadStickyNotesHandler {
-    fn name(&self) -> &'static str {
-        "read_sticky_notes"
-    }
-
-    fn schema(&self) -> Value {
-        crate::mcp::tool_def::<ReadStickyNotesTool>(
-            "read_sticky_notes",
-            "Execute read_sticky_notes",
-        )
-    }
-
-    async fn execute(&self, _args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let now = crate::handlers::utils::now_secs();
-        let mut active_notes = Vec::new();
-
-        state.code.sticky.modify(|notes| {
-            notes.retain(|n| {
-                if let Some(exp) = n.expires_at {
-                    exp > now
-                } else {
-                    true
-                }
-            });
-            active_notes = notes.clone();
-        });
-
-        Ok(serde_json::to_string(&active_notes)?)
-    }
-}
-
-pub struct DeleteStickyNoteHandler;
-
-#[async_trait]
-impl McpTool for DeleteStickyNoteHandler {
-    fn name(&self) -> &'static str {
-        "delete_sticky_note"
-    }
-
-    fn schema(&self) -> Value {
-        crate::mcp::tool_def::<DeleteStickyNoteTool>(
-            "delete_sticky_note",
-            "Execute delete_sticky_note",
-        )
-    }
-
-    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let req: DeleteStickyNoteTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
-        let mut success = false;
-        state.code.sticky.modify(|notes| {
-            if req.index > 0 && req.index <= notes.len() {
-                notes.remove(req.index - 1);
-                success = true;
-            }
-        });
-        if success {
-            Ok("Sticky note deleted.".to_string())
-        } else {
-            Err(crate::error::AppError::Internal(
-                "Invalid sticky note index.".to_string(),
-            ))
-        }
-    }
-}
-
-pub struct ClearStickyNotesHandler;
-
-#[async_trait]
-impl McpTool for ClearStickyNotesHandler {
-    fn name(&self) -> &'static str {
-        "clear_sticky_notes"
-    }
-
-    fn schema(&self) -> Value {
-        crate::mcp::tool_def::<ClearStickyNotesTool>(
-            "clear_sticky_notes",
-            "Execute clear_sticky_notes",
-        )
-    }
-
-    async fn execute(&self, _args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
-        state.code.sticky.modify(|notes| {
-            notes.clear();
-        });
-        Ok("All sticky notes cleared.".to_string())
-    }
-}
 
 pub struct HandoffMemosHandler;
 
@@ -414,37 +291,36 @@ mod tests {
         let dir = tempdir().unwrap();
         let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));
 
-        let add_handler = AddStickyNoteHandler;
+        let handler = StickyNotesHandler;
         let args = json!({
+            "action": "add",
             "content": "Buy milk",
         });
 
-        let res = add_handler
+        let res = handler
             .execute(args, state.clone())
             .await
             .map_err(|e| crate::error::AppError::Internal(e.to_string()))
             .unwrap();
         assert!(res.contains("Sticky note added"));
 
-        let read_handler = ReadStickyNotesHandler;
-        let res2 = read_handler
-            .execute(json!({}), state.clone())
+        let res2 = handler
+            .execute(json!({"action": "read"}), state.clone())
             .await
             .map_err(|e| crate::error::AppError::Internal(e.to_string()))
             .unwrap();
         assert!(res2.contains("Buy milk"));
 
-        let delete_handler = DeleteStickyNoteHandler;
-        let args2 = json!({"index": 1});
-        let res3 = delete_handler
+        let args2 = json!({"action": "delete", "index": 1});
+        let res3 = handler
             .execute(args2, state.clone())
             .await
             .map_err(|e| crate::error::AppError::Internal(e.to_string()))
             .unwrap();
         assert_eq!(res3, "Sticky note deleted.");
 
-        let res4 = read_handler
-            .execute(json!({}), state.clone())
+        let res4 = handler
+            .execute(json!({"action": "read"}), state.clone())
             .await
             .map_err(|e| crate::error::AppError::Internal(e.to_string()))
             .unwrap();