Update server/status.js

Fix status API server syntax

server/status.js

@@ -5,219 +5,213 @@ const port = 8080;
 const fulcrumTimeoutMs = 3000;
 
 function queryFulcrum(fulcrumUrl, method, params = []) {
-return new Promise((resolve) => {
+  return new Promise((resolve) => {
-if (!fulcrumUrl) {
+    if (!fulcrumUrl) {
-resolve({
+      resolve({
-ok: false,
-result: null,
-});
-return;
-}
-
-```
-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 {
-      message = JSON.parse(line);
-    } catch {
-      continue;
-    }
-
-    if (message.error) {
-      finish({
         ok: false,
         result: null,
       });
       return;
     }
 
-    if (Object.prototype.hasOwnProperty.call(message, 'result')) {
+    let parsed;
-      finish({
+
-        ok: true,
+    try {
-        result: message.result,
+      parsed = new URL(fulcrumUrl);
+    } catch {
+      resolve({
+        ok: false,
+        result: null,
       });
       return;
     }
-  }
-});
 
-socket.on('timeout', () => {
+    if (parsed.protocol !== 'tcp:') {
-  finish({
+      resolve({
-    ok: false,
+        ok: false,
-    result: null,
+        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 {
+          message = JSON.parse(line);
+        } catch {
+          continue;
+        }
+
+        if (message.error) {
+          finish({
+            ok: false,
+            result: null,
+          });
+          return;
+        }
+
+        if (Object.prototype.hasOwnProperty.call(message, 'result')) {
+          finish({
+            ok: true,
+            result: message.result,
+          });
+          return;
+        }
+      }
+    });
+
+    socket.on('timeout', () => {
+      finish({
+        ok: false,
+        result: null,
+      });
+    });
+
+    socket.on('error', () => {
+      finish({
+        ok: false,
+        result: null,
+      });
+    });
+
+    socket.on('close', () => {
+      finish({
+        ok: false,
+        result: null,
+      });
+    });
   });
-});
-
-socket.on('error', () => {
-  finish({
-    ok: false,
-    result: null,
-  });
-});
-
-socket.on('close', () => {
-  finish({
-    ok: false,
-    result: null,
-  });
-});
-```
-
-});
 }
 
 async function getFulcrumStatus(fulcrumUrl) {
-const version = await queryFulcrum(
+  const version = await queryFulcrum(
-fulcrumUrl,
+    fulcrumUrl,
-'server.version',
+    'server.version',
-['Munin Bitcoin', '1.4'],
+    ['Munin Bitcoin', '1.4'],
-);
+  );
 
-if (!version.ok) {
+  if (!version.ok) {
-return {
+    return {
-configured: Boolean(fulcrumUrl),
+      configured: Boolean(fulcrumUrl),
-connected: false,
+      connected: false,
-url: fulcrumUrl,
+      url: fulcrumUrl,
-serverVersion: null,
+      serverVersion: null,
-blockchainHeight: null,
+      blockchainHeight: null,
-};
+    };
-}
+  }
 
-const headers = await queryFulcrum(
+  const headers = await queryFulcrum(
-fulcrumUrl,
+    fulcrumUrl,
-'blockchain.headers.subscribe',
+    'blockchain.headers.subscribe',
-[],
+    [],
-);
+  );
 
-return {
+  return {
-configured: Boolean(fulcrumUrl),
+    configured: Boolean(fulcrumUrl),
-connected: true,
+    connected: true,
-url: fulcrumUrl,
+    url: fulcrumUrl,
-serverVersion: version.result,
+    serverVersion: version.result,
-blockchainHeight:
+    blockchainHeight:
-headers.ok && headers.result
+      headers.ok && headers.result
-? headers.result.height ?? null
+        ? headers.result.height ?? null
-: null,
+        : null,
-};
+  };
 }
 
 async function getStatus() {
-const fulcrumUrl = process.env.MUNIN_FULCRUM_URL || null;
+  const fulcrumUrl = process.env.MUNIN_FULCRUM_URL || null;
-const fulcrum = await getFulcrumStatus(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, {
-  res.writeHead(200, {
+        'Content-Type': 'application/json',
-    '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}`);
-});
+});