feat(TASK-12): beta telemetry — report endpoint + settings toggle

Backend: telemetry.report RPC builds anonymous health report with node ID
(SHA-256 hash of pubkey, truncated), version, uptime, container states,
CPU/RAM, federation peers, and recent alerts. Saves latest report to disk.
Requires analytics opt-in (existing analytics.enable/disable flow).

Frontend: "Beta Telemetry" section in Settings with enable/disable toggle.
Shows what data is and isn't collected. Mock backend handles all analytics
and telemetry RPCs.

Privacy: No wallet data, no private keys, no DIDs, no IP addresses.
Node identified by truncated hash only.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

core/archipelago/src/api/rpc/analytics.rs

@@ -117,4 +117,90 @@ impl RpcHandler {
             "collected_at": chrono::Utc::now().to_rfc3339(),
         }))
     }
+
+    /// Build a full telemetry report for the beta fleet monitoring.
+    /// Includes health data, container states, errors, and uptime.
+    /// No wallet data, no keys, no personal data — only system health.
+    pub(super) async fn handle_telemetry_report(&self) -> Result<serde_json::Value> {
+        // Check opt-in
+        let config_path = self.config.data_dir.join(ANALYTICS_FILE);
+        let enabled = if config_path.exists() {
+            let data = tokio::fs::read_to_string(&config_path).await?;
+            let config: serde_json::Value = serde_json::from_str(&data).unwrap_or_default();
+            config["enabled"].as_bool().unwrap_or(false)
+        } else {
+            false
+        };
+        if !enabled {
+            anyhow::bail!("Telemetry not enabled. Opt in via analytics.enable first.");
+        }
+
+        let (data, _) = self.state_manager.get_snapshot().await;
+
+        // Anonymous node ID — SHA-256 hash of the DID (not the DID itself)
+        let node_id = {
+            use sha2::{Sha256, Digest};
+            let mut hasher = Sha256::new();
+            hasher.update(data.server_info.pubkey.as_bytes());
+            hex::encode(hasher.finalize())[..16].to_string()
+        };
+
+        // Container states
+        let containers: Vec<serde_json::Value> = data.package_data.iter().map(|(id, pkg)| {
+            serde_json::json!({
+                "id": id,
+                "state": format!("{:?}", pkg.state),
+                "version": pkg.manifest.version,
+            })
+        }).collect();
+
+        // System stats
+        let cpu_cores = std::thread::available_parallelism()
+            .map(|n| n.get()).unwrap_or(0);
+        let mem_output = tokio::process::Command::new("grep")
+            .args(["MemTotal", "/proc/meminfo"])
+            .output().await;
+        let total_ram_mb = mem_output.ok()
+            .and_then(|o| String::from_utf8_lossy(&o.stdout).split_whitespace().nth(1)?.parse::<u64>().ok())
+            .map(|kb| kb / 1024).unwrap_or(0);
+
+        // Uptime
+        let uptime_secs = tokio::fs::read_to_string("/proc/uptime").await
+            .ok()
+            .and_then(|s| s.split_whitespace().next()?.parse::<f64>().ok())
+            .map(|f| f as u64)
+            .unwrap_or(0);
+
+        // Recent alerts from metrics store
+        let recent_alerts: Vec<serde_json::Value> = self.metrics_store.get_alerts().await
+            .into_iter()
+            .take(10)
+            .map(|a| serde_json::json!({
+                "rule": format!("{:?}", a.rule_type),
+                "message": a.message,
+                "fired_at": a.fired_at.to_rfc3339(),
+            }))
+            .collect();
+
+        let report = serde_json::json!({
+            "node_id": node_id,
+            "version": data.server_info.version,
+            "uptime_secs": uptime_secs,
+            "cpu_cores": cpu_cores,
+            "ram_mb": total_ram_mb,
+            "containers": containers,
+            "container_count": data.package_data.len(),
+            "running_count": data.package_data.values()
+                .filter(|p| matches!(p.state, crate::data_model::PackageState::Running)).count(),
+            "federation_peers": data.peer_health.len(),
+            "recent_alerts": recent_alerts,
+            "reported_at": chrono::Utc::now().to_rfc3339(),
+        });
+
+        // Save latest report to disk for debugging
+        let report_path = self.config.data_dir.join("telemetry-latest.json");
+        let _ = tokio::fs::write(&report_path, serde_json::to_string_pretty(&report)?).await;
+
+        Ok(report)
+    }
 }

