the-invisible-billion-cli 1.0.0

package/src/daemon/network.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const os = require('os');//it provides information about system
+
+//returns current machine ipv4 address if not present in network returns null
+function getCurrentIP() {
+    const ifaces = os.networkInterfaces(); // our machine has different network interfaces like wlan,eth,virtualbox net
+    //this networkInterfaces function gives all netowrk interface and their addresses
+
+    //something like this
+
+    /**
+     * {
+  lo: [
+    { address: "127.0.0.1", family: "IPv4", internal: true }
+  ],
+  eth0: [
+    { address: "192.168.1.12", family: "IPv4", internal: false }
+  ],
+  wlan0: [
+    { address: "192.168.1.15", family: "IPv4", internal: false }
+  ]
+}
+     */
+    for (const name of Object.keys(ifaces)) {
+        for (const iface of ifaces[name]) {
+            if (iface.family === 'IPv4' && !iface.internal) {
+                //as we know eth0 and wlan0 are external so we have to make this condition true
+                //also lo(localhost) we cant take this, because own cannot connect with own
+                return iface.address;
+            }
+        }
+    }
+    return null;
+}
+
+/**
+ * Start polling for network changes every 30 seconds.
+ * Returns a function that stops the watcher when called.
+ */
+
+// The function does not define onChangeCallback itself.
+//It expects the caller to pass a function when calling startNetworkWatcher
+function startNetworkWatcher(onChangeCallback) {
+    let currentIP = getCurrentIP();
+    console.log(`[network] Current IP: ${currentIP || 'none'}`);
+
+    const interval = setInterval(() => {
+        const newIP = getCurrentIP();
+        if (newIP !== currentIP) {
+            const previousIP = currentIP;
+            currentIP = newIP;
+            console.log(`[network] Network change detected: ${previousIP} → ${newIP}`);
+            try {
+                /**
+                 * Function that accepts a callback
+    function greet(callback) {
+            console.log("Hello");
+                callback();
+}
+
+Now call it:
+
+greet(() => {
+    console.log("Callback executed");
+});
+
+Output:
+
+Hello
+Callback executed
+                 */
+                onChangeCallback(newIP, previousIP);
+            } catch (err) {
+                console.error('[network] onChangeCallback error:', err.message);
+            }
+        }
+    }, 15_000);
+
+    // Return a stop function
+    return () => clearInterval(interval);
+}
+
+module.exports = { getCurrentIP, startNetworkWatcher };

package/src/daemon/tcp.js

