slave 0.4.0

Laravel-inspired CLI for Rust MCP servers: scaffold apps whose business operations are MCP tools over Streamable HTTP, with built-in auth, users, roles and Turso migrations
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

//! MCP tools for authentication. Business rules live in `AuthService`.

use axum::extract::FromRef;
use axum::http::request::Parts;
use rmcp::handler::server::router::tool::ToolRouter;
use rmcp::handler::server::tool::Extension;
use rmcp::handler::server::wrapper::{Json, Parameters};
use rmcp::{tool, tool_router};

use crate::base::error::AppResult;
use crate::base::mcp::McpServer;
use crate::modules::auth::dto::auth::{
    LoginRequest, LogoutResponse, MeResponse, RegisterRequest, TokenResponse,
};
use crate::modules::auth::services::auth_service::AuthService;

pub fn tools() -> ToolRouter<McpServer> {
    McpServer::auth_tools()
}

#[tool_router(router = auth_tools, vis = "pub(crate)")]
impl McpServer {
    /// Create an account and get a bearer token. The first account becomes admin.
    #[tool(annotations(open_world_hint = false))]
    async fn auth_register(
        &self,
        Parameters(input): Parameters<RegisterRequest>,
    ) -> AppResult<Json<TokenResponse>> {
        let session = AuthService::from_ref(&self.state).register(input).await?;
        Ok(Json(session.into()))
    }

    /// Exchange an email and password for a new bearer token.
    #[tool(annotations(open_world_hint = false))]
    async fn auth_login(
        &self,
        Parameters(input): Parameters<LoginRequest>,
    ) -> AppResult<Json<TokenResponse>> {
        let session = AuthService::from_ref(&self.state).login(input).await?;
        Ok(Json(session.into()))
    }

    /// Revoke the bearer token this request was made with.
    #[tool(annotations(idempotent_hint = true, open_world_hint = false))]
    async fn auth_logout(
        &self,
        Extension(parts): Extension<Parts>,
    ) -> AppResult<Json<LogoutResponse>> {
        let user = self.authenticate(&parts).await?;
        AuthService::from_ref(&self.state)
            .logout(user.token_hash())
            .await?;
        Ok(Json(LogoutResponse { revoked: true }))
    }

    /// The signed-in user and their roles.
    #[tool(annotations(read_only_hint = true, open_world_hint = false))]
    async fn auth_me(&self, Extension(parts): Extension<Parts>) -> AppResult<Json<MeResponse>> {
        let user = self.authenticate(&parts).await?;
        Ok(Json(MeResponse {
            id: user.id,
            name: user.name,
            email: user.email,
            roles: user.roles,
        }))
    }
}