ai: accept json command inputs via --arg

Author: ovitrif

.claude/plugins/blocktank-api/skills/lsp/SKILL.md

@@ -145,7 +145,8 @@ The script uses the `DevToolsProvider` ContentProvider (dev builds only) to crea
 **Create a single invoice manually:**
 
 ```bash
-adb shell content call --uri content://to.bitkit.dev.devtools --method createInvoice --arg 1000
+adb shell "content call --uri content://to.bitkit.dev.devtools \
+  --method createInvoice --arg '{\"amount\":1000,\"description\":\"test\"}'"
 ```
 
 ## State Machines

.claude/plugins/blocktank-api/skills/lsp/scripts/lsp.sh

@@ -21,12 +21,12 @@ BODY="${3:-}"
 
 URL="${BASE_URL}${API_PATH}"
 
+tmpfile=$(mktemp)
+trap 'rm -f "$tmpfile"' EXIT
+
 call_api() {
     local http_code
     local response
-    local tmpfile
-    tmpfile=$(mktemp)
-    trap 'rm -f "$tmpfile"' EXIT
 
     if [ "$METHOD" = "GET" ]; then
         http_code=$(curl -s -o "$tmpfile" -w "%{http_code}" "$URL")

.claude/plugins/blocktank-api/skills/lsp/scripts/pay-invoices.sh

@@ -36,11 +36,9 @@ create_invoice() {
     local amount="$1"
     local index="$2"
     local raw
-    raw=$(adb shell content call \
-        --uri "content://$AUTHORITY" \
+    raw=$(adb shell "content call --uri content://$AUTHORITY \
         --method createInvoice \
-        --arg "$amount" \
-        --extra "description:s:dev-payment-$index")
+        --arg '{\"amount\":$amount,\"description\":\"dev-payment-$index\"}'")
 
     # Extract JSON from Bundle output: Result: Bundle[{result={"bolt11":"..."}}]
     local json

app/src/debug/java/to/bitkit/dev/DevToolsProvider.kt

@@ -13,15 +13,9 @@ import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
 import to.bitkit.async.ServiceQueue
 import to.bitkit.repositories.LightningRepo
-import to.bitkit.utils.Logger
 
 class DevToolsProvider : ContentProvider() {
 
-    companion object {
-        private const val TAG = "DevToolsProvider"
-        private const val KEY_DESCRIPTION = "description"
-    }
-
     @EntryPoint
     @InstallIn(SingletonComponent::class)
     interface Dependencies {
@@ -33,28 +27,24 @@ class DevToolsProvider : ContentProvider() {
     }
 
     override fun call(method: String, arg: String?, extras: Bundle?): Bundle {
-        val command = DevCommand.from(method)
+        val command = DevCommand.parse(method, arg)
             ?: return DevResult.Error("Unknown method: '$method'").toBundle()
-        return execute(command) { handle(command, arg, extras) }
+        return execute { handle(command) }
     }
 
-    private fun execute(command: DevCommand, block: suspend () -> DevResult): Bundle = runCatching {
+    private fun execute(block: suspend () -> DevResult): Bundle = runCatching {
         ServiceQueue.LDK.blocking { block() }
     }.getOrElse {
-        Logger.error("${command.method} failed", it, context = TAG)
-        DevResult.Error(it.message ?: "Failed command: '$command.method'")
+        DevResult.Error(it.message)
     }.toBundle()
 
-    private suspend fun handle(command: DevCommand, arg: String?, extras: Bundle?): DevResult = when (command) {
-        DevCommand.CREATE_INVOICE -> createInvoice(arg, extras)
-    }
-
-    private suspend fun createInvoice(arg: String?, extras: Bundle?): DevResult {
-        val amountSats = arg?.toULongOrNull()
-        val description = extras?.getString(KEY_DESCRIPTION) ?: "dev-invoice"
-        return lightningRepo.createInvoice(amountSats, description).fold(
+    private suspend fun handle(command: DevCommand): DevResult = when (command) {
+        is DevCommand.CreateInvoice -> lightningRepo.createInvoice(
+            command.args.amount,
+            command.args.description,
+        ).fold(
             onSuccess = { DevResult.Invoice(it) },
-            onFailure = { DevResult.Error(it.message ?: "Failed command: 'createInvoice'.") },
+            onFailure = { DevResult.Error(it.message) },
         )
     }
 
@@ -66,25 +56,43 @@ class DevToolsProvider : ContentProvider() {
     override fun query(uri: Uri, proj: Array<String>?, sel: String?, args: Array<String>?, sort: String?) = null
 }
 
-enum class DevCommand(val method: String) {
-    CREATE_INVOICE("createInvoice");
+private sealed interface DevCommand {
+
+    val method: String
+
+    data class CreateInvoice(val args: Args) : DevCommand {
+        companion object {
+            const val METHOD = "createInvoice"
+        }
+
+        override val method get() = METHOD
+
+        @Serializable
+        data class Args(val amount: ULong? = null, val description: String = "dev-invoice")
+    }
 
     companion object {
-        fun from(method: String) = entries.find { it.method == method }
+        fun parse(method: String, arg: String?): DevCommand? = when (method) {
+            CreateInvoice.METHOD -> CreateInvoice(arg.deserialize<CreateInvoice.Args>())
+            else -> null
+        }
     }
 }
 
 @Serializable
-sealed interface DevResult {
+private sealed interface DevResult {
     @Serializable
     data class Invoice(val bolt11: String) : DevResult
 
     @Serializable
-    data class Error(val message: String) : DevResult
+    data class Error(val message: String? = null) : DevResult
 
     fun toBundle() = bundleOf(KEY_RESULT to Json.encodeToString(this))
 
     companion object {
         private const val KEY_RESULT = "result"
     }
 }
+
+private inline fun <reified T> String?.deserialize(): T =
+    if (isNullOrBlank()) Json.decodeFromString("{}") else Json.decodeFromString(this)