@@ -0,0 +1,200 @@
+'use strict';
+
+
+const net = require('net');
+
+const TCP_PORT = 41235;
+const CONNECT_TIMEOUT_MS = 2000; //wait 2second for peers to respond to TCP connection attempts
+const SEND_TIMEOUT_MS = 8000;   
+
+let _server = null;
+let _identity = null;
+let _privateKey = null;
+let _onMessage = null;
+
+
+function startTCP({ identity, privateKey, onMessage }) {
+    if (_server) return () => stopTCP();
+
+    _identity = identity;
+    _privateKey = privateKey;
+    _onMessage = onMessage;
+
+    _server = net.createServer((socket) => {
+        handleIncomingConnection(socket); //creates tcp server and listens for incoming connections, this function will read message frame, parse JSON, process message
+    });
+
+    _server.listen(TCP_PORT, '0.0.0.0', () => { //0.0.0.0 means listen on all interfaces 
+        console.log(`[tcp] Server listening on port ${TCP_PORT}`); // means node is ready to receive TCP messages from peers. Peers will connect to this port to send messages directly to this node.
+    });
+
+    _server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            console.error(`[tcp] Port ${TCP_PORT} is already in use. Another daemon may be running.`);
+        } else {
+            console.error('[tcp] Server error:', err.message);
+        }
+    });
+
+    return () => stopTCP();
+}
+
+/**
+ * Handle an incoming TCP connection from a peer.
+ * Uses newline-delimited JSON framing.
+ */
+
+//Shivam (192.168.1.12) ───TCP───> Amrit (192.168.1.25)
+function handleIncomingConnection(socket) {
+    let buffer = '';
+    const remoteIP = socket.remoteAddress; //get the IP address of the peer that connected to us. This is used for logging and to pass to the onMessage handler so it knows where the message came from.
+
+    socket.on('data', (chunk) => { //this runs whenever we receive data from the peer over TCP. chunk = <Buffer ...>
+        buffer += chunk.toString('utf8'); //convert the chunk to a string and append it to the buffer. We use a buffer because TCP can split messages into multiple chunks, so we need to accumulate them until we get a full message (delimited by newline).
+        const lines = buffer.split('\n');
+        buffer = lines.pop(); // keep trailing incomplete chunk, Because the last piece might be incomplete.
+
+        for (const line of lines) {
+            if (!line.trim()) continue;
+            let frame;
+            try {
+                frame = JSON.parse(line); //converts JSON string to a JavaScript object. If the peer sent invalid JSON, this will throw an error, which we catch and respond with an ACK indicating the error.
+            } catch {
+                socket.write(JSON.stringify({ type: 'ack', ok: false, error: 'Invalid JSON' }) + '\n');//if parsing fails, we send an ACK back to the peer indicating that the frame was malformed. We then skip processing this frame and wait for the next one.
+                continue;
+            }
+            processFrame(frame, socket, remoteIP);
+        }
+    });
+
+    socket.on('error', () => { }); // peer disconnect — ignore
+    socket.on('close', () => { });
+
+    // Auto-close after 30 s of inactivity
+    socket.setTimeout(30_000, () => socket.destroy());
+}
+
+ // Process frames received from peers. This is where we handle both "deliver" frames (messages addressed to us) and "relay" frames (messages that we need to store and forward later).
+function processFrame(frame, socket, remoteIP) {
+    //frame: { type: 'deliver' | 'relay', message: { id, from_identity, destination, ... } } --->parsed JSON from perr,
+    //socket: the TCP socket connected to the peer that sent this frame. We use this to send ACKs back to the peer after processing the frame.
+    //remoteIP: the IP address of the peer that sent this frame. This is used for logging and is also passed to the onMessage handler so it knows where the message came from.
+    const { type, message } = frame;
+
+    if (!message || !message.id) {
+        socket.write(JSON.stringify({ type: 'ack', ok: false, error: 'Malformed frame' }) + '\n');
+        return;
+    }
+
+    if (type === 'deliver') {
+        // Message is addressed to us — call the delivery handler
+        console.log(`[tcp] Incoming message id=${message.id} from=${message.from_identity || '?'} via ${remoteIP}`);
+        try {
+            if (_onMessage) _onMessage(message, remoteIP);
+            socket.write(JSON.stringify({ type: 'ack', messageId: message.id, ok: true }) + '\n');
+        } catch (err) {
+            console.error('[tcp] onMessage handler error:', err.message);
+            socket.write(JSON.stringify({ type: 'ack', messageId: message.id, ok: false, error: err.message }) + '\n');
+        }
+    } else if (type === 'relay') {
+        // Message is for someone else — store it
+        console.log(`[tcp] Relay message id=${message.id} → ${message.destination} via ${remoteIP}`);
+        try {
+            if (_onMessage) _onMessage(message, remoteIP, true /* isRelay */);
+            socket.write(JSON.stringify({ type: 'ack', messageId: message.id, ok: true }) + '\n');
+        } catch (err) {
+            socket.write(JSON.stringify({ type: 'ack', messageId: message.id, ok: false, error: err.message }) + '\n');
+        }
+    } else {
+        socket.write(JSON.stringify({ type: 'ack', ok: false, error: `Unknown frame type: ${type}` }) + '\n');
+    }
+}
+
+function stopTCP() {
+    if (_server) {
+        _server.close();
+        _server = null;
+        console.log('[tcp] Stopped.');
+    }
+}
+
+/**
+ * Send a message to a peer over TCP.
+ * Waits for ACK before resolving.
+ */
+function sendMessage(peerIP, frameType, message) {
+    //connect → send frame → wait for ACK → resolve/reject
+    return new Promise((resolve, reject) => {
+        const socket = new net.Socket();
+        let buffer = '';
+        let settled = false; //A Promise must only resolve/reject once.
+
+        /*
+        *8 seconds passed
+no response
+abort connection
+         */
+        const timeout = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                socket.destroy();
+                reject(new Error(`TCP send to ${peerIP} timed out`));
+            }
+        }, SEND_TIMEOUT_MS);
+
+        socket.setTimeout(CONNECT_TIMEOUT_MS);
+        socket.on('timeout', () => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timeout);
+                socket.destroy();
+                reject(new Error(`TCP connect to ${peerIP}:${TCP_PORT} timed out`));
+            }
+        });
+
+        socket.connect(TCP_PORT, peerIP, () => {
+            // Connection established — send the frame
+            const frame = JSON.stringify({ type: frameType, message }) + '\n';
+            socket.write(frame);
+        });
+
+        socket.on('data', (chunk) => {
+            buffer += chunk.toString('utf8');
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+
+            for (const line of lines) {
+                if (!line.trim()) continue;
+                try {
+                    const ack = JSON.parse(line);
+                    if (!settled && ack.type === 'ack') {
+                        settled = true;
+                        clearTimeout(timeout);
+                        socket.destroy();
+                        resolve({ ok: ack.ok, messageId: ack.messageId });
+                    }
+                } catch {
+                    // wait for more data
+                }
+            }
+        });
+
+        socket.on('error', (err) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timeout);
+                reject(err);
+            }
+        });
+
+        socket.on('close', () => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timeout);
+                reject(new Error(`Connection to ${peerIP} closed before ACK`));
+            }
+        });
+    });
+}
+
+module.exports = { startTCP, stopTCP, sendMessage, TCP_PORT };

