Update server/status.js

Fix status API server syntax

server/status.js

@@ -5,66 +5,65 @@ 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,
+        ok: false,
-result: null,
+        result: null,
-});
+      });
-return;
+      return;
-}
+    }
 
-```
+    let parsed;
-let parsed;
 
-try {
+    try {
       parsed = new URL(fulcrumUrl);
-} catch {
+    } catch {
       resolve({
         ok: false,
         result: null,
       });
       return;
-}
+    }
 
-if (parsed.protocol !== 'tcp:') {
+    if (parsed.protocol !== 'tcp:') {
       resolve({
         ok: false,
         result: null,
       });
       return;
-}
+    }
 
-const host = parsed.hostname;
+    const host = parsed.hostname;
-const fulcrumPort = Number(parsed.port);
+    const fulcrumPort = Number(parsed.port);
 
-if (!host || !fulcrumPort) {
+    if (!host || !fulcrumPort) {
       resolve({
         ok: false,
         result: null,
       });
       return;
-}
+    }
 
-const socket = net.createConnection({
+    const socket = net.createConnection({
       host,
       port: fulcrumPort,
-});
+    });
 
-let response = '';
+    let response = '';
-let settled = false;
+    let settled = false;
 
-const finish = (value) => {
+    const finish = (value) => {
       if (settled) return;
       settled = true;
 
       socket.destroy();
       resolve(value);
-};
+    };
 
-socket.setTimeout(fulcrumTimeoutMs);
+    socket.setTimeout(fulcrumTimeoutMs);
 
-socket.on('connect', () => {
+    socket.on('connect', () => {
       socket.write(
         JSON.stringify({
           jsonrpc: '2.0',
@@ -73,9 +72,9 @@ socket.on('connect', () => {
           params,
         }) + '\n',
       );
-});
+    });
 
-socket.on('data', (data) => {
+    socket.on('data', (data) => {
       response += data.toString();
 
       const lines = response.split('\n');
@@ -107,94 +106,91 @@ socket.on('data', (data) => {
           return;
         }
       }
-});
+    });
 
-socket.on('timeout', () => {
+    socket.on('timeout', () => {
       finish({
         ok: false,
         result: null,
       });
-});
+    });
 
-socket.on('error', () => {
+    socket.on('error', () => {
       finish({
         ok: false,
         result: null,
       });
-});
+    });
 
-socket.on('close', () => {
+    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, {
         'Content-Type': 'application/json',
       });
 
       res.end(JSON.stringify(status));
-} catch (error) {
+    } catch (error) {
       console.error('Failed to get service status:', error);
 
       res.writeHead(500, {
@@ -207,17 +203,15 @@ const status = await getStatus();
           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}`);
 });