backup commit

neode-ui/src/stores/mesh.ts

@@ -0,0 +1,189 @@
+// Pinia store for mesh networking state (Meshcore LoRa)
+import { defineStore } from 'pinia'
+import { ref, computed } from 'vue'
+import { rpcClient } from '@/api/rpc-client'
+
+export interface MeshStatus {
+  enabled: boolean
+  device_type: string
+  device_path: string | null
+  device_connected: boolean
+  firmware_version: string | null
+  self_node_id: number | null
+  self_advert_name: string | null
+  peer_count: number
+  channel_name: string
+  messages_sent: number
+  messages_received: number
+  detected_devices?: string[]
+}
+
+export interface MeshPeer {
+  contact_id: number
+  advert_name: string
+  did: string | null
+  pubkey_hex: string | null
+  rssi: number | null
+  snr: number | null
+  last_heard: string
+  hops: number
+}
+
+export interface MeshChannel {
+  index: number
+  name: string
+  has_secret: boolean
+}
+
+export interface MeshMessage {
+  id: number
+  direction: 'sent' | 'received'
+  peer_contact_id: number
+  peer_name: string | null
+  plaintext: string
+  timestamp: string
+  delivered: boolean
+  encrypted: boolean
+}
+
+export const useMeshStore = defineStore('mesh', () => {
+  const status = ref<MeshStatus | null>(null)
+  const peers = ref<MeshPeer[]>([])
+  const messages = ref<MeshMessage[]>([])
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+  const sending = ref(false)
+
+  // Track unread message counts per peer (contact_id -> count)
+  const unreadCounts = ref<Record<number, number>>({})
+  // Currently viewing chat for this contact_id (clears unread)
+  const viewingChatId = ref<number | null>(null)
+  // Total unread count for nav badge
+  const totalUnread = computed(() =>
+    Object.values(unreadCounts.value).reduce((a, b) => a + b, 0)
+  )
+
+  async function fetchStatus() {
+    try {
+      loading.value = true
+      error.value = null
+      const res = await rpcClient.call<MeshStatus>({ method: 'mesh.status' })
+      status.value = res
+    } catch (err: unknown) {
+      error.value = err instanceof Error ? err.message : 'Failed to fetch mesh status'
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function fetchPeers() {
+    try {
+      const res = await rpcClient.call<{ peers: MeshPeer[]; count: number }>({
+        method: 'mesh.peers',
+      })
+      peers.value = res.peers
+    } catch (err: unknown) {
+      error.value = err instanceof Error ? err.message : 'Failed to fetch mesh peers'
+    }
+  }
+
+  async function fetchMessages(limit?: number) {
+    try {
+      const res = await rpcClient.call<{ messages: MeshMessage[]; count: number }>({
+        method: 'mesh.messages',
+        params: limit ? { limit } : {},
+      })
+      // Detect new incoming messages and increment unread counts
+      const newMsgs = res.messages.filter(
+        m => m.direction === 'received' && !messages.value.some(existing => existing.id === m.id)
+      )
+      for (const msg of newMsgs) {
+        // Don't count as unread if we're currently viewing that chat
+        if (msg.peer_contact_id !== viewingChatId.value) {
+          unreadCounts.value[msg.peer_contact_id] = (unreadCounts.value[msg.peer_contact_id] || 0) + 1
+        }
+      }
+      messages.value = res.messages
+    } catch (err: unknown) {
+      error.value = err instanceof Error ? err.message : 'Failed to fetch mesh messages'
+    }
+  }
+
+  function markChatRead(contactId: number) {
+    viewingChatId.value = contactId
+    delete unreadCounts.value[contactId]
+  }
+
+  function clearViewingChat() {
+    viewingChatId.value = null
+  }
+
+  async function sendMessage(contactId: number, message: string) {
+    try {
+      sending.value = true
+      error.value = null
+      const res = await rpcClient.call<{ sent: boolean; message_id: number; encrypted: boolean }>({
+        method: 'mesh.send',
+        params: { contact_id: contactId, message: message.trim() },
+      })
+      // Refresh messages after sending
+      if (res.sent) {
+        await fetchMessages()
+      }
+      return res
+    } catch (err: unknown) {
+      error.value = err instanceof Error ? err.message : 'Failed to send mesh message'
+      throw err
+    } finally {
+      sending.value = false
+    }
+  }
+
+  async function broadcastIdentity() {
+    try {
+      error.value = null
+      await rpcClient.call<{ broadcast: boolean }>({ method: 'mesh.broadcast' })
+    } catch (err: unknown) {
+      error.value = err instanceof Error ? err.message : 'Failed to broadcast identity'
+      throw err
+    }
+  }
+
+  async function configure(config: Partial<MeshStatus>) {
+    try {
+      error.value = null
+      await rpcClient.call<{ configured: boolean }>({
+        method: 'mesh.configure',
+        params: config,
+      })
+      await fetchStatus()
+    } catch (err: unknown) {
+      error.value = err instanceof Error ? err.message : 'Failed to configure mesh'
+      throw err
+    }
+  }
+
+  async function refreshAll() {
+    await Promise.all([fetchStatus(), fetchPeers(), fetchMessages()])
+  }
+
+  return {
+    status,
+    peers,
+    messages,
+    loading,
+    error,
+    sending,
+    unreadCounts,
+    totalUnread,
+    fetchStatus,
+    fetchPeers,
+    fetchMessages,
+    sendMessage,
+    broadcastIdentity,
+    configure,
+    refreshAll,
+    markChatRead,
+    clearViewingChat,
+  }
+})