package/src/daemon/udp.js

@@ -0,0 +1,282 @@
+'use strict';
+
+/**
+ * UDP is used for:
+ *   1. Peer discovery (broadcast)
+ *   2. Message delivery fallback when TCP is blocked by firewall
+ *
+ * Broadcast address: computed from interface IP + netmask for subnet accuracy.
+ * Falls back to 255.255.255.255 if no usable interface found.
+ */
+
+const dgram = require('dgram');
+const os = require('os');
+
+const UDP_PORT = 41234;
+const BROADCAST_INTERVAL_MS = 15_000; // brodcast every 15 seconds as heartbeat, to notify peers of our presence and IP changes
+const ANNOUNCE_TYPE = 'ib-announce'; // announces our presence and public key to peers on the LAN, wether new or existing peers, so they can connect to us via TCP or UDP direct message delivery
+const GOODBYE_TYPE = 'ib-goodbye'; //send when we are leaving, so peers can immediately know we are leaving and remove us from their peer list, instead of waiting for a timeout to detect our absence
+const DELIVER_TYPE = 'ib-deliver'; //used for direct message delivery via UDP unicast, when TCP is blocked by firewall, so we can still deliver messages to peers on the same LAN without relying on TCP, but with best effort delivery (no retries, no ordering guarantees)
+const RELAY_TYPE = 'ib-relay'; //used for epidemic routing
+
+// Max safe UDP payload size, because headers also need space 
+const MAX_UDP_PAYLOAD = 60000;
+
+let _socket = null; //handles UDP communication (broadcasts + direct messages)
+let _broadcastInterval = null; //handles periodic broadcast timer
+let _myIdentity = null; //our identity string e.g. shivam@a3f2, included in broadcasts so peers know who we are
+let _myPublicKey = null; //our RSA public key PEM, included in broadcasts so peers can encrypt messages to us for direct UDP delivery when TCP is blocked
+
+
+function computeBroadcast(ip, netmask) {
+    const ipParts = ip.split('.').map(Number);
+    const maskParts = netmask.split('.').map(Number);
+    const broadcast = ipParts.map((b, i) => (b | (~maskParts[i] & 0xff))); //xor of ip and subnet mask
+    return broadcast.join('.');
+}
+
+/**
+ * Get all LAN broadcast addresses for every non-loopback IPv4 interface.
+ * Falls back to ['255.255.255.255'] if none found.
+ */
+function getBroadcastAddresses() {
+    const addrs = [];
+    const ifaces = os.networkInterfaces();
+    for (const ifaceList of Object.values(ifaces)) {
+        for (const iface of ifaceList) {
+            if (iface.family === 'IPv4' && !iface.internal && iface.netmask) {
+                addrs.push(computeBroadcast(iface.address, iface.netmask));
+            }
+        }
+    }
+    return addrs.length > 0 ? addrs : ['255.255.255.255'];
+}
+
+/**
+ * Send a UDP broadcast announce on all LAN interfaces.
+ * Goal: Tell every device on the LAN:
+ * I am an IB node. Here is my identity and public key.
+ */
+function sendBroadcast() {
+    if (!_socket || !_myIdentity || !_myPublicKey) return; //all are compulsory for broadcast
+
+    //first this creates JSON, then converts it into binary data UDP sends bytes, not objects
+    const packet = Buffer.from(JSON.stringify({
+        type: ANNOUNCE_TYPE,
+        identity: _myIdentity,
+        publicKey: _myPublicKey,
+    }));
+
+    for (const addr of getBroadcastAddresses()) {
+        //packet is the data we want to send,
+        //  0 is the offset in the buffer, 
+        // packet.length is the number of bytes to send, 
+        // UDP_PORT is the destination port, 
+        // addr is the destination IP address,the callback handles any errors that occur during sending
+        _socket.send(packet, 0, packet.length, UDP_PORT, addr, (err) => {
+            if (err) console.error(`[udp] Broadcast to ${addr} failed:`, err.message);
+        });
+    }
+}
+
+/**
+ * Send a goodbye broadcast so peers immediately know we are leaving.
+ */
+function sendGoodbye() {
+    if (!_socket || !_myIdentity) return;
+
+    const packet = Buffer.from(JSON.stringify({
+        type: GOODBYE_TYPE,
+        identity: _myIdentity,
+    }));
+
+    for (const addr of getBroadcastAddresses()) {
+        _socket.send(packet, 0, packet.length, UDP_PORT, addr, (err) => {
+            if (err) console.error(`[udp] Goodbye broadcast to ${addr} failed:`, err.message);
+        });
+    }
+}
+
+/**
+ * Send a message directly to a peer via UDP unicast.
+ * This is the fallback when TCP is blocked by firewall.
+ *
+ * @param {string} peerIP - Target peer's IP address
+ * @param {'deliver'|'relay'} frameType - 'deliver' for direct, 'relay' for epidemic
+ * @param {object} message - Full message object
+ * @returns {Promise<{ok: boolean}>}
+ */
+function sendDirectMessage(peerIP, frameType, message) {
+    return new Promise((resolve, reject) => {
+        if (!_socket) {
+            reject(new Error('UDP socket not initialized'));
+            return;
+        }
+
+        const udpType = frameType === 'deliver' ? DELIVER_TYPE : RELAY_TYPE;
+        const data = JSON.stringify({ type: udpType, message });
+
+        if (data.length > MAX_UDP_PAYLOAD) {
+            reject(new Error(`Message too large for UDP delivery (${data.length} bytes > ${MAX_UDP_PAYLOAD})`));
+            return;
+        }
+
+        const packet = Buffer.from(data);
+        _socket.send(packet, 0, packet.length, UDP_PORT, peerIP, (err) => {
+            if (err) {
+                console.error(`[udp] Direct send to ${peerIP} failed:`, err.message);
+                reject(err);
+            } else {
+                console.log(`[udp] Direct ${frameType} sent to ${peerIP} (${packet.length} bytes)`);
+                resolve({ ok: true });
+            }
+        });
+    });
+}
+
+/**
+ * Basically it does 3 main jobs:
+ * 
+    Start a UDP socket and listen for packets
+
+    Discover peers using broadcast
+
+    Receive messages from other peers
+ *
+ * @param {object} opts
+ * @param {string}   opts.identity       - Our identity string e.g. shivam@a3f2
+ * @param {string}   opts.publicKey      - Our RSA public key PEM
+ * @param {function} opts.onPeer         - Called with (identity, publicKeyPem, remoteIP) on discovery
+ * @param {function} [opts.onPeerGoodbye] - Called with (identity) when a peer sends goodbye
+ * @param {function} [opts.onMessage]    - Called with (message, remoteIP, isRelay) for UDP-delivered messages
+ * @returns {function} stop — call to shut down UDP
+ */
+function startUDP({ identity, publicKey, onPeer, onPeerGoodbye, onMessage }) {
+    if (_socket) return () => stopUDP(); //if connection already exists, return the stop function without creating a new socket
+
+    _myIdentity = identity;
+    _myPublicKey = publicKey;
+
+    //opens a UDP socket for IPv4 with address reuse enabled (allows multiple processes to bind to the same port, useful for multiple IB instances on the same LAN)
+    _socket = dgram.createSocket({ type: 'udp4', reuseAddr: true });
+
+    _socket.on('error', (err) => {
+        console.error('[udp] Socket error:', err.message);
+    });
+
+    //this runs whenever a UDP packet is recieved
+    _socket.on('message', (msg, rinfo) => {
+        let packet;
+        try {
+            packet = JSON.parse(msg.toString('utf8'));
+        } catch {
+            return; // ignore malformed packets
+        }
+
+        //goodbye
+        if (packet.type === GOODBYE_TYPE && packet.identity) {
+            if (packet.identity === _myIdentity) return; // ignore our own
+            console.log(`[udp] Peer goodbye: ${packet.identity}`);
+            try {
+                if (onPeerGoodbye) onPeerGoodbye(packet.identity);
+            } catch (err) {
+                console.error('[udp] onPeerGoodbye handler error:', err.message);
+            }
+            return;
+        }
+
+        //direct message delivery via UDP 
+        if (packet.type === DELIVER_TYPE && packet.message) {
+            console.log(`[udp] Received direct message id=${packet.message.id} from ${rinfo.address}`);
+            try {
+                if (onMessage) onMessage(packet.message, rinfo.address, false); //value false for direct delivery, so onMessage can distinguish between direct and relay messages if needed
+            } catch (err) {
+                console.error('[udp] onMessage (deliver) error:', err.message);
+            }
+            return;
+        }
+
+        // relay message via UDP for epidemic routing (used when destination peer is not currently on the network, so we relay to other peers in the hope that one of them will eventually meet the destination peer and deliver it)
+        if (packet.type === RELAY_TYPE && packet.message) {
+            console.log(`[udp] Received relay message id=${packet.message.id} from ${rinfo.address}`);
+            try {
+                if (onMessage) onMessage(packet.message, rinfo.address, true);
+            } catch (err) {
+                console.error('[udp] onMessage (relay) error:', err.message);
+            }
+            return;
+        }
+
+        // Handle announce 
+        if (packet.type !== ANNOUNCE_TYPE) return;
+        if (!packet.identity || !packet.publicKey) return;
+
+        // Ignore our own broadcasts
+        if (packet.identity === _myIdentity) return;
+
+        console.log(`[udp] Peer discovered: ${packet.identity} at ${rinfo.address}`);
+        try {
+            onPeer(packet.identity, packet.publicKey, rinfo.address);
+        } catch (err) {
+            console.error('[udp] onPeer handler error:', err.message);
+        }
+    });
+
+    _socket.bind(UDP_PORT, () => {
+        _socket.setBroadcast(true);
+        console.log(`[udp] Listening on port ${UDP_PORT}`);
+
+
+        // Broadcast immediately so peers on the LAN discover us fast
+        sendBroadcast();
+
+        // Re-broadcast every 15 s, setInterval will automatically call sendBroadcast every 15 seconds
+        _broadcastInterval = setInterval(sendBroadcast, BROADCAST_INTERVAL_MS);
+        /**
+         * if nothing else is running
+            allow program to exit
+         */
+        _broadcastInterval.unref();
+
+    });
+
+    _socket.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            console.error(`[udp] Port ${UDP_PORT} already in use.`);
+        }
+    });
+
+    return () => stopUDP();
+}
+
+function stopUDP() {
+    if (_broadcastInterval) {
+        clearInterval(_broadcastInterval);
+        _broadcastInterval = null;
+    }
+    if (_socket) {
+        _socket.close();
+        _socket = null;
+    }
+    console.log('[udp] Stopped.');
+}
+
+ // Broadcast a goodbye (exit ke waqt call karna).
+function broadcastGoodbye() {
+    sendGoodbye();
+}
+
+/**
+ * Broadcast our identity immediately on the current network.
+ * Called when a network change is detected.
+ */
+function broadcastNow() {
+    sendBroadcast();
+}
+
+/**
+ * Get the current UDP socket
+ */
+function getSocket() { return _socket; }
+
+module.exports = { startUDP, stopUDP, broadcastNow, broadcastGoodbye, sendDirectMessage, getSocket, UDP_PORT };

