feat(watch): add voice command to post messages to Ant Farm rooms

ThinkOffApp · ThinkOffApp · commit 825d79263b3b · 2026-03-13T19:36:41.000+02:00
diff --git a/app/src/main/java/com/thinkoff/clawwatch/ClawRunner.kt b/app/src/main/java/com/thinkoff/clawwatch/ClawRunner.kt
@@ -95,13 +95,22 @@ class ClawRunner(private val context: Context) {
     fun saveMaxTokens(n: Int) = prefs.edit().putInt(PREF_MAX_TOKENS, n).apply()
     fun saveRagMode(mode: String) = prefs.edit().putString(PREF_RAG_MODE, mode).apply()
 
+    private fun getStringSetting(key: String, default: String? = null): String? {
+        val secure = prefs.getString(key, null)
+        if (!secure.isNullOrBlank()) return secure
+        val legacy = context
+            .getSharedPreferences("clawwatch_prefs", Context.MODE_PRIVATE)
+            .getString(key, null)
+        return legacy ?: default
+    }
+
     fun hasApiKey(): Boolean = prefs.getString(PREF_API_KEY, null)?.isNotBlank() == true
     private fun getApiKey(): String? = prefs.getString(PREF_API_KEY, null)
     private fun getBraveKey(): String? = prefs.getString(PREF_BRAVE_KEY, null)
     private fun getTavilyKey(): String? = prefs.getString(PREF_TAVILY_KEY, null)
-    private fun getAntFarmKey(): String? = prefs.getString(PREF_ANTFARM_KEY, null)
+    private fun getAntFarmKey(): String? = getStringSetting(PREF_ANTFARM_KEY)
     private fun getAntFarmRooms(): List<String> =
-        (prefs.getString(PREF_ANTFARM_ROOMS, DEFAULT_FAMILY_ROOMS) ?: DEFAULT_FAMILY_ROOMS)
+        (getStringSetting(PREF_ANTFARM_ROOMS, DEFAULT_FAMILY_ROOMS) ?: DEFAULT_FAMILY_ROOMS)
             .split(',')
             .map { it.trim() }
             .filter { it.isNotBlank() }
@@ -427,6 +436,60 @@ class ClawRunner(private val context: Context) {
         )
     }
 
+    suspend fun postMessageToRoom(room: String, message: String): Result<String> = withContext(Dispatchers.IO) {
+        val antFarmKey = getAntFarmKey()
+            ?: return@withContext Result.failure(
+                RuntimeException("room access key is missing")
+            )
+
+        val targetRoom = room.trim()
+            .ifBlank { getAntFarmRooms().firstOrNull().orEmpty() }
+            .ifBlank {
+                return@withContext Result.failure(RuntimeException("room name is missing"))
+            }
+
+        val cleanBody = message
+            .trim()
+            .replace(Regex("\\s+"), " ")
+            .take(500)
+        if (cleanBody.isBlank()) {
+            return@withContext Result.failure(RuntimeException("message was empty"))
+        }
+
+        return@withContext try {
+            val encodedRoom = URLEncoder.encode(targetRoom, "UTF-8")
+            val url = URL("https://antfarm.world/api/v1/rooms/$encodedRoom/messages")
+            val conn = url.openConnection() as HttpURLConnection
+            conn.requestMethod = "POST"
+            conn.setRequestProperty("Accept", "application/json")
+            conn.setRequestProperty("Authorization", "Bearer $antFarmKey")
+            conn.setRequestProperty("Content-Type", "application/json")
+            conn.connectTimeout = 10_000
+            conn.readTimeout = 10_000
+            conn.doOutput = true
+            val payload = JSONObject().apply { put("body", cleanBody) }.toString()
+            OutputStreamWriter(conn.outputStream).use { it.write(payload) }
+
+            val code = conn.responseCode
+            val responseText = if (code in 200..299) {
+                conn.inputStream.bufferedReader().readText()
+            } else {
+                conn.errorStream?.bufferedReader()?.readText() ?: "HTTP $code"
+            }
+
+            if (code !in 200..299) {
+                Log.w(TAG, "Ant Farm room post failed for $targetRoom: $code $responseText")
+                Result.failure(RuntimeException("room post failed ($code)"))
+            } else {
+                Log.i(TAG, "Posted room message to $targetRoom")
+                Result.success("Posted to $targetRoom.")
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "Ant Farm room post failed for $targetRoom: ${e.message}")
+            Result.failure(RuntimeException("network error while posting to room"))
+        }
+    }
+
     // ── Mode 1: Direct (no RAG) ───────────────────────────────────────────────
 
     private suspend fun queryDirect(prompt: String, apiKey: String): Result<String> =
