From e83e907406919f647dd1a2024d480da6e2bfe3b7 Mon Sep 17 00:00:00 2001 From: CN059 Date: Wed, 30 Sep 2026 15:47:57 +0800 Subject: [PATCH 1/3] feat: complete capability provider dispatch --- .../mbrain/capability/AppCapabilityTools.kt | 56 ++++++++++++++++ .../mbrain/capability/CapabilityDispatch.kt | 67 +++++++++---------- .../mbrain/gateway/GatewayRuntime.kt | 15 ++++- 3 files changed, 101 insertions(+), 37 deletions(-) create mode 100644 app/src/main/kotlin/com/powercess/mbrain/capability/AppCapabilityTools.kt diff --git a/app/src/main/kotlin/com/powercess/mbrain/capability/AppCapabilityTools.kt b/app/src/main/kotlin/com/powercess/mbrain/capability/AppCapabilityTools.kt new file mode 100644 index 0000000..ce10b1d --- /dev/null +++ b/app/src/main/kotlin/com/powercess/mbrain/capability/AppCapabilityTools.kt @@ -0,0 +1,56 @@ +package com.powercess.mbrain.capability + +import android.content.ClipData +import android.content.ClipboardManager +import android.content.Context +import android.net.ConnectivityManager +import android.os.Build +import io.droidmcp.core.* + +/** Capabilities implemented by the MBrain process without Shizuku or Root. */ +object AppCapabilityTools { + fun all(context: Context): List = listOf(clipboardGet(context), clipboardSet(context), networkStatus(context)) + + private fun clipboardGet(context: Context) = object : McpTool { + override val name = "clipboard_get" + override val description = "Read the current clipboard through the normal Android ClipboardManager API." + override val annotations = ToolAnnotations(readOnlyHint = true) + override val parameters = emptyList() + override suspend fun execute(params: Map): ToolResult = try { + val manager = context.getSystemService(ClipboardManager::class.java) + val clip = manager?.primaryClip + val text = clip?.takeIf { it.itemCount > 0 }?.getItemAt(0)?.coerceToText(context)?.toString() + ToolResult.success(mapOf("available" to (text != null), "text" to (text ?: ""), "source" to "app")) + } catch (error: SecurityException) { + ToolResult.success(mapOf("available" to false, "text" to "", "source" to "app", "reason" to "system_denied")) + } + } + + private fun clipboardSet(context: Context) = object : McpTool { + override val name = "clipboard_set" + override val description = "Set the current clipboard through the normal Android ClipboardManager API." + override val annotations = ToolAnnotations(destructiveHint = true) + override val parameters = listOf(ToolParameter("value", "Clipboard text", ParameterType.STRING, true)) + override suspend fun execute(params: Map): ToolResult = try { + val value = params["value"] as? String ?: return ToolResult.error("value is required") + require(value.length <= 16000 && '\u0000' !in value) { "Text too long or contains NUL" } + context.getSystemService(ClipboardManager::class.java)?.setPrimaryClip(ClipData.newPlainText("MBrain", value)) + ToolResult.success(mapOf("ok" to true, "source" to "app")) + } catch (error: SecurityException) { ToolResult.error("clipboard_denied", "System denied clipboard write") } + } + + private fun networkStatus(context: Context) = object : McpTool { + override val name = "net_status" + override val description = "Read active network transport through ConnectivityManager." + override val annotations = ToolAnnotations(readOnlyHint = true) + override val parameters = emptyList() + override suspend fun execute(params: Map): ToolResult { + val manager = context.getSystemService(ConnectivityManager::class.java) + val network = manager?.activeNetwork + val caps = network?.let { manager.getNetworkCapabilities(it) } + return ToolResult.success(mapOf("available" to (network != null), "validated" to (caps?.hasCapability(16) == true), + "wifi" to (caps?.hasTransport(1) == true), "cellular" to (caps?.hasTransport(0) == true), + "vpn" to (caps?.hasTransport(4) == true), "api" to Build.VERSION.SDK_INT, "source" to "app")) + } + } +} diff --git a/app/src/main/kotlin/com/powercess/mbrain/capability/CapabilityDispatch.kt b/app/src/main/kotlin/com/powercess/mbrain/capability/CapabilityDispatch.kt index d548991..fc402fe 100644 --- a/app/src/main/kotlin/com/powercess/mbrain/capability/CapabilityDispatch.kt +++ b/app/src/main/kotlin/com/powercess/mbrain/capability/CapabilityDispatch.kt @@ -1,42 +1,37 @@ package com.powercess.mbrain.capability -import io.droidmcp.core.McpTool -import io.droidmcp.core.ToolAnnotations -import io.droidmcp.core.ToolParameter -import io.droidmcp.core.ToolResult -import io.droidmcp.core.ParameterType +import io.droidmcp.core.* enum class ProviderKind { APP, SPECIAL_ACCESS, SHIZUKU, ROOT } - -data class CapabilityDefinition( - val id: String, - val description: String, - val risk: String = "read", - val providers: List, -) - -/** Stable MCP capability names over provider-specific tools. */ -class CapabilityDispatcher( - private val definitions: List, - private val tools: Map>, -) { - fun tools(): List = definitions.mapNotNull { definition -> - val available = definition.providers.firstOrNull { tools[it]?.containsKey(definition.id) == true } ?: return@mapNotNull null - val delegate = tools.getValue(available).getValue(definition.id) - object : McpTool { - override val name = definition.id - override val description = "${definition.description} Provider: ${available.name.lowercase()}." - override val annotations: ToolAnnotations = delegate.annotations - override val parameters: List = delegate.parameters + - ToolParameter("provider", "auto or ${definition.providers.joinToString("/") { it.name.lowercase() }}", ParameterType.STRING) - override suspend fun execute(params: Map): ToolResult { - val requested = (params["provider"] as? String)?.lowercase() - val selected = if (requested == null || requested == "auto") available else - runCatching { ProviderKind.valueOf(requested.uppercase()) }.getOrNull() - val target = selected?.let { tools[it]?.get(definition.id) } - ?: return ToolResult.error("provider_unavailable", "Capability ${definition.id} has no available provider") - return target.execute(params - "provider") - } +enum class ProviderStatus { AVAILABLE, UNAVAILABLE, REQUIRES_PERMISSION, DISCONNECTED, UNSUPPORTED } +data class ProviderState(val status: ProviderStatus, val reason: String? = null) { val available get() = status == ProviderStatus.AVAILABLE } +data class CapabilityDefinition(val id: String, val description: String, val risk: String = "read", val providers: List, val outputContract: String = "provider_envelope_v1") +interface CapabilityProvider { val kind: ProviderKind; fun state(capabilityId: String): ProviderState; fun tool(capabilityId: String): McpTool? } +class ToolMapProvider(override val kind: ProviderKind, private val tools: Map, private val stateResolver: (String) -> ProviderState = { ProviderState(ProviderStatus.AVAILABLE) }) : CapabilityProvider { + override fun state(capabilityId: String) = if (tools.containsKey(capabilityId)) stateResolver(capabilityId) else ProviderState(ProviderStatus.UNSUPPORTED, "provider_has_no_implementation") + override fun tool(capabilityId: String): McpTool? = tools[capabilityId] +} +class CapabilityRegistry(val definitions: List, private val providers: Map) { + fun states(id: String) = definitions.firstOrNull { it.id == id }?.providers?.associateWith { providers[it]?.state(id) ?: ProviderState(ProviderStatus.UNSUPPORTED, "provider_not_registered") } ?: emptyMap() + fun provider(kind: ProviderKind) = providers[kind] +} +class CapabilityDispatcher(private val registry: CapabilityRegistry) { + fun tools(): List = registry.definitions.map { definition -> object : McpTool { + override val name = definition.id + override val description = definition.description + private val delegate = definition.providers.asSequence().mapNotNull { registry.provider(it)?.tool(definition.id) }.firstOrNull() + override val annotations = delegate?.annotations ?: ToolAnnotations() + override val parameters = (delegate?.parameters ?: emptyList()) + ToolParameter("provider", "Provider override; default auto", ParameterType.STRING) + override suspend fun execute(params: Map): ToolResult { + val requested = (params["provider"] as? String)?.lowercase() ?: "auto" + val explicit = if (requested == "auto") null else runCatching { ProviderKind.valueOf(requested.uppercase()) }.getOrNull() ?: return ToolResult.error("invalid_provider", requested) + val candidates = explicit?.let { listOf(it) } ?: definition.providers + val states = registry.states(definition.id) + val selected = candidates.firstOrNull { states[it]?.available == true } ?: return ToolResult.error("provider_unavailable", states.entries.joinToString { "${it.key.name.lowercase()}:${it.value.reason ?: it.value.status.name.lowercase()}" }) + val target = registry.provider(selected)?.tool(definition.id) ?: return ToolResult.error("provider_unavailable", selected.name.lowercase()) + val result = target.execute(params - "provider") + return if (result.isSuccess) ToolResult.success((result.data ?: emptyMap()) + mapOf("provider" to selected.name.lowercase(), "capability" to definition.id, "contract" to definition.outputContract)) else result } - } + } } + fun directory(): List> = registry.definitions.map { definition -> mapOf("id" to definition.id, "risk" to definition.risk, "contract" to definition.outputContract, "providers" to definition.providers.map { it.name.lowercase() }, "states" to registry.states(definition.id).mapKeys { it.key.name.lowercase() }.mapValues { mapOf("status" to it.value.status.name.lowercase(), "reason" to it.value.reason) }) } } diff --git a/app/src/main/kotlin/com/powercess/mbrain/gateway/GatewayRuntime.kt b/app/src/main/kotlin/com/powercess/mbrain/gateway/GatewayRuntime.kt index 6485dd4..cee1017 100644 --- a/app/src/main/kotlin/com/powercess/mbrain/gateway/GatewayRuntime.kt +++ b/app/src/main/kotlin/com/powercess/mbrain/gateway/GatewayRuntime.kt @@ -210,6 +210,7 @@ object GatewayRuntime { } private fun localTools(): List = buildList { val capabilityProviders = mutableMapOf>() + capabilityProviders[ProviderKind.APP] = AppCapabilityTools.all(context).associateBy { it.name }.toMutableMap() addAll(DeviceTools.all(context)) if (config.value.appsEnabled) addAll(AppsTools.all(context)) listOf(ExecutionMode.ROOT, ExecutionMode.SHIZUKU).forEach { mode -> @@ -246,7 +247,19 @@ object GatewayRuntime { CapabilityDefinition("net_status", "Read network status", "read", listOf(ProviderKind.APP, ProviderKind.SHIZUKU, ProviderKind.ROOT)), CapabilityDefinition("net_diagnose", "Diagnose DNS and TCP connectivity", "read", listOf(ProviderKind.APP, ProviderKind.SHIZUKU, ProviderKind.ROOT)), ) - addAll(CapabilityDispatcher(definitions, capabilityProviders).tools()) + val providerObjects = capabilityProviders.mapValues { (kind, tools) -> + ToolMapProvider(kind, tools) { if (kind == ProviderKind.APP) ProviderState(ProviderStatus.AVAILABLE) else ProviderState(ProviderStatus.AVAILABLE) } + } + val registry = CapabilityRegistry(definitions, providerObjects) + val dispatcher = CapabilityDispatcher(registry) + addAll(dispatcher.tools()) + add(object : McpTool { + override val name = "capabilities_list" + override val description = "List capability contracts and live Provider states." + override val annotations = ToolAnnotations(readOnlyHint = true) + override val parameters = emptyList() + override suspend fun execute(params: Map) = ToolResult.success(mapOf("capabilities" to dispatcher.directory())) + }) } private fun refreshTools() { val current = server ?: return From 2d9023caab512e9ca64dd2ee617607b7cee10a3b Mon Sep 17 00:00:00 2001 From: CN059 Date: Wed, 30 Sep 2026 15:52:21 +0800 Subject: [PATCH 2/3] fix: report live privileged provider state --- .../com/powercess/mbrain/gateway/GatewayRuntime.kt | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/app/src/main/kotlin/com/powercess/mbrain/gateway/GatewayRuntime.kt b/app/src/main/kotlin/com/powercess/mbrain/gateway/GatewayRuntime.kt index cee1017..a122390 100644 --- a/app/src/main/kotlin/com/powercess/mbrain/gateway/GatewayRuntime.kt +++ b/app/src/main/kotlin/com/powercess/mbrain/gateway/GatewayRuntime.kt @@ -248,7 +248,14 @@ object GatewayRuntime { CapabilityDefinition("net_diagnose", "Diagnose DNS and TCP connectivity", "read", listOf(ProviderKind.APP, ProviderKind.SHIZUKU, ProviderKind.ROOT)), ) val providerObjects = capabilityProviders.mapValues { (kind, tools) -> - ToolMapProvider(kind, tools) { if (kind == ProviderKind.APP) ProviderState(ProviderStatus.AVAILABLE) else ProviderState(ProviderStatus.AVAILABLE) } + ToolMapProvider(kind, tools) { + when (kind) { + ProviderKind.APP -> ProviderState(ProviderStatus.AVAILABLE) + ProviderKind.ROOT -> if (available(ExecutionMode.ROOT)) ProviderState(ProviderStatus.AVAILABLE) else ProviderState(ProviderStatus.DISCONNECTED, "root_not_ready") + ProviderKind.SHIZUKU -> if (available(ExecutionMode.SHIZUKU)) ProviderState(ProviderStatus.AVAILABLE) else ProviderState(ProviderStatus.DISCONNECTED, "shizuku_not_ready") + ProviderKind.SPECIAL_ACCESS -> ProviderState(ProviderStatus.REQUIRES_PERMISSION, "special_access_not_registered") + } + } } val registry = CapabilityRegistry(definitions, providerObjects) val dispatcher = CapabilityDispatcher(registry) From 496f25f694582fc1a38ded17ae2785c9fcfcf13e Mon Sep 17 00:00:00 2001 From: CN059 Date: Wed, 30 Sep 2026 18:23:08 +0800 Subject: [PATCH 3/3] fix: use network capability constants --- .../com/powercess/mbrain/capability/AppCapabilityTools.kt | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/app/src/main/kotlin/com/powercess/mbrain/capability/AppCapabilityTools.kt b/app/src/main/kotlin/com/powercess/mbrain/capability/AppCapabilityTools.kt index ce10b1d..1dcf6aa 100644 --- a/app/src/main/kotlin/com/powercess/mbrain/capability/AppCapabilityTools.kt +++ b/app/src/main/kotlin/com/powercess/mbrain/capability/AppCapabilityTools.kt @@ -48,9 +48,9 @@ object AppCapabilityTools { val manager = context.getSystemService(ConnectivityManager::class.java) val network = manager?.activeNetwork val caps = network?.let { manager.getNetworkCapabilities(it) } - return ToolResult.success(mapOf("available" to (network != null), "validated" to (caps?.hasCapability(16) == true), - "wifi" to (caps?.hasTransport(1) == true), "cellular" to (caps?.hasTransport(0) == true), - "vpn" to (caps?.hasTransport(4) == true), "api" to Build.VERSION.SDK_INT, "source" to "app")) + return ToolResult.success(mapOf("available" to (network != null), "validated" to (caps?.hasCapability(android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED) == true), + "wifi" to (caps?.hasTransport(android.net.NetworkCapabilities.TRANSPORT_WIFI) == true), "cellular" to (caps?.hasTransport(android.net.NetworkCapabilities.TRANSPORT_CELLULAR) == true), + "vpn" to (caps?.hasTransport(android.net.NetworkCapabilities.TRANSPORT_VPN) == true), "api" to Build.VERSION.SDK_INT, "source" to "app")) } } }