package/src/db/cleanup.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { openDb } = require('./index');
+
+/**
+ * Delete all messages that have expired (ttl < now) and are not delivered.
+ * Delivered messages are kept as a record so senders can still check
+ * ib status <id>. They are cleaned up after 30 days.
+ * Also clean up peers that haven't been seen in 1 hour, to prevent stale peer entries.
+ */
+function cleanExpired() {
+    const db = openDb();
+    const now = Date.now();
+    const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1000;
+
+    // Delete expired undelivered/intransit messages
+    const r1 = db.prepare(`
+    DELETE FROM messages
+    WHERE ttl < ? AND status != 'delivered'
+  `).run(now);
+
+    //clean up old delivered messages
+    const r2 = db.prepare(`
+    DELETE FROM messages
+    WHERE status = 'delivered' AND created_at < ?
+  `).run(thirtyDaysAgo);
+
+    // Clean up peers not seen in 1 hour (with 15s heartbeats, a live peer would have re-announced many times)
+    const oneHourAgo = now - 60 * 60 * 1000;
+    db.prepare(`DELETE FROM peers WHERE last_seen < ?`).run(oneHourAgo);
+
+    const deleted = r1.changes + r2.changes;
+    if (deleted > 0) {
+        console.log(`[cleanup] Removed ${deleted} expired message(s) from storage.`);
+    }
+    return deleted;
+}
+
+module.exports = { cleanExpired };

