Update server/status.js

Add blockchain height to Fulcrum status

server/status.js

@@ -4,147 +4,220 @@ const net = require('net');
 const port = 8080;
 const fulcrumTimeoutMs = 3000;
 
-function checkFulcrum(fulcrumUrl) {
+function queryFulcrum(fulcrumUrl, method, params = []) {
-  return new Promise((resolve) => {
+return new Promise((resolve) => {
-    if (!fulcrumUrl) {
+if (!fulcrumUrl) {
-      resolve({
+resolve({
-        configured: false,
+ok: false,
-        connected: false,
+result: null,
-        url: null,
+});
-      });
+return;
-      return;
+}
-    }
 
-    let parsed;
+```
+let parsed;
+
+try {
+  parsed = new URL(fulcrumUrl);
+} catch {
+  resolve({
+    ok: false,
+    result: null,
+  });
+  return;
+}
+
+if (parsed.protocol !== 'tcp:') {
+  resolve({
+    ok: false,
+    result: null,
+  });
+  return;
+}
+
+const host = parsed.hostname;
+const fulcrumPort = Number(parsed.port);
+
+if (!host || !fulcrumPort) {
+  resolve({
+    ok: false,
+    result: null,
+  });
+  return;
+}
+
+const socket = net.createConnection({
+  host,
+  port: fulcrumPort,
+});
+
+let response = '';
+let settled = false;
+
+const finish = (value) => {
+  if (settled) return;
+  settled = true;
+
+  socket.destroy();
+  resolve(value);
+};
+
+socket.setTimeout(fulcrumTimeoutMs);
+
+socket.on('connect', () => {
+  socket.write(
+    `${JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method,
+      params,
+    })}\n`,
+  );
+});
+
+socket.on('data', (data) => {
+  response += data.toString();
+
+  const lines = response.split('\n');
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+
+    let message;
 
     try {
-      parsed = new URL(fulcrumUrl);
+      message = JSON.parse(line);
     } catch {
-      resolve({
+      continue;
-        configured: true,
+    }
-        connected: false,
+
-        url: fulcrumUrl,
+    if (message.error) {
+      finish({
+        ok: false,
+        result: null,
       });
       return;
     }
 
-    if (parsed.protocol !== 'tcp:') {
+    if (Object.prototype.hasOwnProperty.call(message, 'result')) {
-      resolve({
+      finish({
-        configured: true,
+        ok: true,
-        connected: false,
+        result: message.result,
-        url: fulcrumUrl,
       });
       return;
     }
+  }
+});
 
-    const host = parsed.hostname;
+socket.on('timeout', () => {
-    const port = Number(parsed.port);
+  finish({
-
+    ok: false,
-    if (!host || !port) {
+    result: null,
-      resolve({
-        configured: true,
-        connected: false,
-        url: fulcrumUrl,
-      });
-      return;
-    }
-
-    const socket = net.createConnection({
-      host,
-      port,
-    });
-
-    let response = '';
-    let settled = false;
-
-    const finish = (connected) => {
-      if (settled) return;
-      settled = true;
-
-      socket.destroy();
-
-      resolve({
-        configured: true,
-        connected,
-        url: fulcrumUrl,
-      });
-    };
-
-    socket.setTimeout(fulcrumTimeoutMs);
-
-    socket.on('connect', () => {
-      socket.write(
-        `${JSON.stringify({
-          jsonrpc: '2.0',
-          id: 1,
-          method: 'server.version',
-          params: ['Munin Bitcoin', '1.4'],
-        })}\n`,
-      );
-    });
-
-    socket.on('data', (data) => {
-      response += data.toString();
-
-      if (response.includes('"result"')) {
-        finish(true);
-      } else if (response.includes('"error"')) {
-        finish(false);
-      }
-    });
-
-    socket.on('timeout', () => finish(false));
-    socket.on('error', () => finish(false));
-    socket.on('close', () => finish(false));
   });
+});
+
+socket.on('error', () => {
+  finish({
+    ok: false,
+    result: null,
+  });
+});
+
+socket.on('close', () => {
+  finish({
+    ok: false,
+    result: null,
+  });
+});
+```
+
+});
+}
+
+async function getFulcrumStatus(fulcrumUrl) {
+const version = await queryFulcrum(
+fulcrumUrl,
+'server.version',
+['Munin Bitcoin', '1.4'],
+);
+
+if (!version.ok) {
+return {
+configured: Boolean(fulcrumUrl),
+connected: false,
+url: fulcrumUrl,
+serverVersion: null,
+blockchainHeight: null,
+};
+}
+
+const headers = await queryFulcrum(
+fulcrumUrl,
+'blockchain.headers.subscribe',
+[],
+);
+
+return {
+configured: Boolean(fulcrumUrl),
+connected: true,
+url: fulcrumUrl,
+serverVersion: version.result,
+blockchainHeight:
+headers.ok && headers.result
+? headers.result.height ?? null
+: null,
+};
 }
 
 async function getStatus() {
-  const fulcrumUrl = process.env.MUNIN_FULCRUM_URL || null;
+const fulcrumUrl = process.env.MUNIN_FULCRUM_URL || null;
-  const fulcrum = await checkFulcrum(fulcrumUrl);
+const fulcrum = await getFulcrumStatus(fulcrumUrl);
 
-  return {
+return {
-    service: 'running',
+service: 'running',
-    fulcrum,
+fulcrum,
-    wallet: 'not configured',
+wallet: 'not configured',
-    labels: 0,
+labels: 0,
-    transactions: 0,
+transactions: 0,
-    lastScan: 'never',
+lastScan: 'never',
-  };
+};
 }
 
 const server = http.createServer(async (req, res) => {
-  if (req.url === '/api/status') {
+if (req.url === '/api/status') {
-    try {
+try {
-      const status = await getStatus();
+const status = await getStatus();
 
-      res.writeHead(200, {
+```
-        'Content-Type': 'application/json',
+  res.writeHead(200, {
-      });
+    'Content-Type': 'application/json',
+  });
 
-      res.end(JSON.stringify(status));
+  res.end(JSON.stringify(status));
-    } catch (error) {
+} catch (error) {
-      console.error('Failed to get service status:', error);
+  console.error('Failed to get service status:', error);
 
-      res.writeHead(500, {
+  res.writeHead(500, {
-        'Content-Type': 'application/json',
+    'Content-Type': 'application/json',
-      });
+  });
 
-      res.end(
+  res.end(
-        JSON.stringify({
+    JSON.stringify({
-          service: 'running',
+      service: 'running',
-          error: 'Failed to determine service status',
+      error: 'Failed to determine service status',
-        }),
+    }),
-      );
+  );
-    }
+}
 
-    return;
+return;
-  }
+```
 
-  res.writeHead(404);
+}
-  res.end('Not found');
+
+res.writeHead(404);
+res.end('Not found');
 });
 
 server.listen(port, () => {
-  console.log(`Status API listening on port ${port}`);
+console.log(`Status API listening on port ${port}`);
 });