feat: implement MCP server

.github/workflows/skit.yml

@@ -57,6 +57,7 @@ jobs:
         run: |
           cargo clippy --locked --workspace --all-targets -- -D warnings
           cargo clippy --locked -p streamkit-server --all-targets --features "moq" -- -D warnings
+          cargo clippy --locked -p streamkit-server --all-targets --features "mcp" -- -D warnings
 
       - name: Install cargo-deny
         run: cargo install --locked cargo-deny
@@ -111,6 +112,7 @@ jobs:
         run: |
           cargo test --locked --workspace -- --skip gpu_tests::
           cargo test --locked -p streamkit-server --features "moq"
+          cargo test --locked -p streamkit-server --features "mcp"
 
   test-gpu:
     name: Test (GPU)

apps/skit/Cargo.toml

@@ -137,6 +137,18 @@ moq-lite = { version = "0.15.13", optional = true }
 blake2 = "0.10.6"
 async-stream = "0.3.6"
 
+# MCP (Model Context Protocol) server (optional)
+rmcp = { version = "1.5", features = [
+  "server",                                     # ServerHandler trait + service runner
+  "transport-streamable-http-server",            # Streamable HTTP transport (tower service)
+  "transport-streamable-http-server-session",    # Stateful session management (LocalSessionManager)
+  "transport-io",                                # STDIO transport (stdin/stdout)
+  "macros",                                      # #[tool], #[tool_router] proc macros
+  "schemars",                                    # JSON Schema generation for tool arguments
+], optional = true }
+# Used by the MCP module to extract HTTP request parts from rmcp's request context.
+http = { version = "1", optional = true }
+
 [features]
 default = ["script", "compositor", "gpu", "moq"]
 tokio-console = ["console-subscriber"]
@@ -145,6 +157,7 @@ profiling = ["dep:pprof", "dep:tikv-jemallocator", "dep:jemalloc_pprof"]
 # Use this to find hot allocation sites. Output is written on graceful shutdown.
 dhat-heap = ["dep:dhat"]
 moq = ["dep:moq-native", "dep:moq-lite"]
+mcp = ["dep:rmcp", "dep:http"]
 script = ["streamkit-nodes/script", "streamkit-engine/script"]
 compositor = ["streamkit-nodes/compositor", "streamkit-engine/compositor"]
 gpu = ["compositor", "streamkit-nodes/gpu", "streamkit-engine/gpu"]

apps/skit/src/cli.rs

@@ -51,6 +51,9 @@ pub struct Cli {
 pub enum Commands {
     /// Starts the skit server
     Serve,
+    /// Run the MCP server over STDIO (for MCP client integration)
+    #[cfg(feature = "mcp")]
+    Mcp,
     /// Manage configuration
     #[command(subcommand)]
     Config(ConfigCommands),
@@ -251,6 +254,39 @@ fn log_startup_info(config: &config::Config) {
     );
 }
 
+/// Handle the "mcp" command — start the MCP server over STDIO.
+/// Exits the process on error with status code 1.
+///
+/// Uses [`crate::logging::init_logging_stderr`] so that tracing output goes
+/// to stderr, keeping stdout clean for the JSON-RPC message stream.
+#[cfg(feature = "mcp")]
+#[allow(clippy::disallowed_macros)]
+async fn handle_mcp_command(config_path: &str, _init_logging: LogInitFn) {
+    let config_result = match config::load(config_path) {
+        Ok(result) => result,
+        Err(e) => {
+            eprintln!("Failed to load configuration: {e}");
+            std::process::exit(1);
+        },
+    };
+
+    let _log_guard = match crate::logging::init_logging_stderr(
+        &config_result.config.log,
+        &config_result.config.telemetry,
+    ) {
+        Ok(guard) => guard,
+        Err(e) => {
+            eprintln!("Failed to initialize logging: {e}");
+            std::process::exit(1);
+        },
+    };
+
+    if let Err(e) = crate::server::start_mcp_stdio(&config_result.config).await {
+        error!(error = %e, "Failed to start MCP STDIO server");
+        std::process::exit(1);
+    }
+}
+
 /// Handle the "serve" command - start the server
 /// Exits the process on error with status code 1
 // Allow eprintln before logging is initialized (CLI output)
@@ -724,6 +760,10 @@ pub async fn handle_command(cli: &Cli, init_logging: LogInitFn) {
         Commands::Serve => {
             handle_serve_command(&cli.config, init_logging).await;
         },
+        #[cfg(feature = "mcp")]
+        Commands::Mcp => {
+            handle_mcp_command(&cli.config, init_logging).await;
+        },
         Commands::Config(ConfigCommands::Default) => {
             handle_config_default_command();
         },