package/src/db/index.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const path = require('path'); //help safely create path files
+const fs = require('fs'); //help read and write files, also check if file exists
+const Database = require('better-sqlite3'); //importing SQLite from better-sqlite3
+const { IB_DIR } = require('../identity/index'); //main folder file path
+
+const DB_PATH = path.join(IB_DIR, 'ib.db');
+
+let _db = null; //stores database connection, so we dont need to open the database multiple times, 
+
+//open or create the database and initialize the schema,uses cache instance also
+function openDb() {
+  if (_db) return _db;
+
+  if (!fs.existsSync(IB_DIR)) {
+    fs.mkdirSync(IB_DIR, { recursive: true });
+  }
+
+  _db = new Database(DB_PATH); //if file exists, open ib.db
+  //else create ib.db
+
+  // Enable WAL mode for better concurrent read performance
+  _db.pragma('journal_mode = WAL');
+  _db.pragma('foreign_keys = ON');
+
+  // Main messages table
+  _db.exec(`
+    CREATE TABLE IF NOT EXISTS messages (
+      id           TEXT PRIMARY KEY,
+      from_identity TEXT NOT NULL,
+      destination  TEXT NOT NULL,
+      payload      TEXT NOT NULL,      -- JSON-encoded encrypted blob
+      status       TEXT NOT NULL DEFAULT 'undelivered',
+                                       -- undelivered | intransit | delivered
+      hop_count    INTEGER NOT NULL DEFAULT 0,
+      ttl          INTEGER NOT NULL,   -- Unix epoch ms — message dies after this
+      created_at   INTEGER NOT NULL
+    );
+  `);
+
+  // Known peer public keys
+  _db.exec(`
+    CREATE TABLE IF NOT EXISTS peers (
+      identity   TEXT PRIMARY KEY,     -- e.g. raj@a3f2
+      public_key TEXT NOT NULL,        -- RSA PEM
+      ip         TEXT,                 -- last known IP address
+      last_seen  INTEGER NOT NULL      -- Unix epoch ms
+    );
+  `);
+
+  try {
+    _db.exec(`ALTER TABLE peers ADD COLUMN ip TEXT`);
+  } catch (_) {
+     // column already exists, leave it
+     //for safety purpose
+
+  return _db;
+}
+}
+
+/**
+ * Close the database connection.
+ * Should be called on daemon shutdown.
+ */
+function closeDb() {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}
+
+
+module.exports = { openDb, closeDb, DB_PATH };