diff --git a/app/src/main/java/com/thinkoff/clawwatch/MainActivity.kt b/app/src/main/java/com/thinkoff/clawwatch/MainActivity.kt
@@ -75,6 +75,10 @@ class MainActivity : AppCompatActivity() {
         val totalSeconds: Int,
         val spokenDuration: String
     )
+    private data class RoomMessageCommand(
+        val room: String,
+        val body: String
+    )
     private data class PendingVitalsCommand(
         val type: LocalCommandType,
         val token: Int
@@ -479,6 +483,10 @@ class MainActivity : AppCompatActivity() {
     }
 
     private fun handleLocalCommand(prompt: String, token: Int): Boolean {
+        parseRoomMessageCommand(prompt)?.let { command ->
+            launchRoomMessageCommand(command, token)
+            return true
+        }
         parseVitalsCommand(prompt)?.let { command ->
             launchVitalsCommand(command, token)
             return true
@@ -491,6 +499,54 @@ class MainActivity : AppCompatActivity() {
         return launchSystemTimer(timer, token)
     }
 
+    private fun parseRoomMessageCommand(prompt: String): RoomMessageCommand? {
+        val raw = prompt.trim()
+        if (raw.isBlank()) return null
+        val normalized = raw.lowercase().replace(Regex("\\s+"), " ")
+        val likelyPostIntent =
+            normalized.contains("send") ||
+                normalized.contains("post") ||
+                normalized.contains("write") ||
+                normalized.contains("tell")
+        if (!likelyPostIntent || !normalized.contains("room")) return null
+
+        val toRoomPattern = Regex(
+            """\b(?:send|post|write|tell)\b\s+(.+?)\s+\bto\s+(?:the\s+)?room\s+([a-zA-Z0-9._-]+)\b\s*$""",
+            RegexOption.IGNORE_CASE
+        )
+        toRoomPattern.find(raw)?.let { match ->
+            val body = cleanRoomMessageBody(match.groupValues[1])
+            val room = match.groupValues[2].trim()
+            if (body.isNotBlank() && room.isNotBlank()) {
+                return RoomMessageCommand(room = room, body = body)
+            }
+        }
+
+        val inRoomPattern = Regex(
+            """\b(?:send|post|write|tell)\b\s+(?:a\s+)?(?:message\s+)?(?:to|in)\s+(?:the\s+)?room\s+([a-zA-Z0-9._-]+)\b(?:\s*(?:saying|that|:)\s*|\s+)(.+)$""",
+            RegexOption.IGNORE_CASE
+        )
+        inRoomPattern.find(raw)?.let { match ->
+            val room = match.groupValues[1].trim()
+            val body = cleanRoomMessageBody(match.groupValues[2])
+            if (body.isNotBlank() && room.isNotBlank()) {
+                return RoomMessageCommand(room = room, body = body)
+            }
+        }
+
+        return null
+    }
+
+    private fun cleanRoomMessageBody(raw: String): String {
+        return raw
+            .trim()
+            .trim('"', '\'', '“', '”')
+            .replace(Regex("^message\\s+", RegexOption.IGNORE_CASE), "")
+            .replace(Regex("\\s+"), " ")
+            .trim()
+            .take(500)
+    }
+
     private fun parseVitalsCommand(prompt: String): LocalCommandType? {
         val normalized = prompt.lowercase()
         if (
@@ -687,6 +743,31 @@ class MainActivity : AppCompatActivity() {
         }
     }
 
+    private fun launchRoomMessageCommand(command: RoomMessageCommand, token: Int) {
+        queryJob?.cancel()
+        setState(State.THINKING)
+        setStatus("Sending message…")
+        queryJob = lifecycleScope.launch {
+            val result = clawRunner.postMessageToRoom(
+                room = command.room,
+                message = command.body
+            )
+            if (token != interactionToken) return@launch
+            result.fold(
+                onSuccess = { response ->
+                    binding.responseText.text = response
+                    speakLocalResponse(response, token)
+                },
+                onFailure = { err ->
+                    val reason = err.message?.take(120) ?: "unknown error"
+                    val response = "I couldn't send that room message. $reason"
+                    binding.responseText.text = response
+                    speakLocalResponse(response, token)
+                }
+            )
+        }
+    }
+
     private fun buildHeartRateSummary(snapshot: VitalsReader.Snapshot): String {
         val bpm = snapshot.heartRateBpm
             ?: return "I couldn't get a clean pulse reading just now. Keep the watch snug and hold still for a moment, then ask again."