core/archipelago/src/api/rpc/mod.rs

@@ -703,6 +703,7 @@ impl RpcHandler {
             "analytics.enable" => self.handle_analytics_enable().await,
             "analytics.disable" => self.handle_analytics_disable().await,
             "analytics.get-snapshot" => self.handle_analytics_get_snapshot().await,
+            "telemetry.report" => self.handle_telemetry_report().await,
 
             // Real-time metrics monitoring
             "monitoring.current" => self.handle_monitoring_current().await,

neode-ui/mock-backend.js

@@ -88,6 +88,21 @@ app.use(cookieParser())
 const sessions = new Map()
 const MOCK_PASSWORD = 'password123'
 
+// Mutable wallet state — faucet/send/receive modify these values
+const walletState = {
+  onchain_sats: 2_350_000,
+  channel_sats: 8_250_000,
+  ecash_sats: 250_000,
+  ecash_tokens: 12,
+  block_height: 892451,
+  transactions: [
+    { tx_hash: 'ab12cd34ef5678901234567890abcdef12345678', amount_sats: 2_000_000, direction: 'incoming', num_confirmations: 142, block_height: 892310, time_stamp: Math.floor(Date.now()/1000) - 86400, label: 'Channel funding', total_fees: 0, dest_addresses: [] },
+    { tx_hash: 'cd34ef5678901234567890abcdef1234567890ab', amount_sats: 250_000, direction: 'incoming', num_confirmations: 28, block_height: 892420, time_stamp: Math.floor(Date.now()/1000) - 7200, label: 'Faucet deposit', total_fees: 0, dest_addresses: [] },
+    { tx_hash: 'ff99ee88dd7766554433221100aabbccddeeff00', amount_sats: 100_000, direction: 'incoming', num_confirmations: 0, block_height: 0, time_stamp: Math.floor(Date.now()/1000) - 600, label: 'Incoming from faucet', total_fees: 0, dest_addresses: [] },
+  ],
+}
+function randomHex(bytes) { return Array.from({length: bytes}, () => Math.floor(Math.random()*256).toString(16).padStart(2,'0')).join('') }
+
 // User state (simulated file-based storage)
 let userState = {
   setupComplete: false,
@@ -95,6 +110,8 @@ let userState = {
   passwordHash: null, // In real app, this would be bcrypt hash
 }
 
+let mockState = { analyticsEnabled: false }
+
 // Initialize user state based on dev mode
 function initializeUserState() {
   switch (DEV_MODE) {
@@ -1912,28 +1929,24 @@ app.post('/rpc/v1', (req, res) => {
             num_active_channels: 4,
             num_inactive_channels: 1,
             num_pending_channels: 1,
-            block_height: 892451,
+            block_height: walletState.block_height,
             synced_to_chain: true,
             synced_to_graph: true,
             version: '0.17.4-beta',
             identity_pubkey: '03a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456',
             chains: [{ chain: 'bitcoin', network: 'signet' }],
-            // Balances (Home.vue reads these from getinfo)
-            balance_sats: 2_350_000,
-            channel_balance_sats: 8_250_000,
+            balance_sats: walletState.onchain_sats,
+            channel_balance_sats: walletState.channel_sats,
           },
         })
       }
 
       case 'lnd.gettransactions': {
+        const pending = walletState.transactions.filter(tx => tx.direction === 'incoming' && tx.num_confirmations < 3).length
         return res.json({
           result: {
-            transactions: [
-              { tx_hash: 'ab12cd34ef5678901234567890abcdef12345678', amount_sats: 2_000_000, num_confirmations: 142, block_height: 892310, time_stamp: Math.floor(Date.now()/1000) - 86400, label: 'Channel funding' },
-              { tx_hash: 'cd34ef5678901234567890abcdef1234567890ab', amount_sats: 250_000, num_confirmations: 28, block_height: 892420, time_stamp: Math.floor(Date.now()/1000) - 7200, label: 'Faucet deposit' },
-              { tx_hash: 'ff99ee88dd7766554433221100aabbccddeeff00', amount_sats: 100_000, num_confirmations: 0, block_height: 0, time_stamp: Math.floor(Date.now()/1000) - 600, label: 'Incoming from faucet' },
-            ],
-            incoming_pending_count: 1,
+            transactions: walletState.transactions,
+            incoming_pending_count: pending,
           },
         })
       }
@@ -1941,7 +1954,7 @@ app.post('/rpc/v1', (req, res) => {
       case 'lnd.channelbalance': {
         return res.json({
           result: {
-            local_balance: { sat: 8250000 },
+            local_balance: { sat: walletState.channel_sats },
             remote_balance: { sat: 11750000 },
             pending_open_local_balance: { sat: 500000 },
           },
@@ -1951,8 +1964,8 @@ app.post('/rpc/v1', (req, res) => {
       case 'lnd.walletbalance': {
         return res.json({
           result: {
-            total_balance: 2450000,
-            confirmed_balance: 2350000,
+            total_balance: walletState.onchain_sats + 100000,
+            confirmed_balance: walletState.onchain_sats,
             unconfirmed_balance: 100000,
           },
         })
@@ -1974,46 +1987,52 @@ app.post('/rpc/v1', (req, res) => {
       case 'lnd.newaddress': {
         const addrType = params?.type || 'p2wkh'
         const mockAddr = addrType === 'p2tr'
-          ? 'tb1p' + Array.from({length: 58}, () => '0123456789abcdef'[Math.floor(Math.random()*16)]).join('')
-          : 'tb1q' + Array.from({length: 38}, () => '0123456789abcdef'[Math.floor(Math.random()*16)]).join('')
+          ? 'tb1p' + randomHex(29)
+          : 'tb1q' + randomHex(19)
         return res.json({ result: { address: mockAddr } })
       }
 
       case 'lnd.addinvoice':
       case 'lnd.createinvoice': {
         const amt = params?.amt || params?.value || params?.amount_sats || 1000
-        const memo = params?.memo || ''
-        const rHash = Array.from({length: 32}, () => Math.floor(Math.random()*256).toString(16).padStart(2,'0')).join('')
+        const rHash = randomHex(32)
         return res.json({
           result: {
             r_hash: rHash,
             payment_request: `lnsb${amt}n1pjmock${Date.now().toString(36)}qqqxqyz5vqsp5mock${rHash.slice(0,20)}`,
             add_index: Date.now(),
-            payment_addr: Array.from({length: 32}, () => Math.floor(Math.random()*256).toString(16).padStart(2,'0')).join(''),
+            payment_addr: randomHex(32),
           },
         })
       }
 
       case 'lnd.payinvoice':
       case 'lnd.sendpayment': {
+        const amt = params?.amt || params?.amount_sats || 1000
+        const fee = Math.floor(Math.random() * 10) + 1
+        walletState.channel_sats = Math.max(0, walletState.channel_sats - amt - fee)
         return res.json({
           result: {
-            payment_hash: Array.from({length: 32}, () => Math.floor(Math.random()*256).toString(16).padStart(2,'0')).join(''),
-            payment_preimage: Array.from({length: 32}, () => Math.floor(Math.random()*256).toString(16).padStart(2,'0')).join(''),
+            payment_hash: randomHex(32),
+            payment_preimage: randomHex(32),
             status: 'SUCCEEDED',
-            fee_sat: Math.floor(Math.random() * 10) + 1,
-            value_sat: params?.amt || params?.amount_sats || 1000,
+            fee_sat: fee,
+            value_sat: amt,
           },
         })
       }
 
       case 'lnd.sendcoins': {
         const amt = params?.amount || params?.amt || 50000
+        walletState.onchain_sats = Math.max(0, walletState.onchain_sats - amt)
+        const txid = randomHex(32)
+        walletState.transactions.unshift({
+          tx_hash: txid, amount_sats: -amt, direction: 'outgoing', num_confirmations: 0,
+          block_height: 0, time_stamp: Math.floor(Date.now()/1000), label: 'Sent on-chain',
+          total_fees: 250, dest_addresses: [params?.addr || ''],
+        })
         return res.json({
-          result: {
-            txid: Array.from({length: 32}, () => Math.floor(Math.random()*256).toString(16).padStart(2,'0')).join(''),
-            amount: amt,
-          },
+          result: { txid, amount: amt },
         })
       }
 
@@ -2071,11 +2090,11 @@ app.post('/rpc/v1', (req, res) => {
       case 'wallet.ecash-balance': {
         return res.json({
           result: {
-            balance_sats: 250_000,
-            balance_msat: 250_000_000,
-            token_count: 12,
+            balance_sats: walletState.ecash_sats,
+            balance_msat: walletState.ecash_sats * 1000,
+            token_count: walletState.ecash_tokens,
             federations: [
-              { federation_id: 'fed1-demo', name: 'Archy Signet Mint', balance_msat: 250_000_000, gateway_active: true },
+              { federation_id: 'fed1-demo', name: 'Archy Signet Mint', balance_msat: walletState.ecash_sats * 1000, gateway_active: true },
             ],
           },
         })
@@ -2083,6 +2102,8 @@ app.post('/rpc/v1', (req, res) => {
 
       case 'wallet.ecash-send': {
         const amt = params?.amount_sats || 1000
+        walletState.ecash_sats = Math.max(0, walletState.ecash_sats - amt)
+        walletState.ecash_tokens = Math.max(0, walletState.ecash_tokens - 1)
         return res.json({
           result: {
             token: `cashuSend_mock_${amt}_${Date.now().toString(36)}`,
@@ -2092,9 +2113,12 @@ app.post('/rpc/v1', (req, res) => {
       }
 
       case 'wallet.ecash-receive': {
+        const amt = 5000
+        walletState.ecash_sats += amt
+        walletState.ecash_tokens += 1
         return res.json({
           result: {
-            amount_sats: 5000,
+            amount_sats: amt,
             federation_id: 'fed1-demo',
           },
         })
@@ -2125,15 +2149,25 @@ app.post('/rpc/v1', (req, res) => {
       }
 
       case 'dev.faucet': {
-        // Dev-only: add mock funds to all wallet types
         const amount = params?.amount_sats || 1_000_000
-        console.log(`[Dev Faucet] Adding ${amount} sats to all wallets`)
+        const ecashAmt = Math.floor(amount / 10)
+        walletState.onchain_sats += amount
+        walletState.channel_sats += amount
+        walletState.ecash_sats += ecashAmt
+        walletState.ecash_tokens += 1
+        const txid = randomHex(32)
+        walletState.transactions.unshift({
+          tx_hash: txid, amount_sats: amount, direction: 'incoming', num_confirmations: 0,
+          block_height: 0, time_stamp: Math.floor(Date.now()/1000), label: 'Dev faucet',
+          total_fees: 0, dest_addresses: [],
+        })
+        console.log(`[Dev Faucet] +${amount} on-chain, +${amount} Lightning, +${ecashAmt} ecash`)
         return res.json({
           result: {
-            onchain: { txid: Array.from({length: 32}, () => Math.floor(Math.random()*256).toString(16).padStart(2,'0')).join(''), amount_sats: amount },
-            lightning: { payment_hash: Array.from({length: 32}, () => Math.floor(Math.random()*256).toString(16).padStart(2,'0')).join(''), amount_sats: amount },
-            ecash: { token: `cashuSend_faucet_${amount}_${Date.now().toString(36)}`, amount_sats: Math.floor(amount / 10) },
-            message: `Added ${amount} sats on-chain, ${amount} sats Lightning, ${Math.floor(amount / 10)} sats ecash`,
+            onchain: { txid, amount_sats: amount },
+            lightning: { payment_hash: randomHex(32), amount_sats: amount },
+            ecash: { token: `cashuSend_faucet_${amount}_${Date.now().toString(36)}`, amount_sats: ecashAmt },
+            message: `Added ${amount} sats on-chain, ${amount} sats Lightning, ${ecashAmt} sats ecash`,
           },
         })
       }
@@ -2157,12 +2191,41 @@ app.post('/rpc/v1', (req, res) => {
       }
 
       // =====================================================================
+      // Analytics / Telemetry
+      // =====================================================================
+      case 'analytics.get-status': {
+        return res.json({ result: { enabled: mockState.analyticsEnabled || false, description: 'Anonymous aggregate statistics. No personal data collected.' } })
+      }
+      case 'analytics.enable': {
+        mockState.analyticsEnabled = true
+        return res.json({ result: { enabled: true } })
+      }
+      case 'analytics.disable': {
+        mockState.analyticsEnabled = false
+        return res.json({ result: { enabled: false } })
+      }
+      case 'analytics.get-snapshot':
+      case 'telemetry.report': {
+        return res.json({ result: {
+          node_id: 'mock-dev-node',
+          version: '1.2.0-alpha',
+          uptime_secs: 86400,
+          cpu_cores: 4,
+          ram_mb: 16384,
+          container_count: 12,
+          running_count: 10,
+          federation_peers: 2,
+          recent_alerts: [],
+          reported_at: new Date().toISOString(),
+        }})
+      }
+
       // System / Network / Updates
       // =====================================================================
       case 'system.stats': {
         return res.json({
           result: {
-            cpu_percent: +(12 + Math.random() * 18).toFixed(1),
+            cpu_usage_percent: +(12 + Math.random() * 18).toFixed(1),
             mem_used_bytes: 6_200_000_000 + Math.floor(Math.random() * 500_000_000),
             mem_total_bytes: 16_000_000_000,
             disk_used_bytes: 620_000_000_000 + Math.floor(Math.random() * 10_000_000_000),

neode-ui/src/views/Settings.vue

@@ -844,6 +844,28 @@
       </div>
     </div>
 
+    <!-- Beta Telemetry Section -->
+    <div class="glass-card px-6 py-6 mb-6">
+      <div class="flex items-center justify-between mb-3">
+        <div>
+          <h2 class="text-xl font-semibold text-white/96 mb-1">Beta Telemetry</h2>
+          <p class="text-sm text-white/60">Help improve Archipelago by sharing anonymous system health data. No wallet data, no keys, no personal info.</p>
+        </div>
+        <button
+          @click="toggleTelemetry"
+          :disabled="telemetryLoading"
+          class="shrink-0 ml-4 px-4 py-2 rounded-lg text-sm font-medium transition-colors"
+          :class="telemetryEnabled ? 'bg-green-500/20 text-green-300 border border-green-500/30 hover:bg-green-500/30' : 'glass-button'"
+        >
+          {{ telemetryLoading ? '...' : telemetryEnabled ? 'Enabled' : 'Enable' }}
+        </button>
+      </div>
+      <div v-if="telemetryEnabled" class="mt-3 text-xs text-white/50 space-y-1">
+        <p>Reporting: version, uptime, container states, CPU/RAM, error alerts.</p>
+        <p>Not reporting: wallet balances, private keys, DIDs, IP addresses.</p>
+      </div>
+    </div>
+
     <!-- Backup & Restore Section -->
     <div class="glass-card px-6 py-6 mb-6">
       <div class="mb-4">
@@ -1091,6 +1113,26 @@ async function saveServerName() {
 
 const version = computed(() => store.serverInfo?.version || '0.0.0')
 const showReleaseNotes = ref(false)
+
+// Telemetry
+const telemetryEnabled = ref(false)
+const telemetryLoading = ref(false)
+async function loadTelemetryStatus() {
+  try {
+    const res = await rpcClient.call<{ enabled: boolean }>({ method: 'analytics.get-status' })
+    telemetryEnabled.value = res.enabled
+  } catch { /* ignore */ }
+}
+async function toggleTelemetry() {
+  telemetryLoading.value = true
+  try {
+    const method = telemetryEnabled.value ? 'analytics.disable' : 'analytics.enable'
+    await rpcClient.call({ method })
+    telemetryEnabled.value = !telemetryEnabled.value
+  } catch { /* ignore */ }
+  telemetryLoading.value = false
+}
+loadTelemetryStatus()
 const serverTorAddressFromStore = computed(() => store.serverInfo?.['tor-address'] || null)
 const torAddressFromRpc = ref<string | null>(null)
 const serverTorAddress = computed(() => serverTorAddressFromStore.value || torAddressFromRpc.value)