Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -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<McpTool> = 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<ToolParameter>()
override suspend fun execute(params: Map<String, Any>): 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<String, Any>): 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<ToolParameter>()
override suspend fun execute(params: Map<String, Any>): 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(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"))
}
}
}
Original file line number Diff line number Diff line change
@@ -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<ProviderKind>,
)

/** Stable MCP capability names over provider-specific tools. */
class CapabilityDispatcher(
private val definitions: List<CapabilityDefinition>,
private val tools: Map<ProviderKind, Map<String, McpTool>>,
) {
fun tools(): List<McpTool> = 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<ToolParameter> = delegate.parameters +
ToolParameter("provider", "auto or ${definition.providers.joinToString("/") { it.name.lowercase() }}", ParameterType.STRING)
override suspend fun execute(params: Map<String, Any>): 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<ProviderKind>, 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<String, McpTool>, 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<CapabilityDefinition>, private val providers: Map<ProviderKind, CapabilityProvider>) {
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<McpTool> = 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<String, Any>): 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<Map<String, Any?>> = 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) }) }
}
Original file line number Diff line number Diff line change
Expand Up @@ -210,6 +210,7 @@ object GatewayRuntime {
}
private fun localTools(): List<McpTool> = buildList {
val capabilityProviders = mutableMapOf<ProviderKind, MutableMap<String, McpTool>>()
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 ->
Expand Down Expand Up @@ -246,7 +247,26 @@ 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) {
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)
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<ToolParameter>()
override suspend fun execute(params: Map<String, Any>) = ToolResult.success(mapOf("capabilities" to dispatcher.directory()))
})
}
private fun refreshTools() {
val current = server ?: return
Expand Down
Loading