the-invisible-billion-cli 1.0.0

package/src/cli/commands/send.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const crypto = require('crypto');
+const { runCommand, sendCommand } = require('../ipc');
+const { encrypt } = require('../../crypto/encrypt');
+const { loadIdentity } = require('../../identity/index');
+const { loadOrCreateKeypair } = require('../../crypto/keys');
+
+/**
+ * ib send <destination> "<message>"
+ *
+ *  1. Validate identity format
+ *  2. Ask daemon for recipient's public key via get-peer-key IPC
+ *  3a. Key found → encrypt with hybrid AES+RSA, send pre-encrypted payload
+ *  3b. Key not found → store as pending (daemon will encrypt when peer discovered)
+ *  4. Daemon stores first, then attempts live TCP delivery immediately
+ */
+async function sendCommand_(destination, messageText) {
+    if (!destination || !messageText) {
+        console.error('Usage: ib send <identity> "<message>"');
+        console.error('Example: ib send raj@a3f2 "bhai notes bhej"');
+        process.exit(1);
+    }
+
+    // Validate identity format: username@xxxx (4 alphanumeric chars)
+    if (!/^[a-z0-9_-]+@[a-z0-9]{4}$/.test(destination)) {
+        console.error(`❌ Invalid identity format: "${destination}"`);
+        console.error('   Expected: username@xxxx  (e.g. raj@a3f2)');
+        process.exit(1);
+    }
+
+    // Load sender identity
+    let senderIdentity;
+    try {
+        senderIdentity = loadIdentity().identity;
+    } catch {
+        console.error('❌ Not initialised. Run: ib start');
+        process.exit(1);
+    }
+
+    // ── 1. Try to get recipient public key from daemon's peer table ──────────
+    let encryptedPayload;
+    let recipientPublicKey = null;
+
+    // Sending to ourselves? Use our own public key.
+    if (destination === senderIdentity) {
+        const { publicKey } = loadOrCreateKeypair();
+        recipientPublicKey = publicKey;
+    } else {
+        // Ask the daemon (it has the peer table from UDP discovery)
+        try {
+            const res = await sendCommand({ type: 'get-peer-key', identity: destination });
+            if (res.ok && res.publicKey) {
+                recipientPublicKey = res.publicKey;
+            }
+        } catch {
+            // Daemon may be unreachable — handled below
+            console.error('❌ Daemon is not running. Start it with: ib start');
+            process.exit(1);
+        }
+    }
+
+    // ── 2. Encrypt the message ───────────────────────────────────────────────
+    if (recipientPublicKey) {
+        try {
+            const blob = encrypt(messageText, recipientPublicKey);
+            encryptedPayload = JSON.stringify(blob);
+            console.log(`🔐 Message encrypted for ${destination}`);
+        } catch (err) {
+            console.error('❌ Encryption failed:', err.message);
+            process.exit(1);
+        }
+    } else {
+        // Peer's public key not yet known — store with pending flag
+        // Daemon will encrypt + re-deliver once it discovers the peer via UDP
+        console.log(`⚠️  ${destination} not yet on network — storing for epidemic delivery.`);
+        encryptedPayload = JSON.stringify({
+            __pending_encryption: true,
+            __phase1_plaintext: messageText,
+        });
+    }
+
+    // ── 3. Send to daemon (store-first, then live delivery attempt) ──────────
+    const messageId = crypto.randomUUID();
+    const ttl = Date.now() + 7 * 24 * 60 * 60 * 1000; // 7 days
+
+    await runCommand(
+        {
+            type: 'send',
+            id: messageId,
+            from_identity: senderIdentity,
+            destination,
+            payload: encryptedPayload,
+            ttl,
+        },
+        (res) => {
+            if (!res.ok) {
+                console.error('❌ Failed to queue message:', res.error);
+                return;
+            }
+
+            const isDelivered = res.status === 'delivered';
+            console.log(`\n📤 Message ${isDelivered ? 'delivered!' : 'queued!'}`);
+            console.log(`   To:        ${destination}`);
+            console.log(`   Message:   "${messageText}"`);
+            console.log(`   ID:        ${messageId}`);
+            console.log(`   Status:    ${isDelivered ? '✅ Delivered' : '⏳ Undelivered (will deliver when peer connects)'}`);
+            console.log(`\n   Track it:  ib status ${messageId}\n`);
+        }
+    );
+}
+
+module.exports = { sendCommand: sendCommand_ };

package/src/cli/commands/start.js

@@ -0,0 +1,126 @@
+'use strict';
+
+/**
+ * ib start — Start the background daemon.
+ *
+ * Handles:
+ *  1. First-time identity + keypair setup (interactive)
+ *  2. Crash recovery (stale PID file detection)
+ *  3. Idempotent: if daemon already running, says so and exits
+ *  4. Spawns daemon detached with windowsHide: true
+ *  5. Waits up to 3 s for daemon IPC to become ready, then confirms
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+const { loadOrCreate } = require('../../identity/index');
+const { loadOrCreateKeypair } = require('../../crypto/keys');
+const { isDaemonRunning } = require('../ipc');
+
+const IB_DIR = path.join(os.homedir(), '.ib');
+const PID_FILE = path.join(IB_DIR, 'daemon.pid');
+const DAEMON_ENTRY = path.resolve(__dirname, '../../daemon/index.js');
+
+/**
+ * Check if a process with the given PID is alive.
+ * Cross-platform: signal 0 on unix, tasklist on Windows.
+ */
+function isProcessAlive(pid) {
+    try {
+        // kill(pid, 0) does not send a signal — just checks existence
+        process.kill(pid, 0);
+        return true;
+    } catch (err) {
+        // EPERM means process exists but we can't signal it — still alive
+        return err.code === 'EPERM';
+    }
+}
+
+/**
+ * Remove a stale PID file if the process is not running.
+ * Returns true if a stale PID was cleaned up.
+ */
+function cleanStalePid() {
+    if (!fs.existsSync(PID_FILE)) return false;
+
+    const raw = fs.readFileSync(PID_FILE, 'utf8').trim();
+    const pid = parseInt(raw, 10);
+
+    if (!pid || isNaN(pid)) {
+        fs.unlinkSync(PID_FILE);
+        return true;
+    }
+
+    if (!isProcessAlive(pid)) {
+        console.log(`⚠️  Found stale PID file (PID ${pid} is not running). Cleaning up...`);
+        fs.unlinkSync(PID_FILE);
+        return true;
+    }
+
+    return false; // Process is alive — daemon is running
+}
+
+/**
+ * Wait for IPC to become responsive. Polls every 200ms up to maxMs.
+ */
+async function waitForDaemon(maxMs = 3000) {
+    const start = Date.now();
+    while (Date.now() - start < maxMs) {
+        if (await isDaemonRunning()) return true;
+        await new Promise((r) => setTimeout(r, 200));
+    }
+    return false;
+}
+
+async function startCommand() {
+    // ── 1. First-time setup (identity + keypair) ───────────────────────────────
+    //    Must happen BEFORE daemon spawn because daemon reads identity from disk.
+    const identity = await loadOrCreate();
+    loadOrCreateKeypair(); // generate if not exists, silent if already there
+
+    // ── 2. Crash recovery ──────────────────────────────────────────────────────
+    const wasStale = cleanStalePid();
+
+    // ── 3. Check if already running ───────────────────────────────────────────
+    if (!wasStale && fs.existsSync(PID_FILE)) {
+        // PID file exists and process is alive → already running
+        if (await isDaemonRunning()) {
+            console.log(`✅ The Invisible Billion daemon is already running as ${identity.identity}`);
+            return;
+        }
+        // PID alive but IPC not responding — force clean and restart
+        console.log('⚠️  Daemon PID exists but IPC is unresponsive. Force-restarting...');
+        fs.unlinkSync(PID_FILE);
+    }
+
+    // ── 4. Spawn daemon ───────────────────────────────────────────────────────
+    const child = spawn(process.execPath, [DAEMON_ENTRY], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,   // Critical: no console window on Windows
+    });
+    child.unref(); // Allow CLI to exit immediately
+
+    console.log(`🌍 Starting The Invisible Billion daemon... (PID will be ${child.pid})`);
+
+    // ── 5. Wait for IPC ready ─────────────────────────────────────────────────
+    const ready = await waitForDaemon(4000);
+
+    if (ready) {
+        console.log(`\n✅ The Invisible Billion daemon is running!`);
+        console.log(`   Your identity: ${identity.identity}`);
+        console.log(`   Log: ~/.ib/daemon.log`);
+        console.log(`   Stop: ib stop\n`);
+    } else {
+        console.error(
+            '\n⚠️  Daemon spawned but IPC is not responding yet.\n' +
+            '   It may still be starting up — check ~/.ib/daemon.log for details.'
+        );
+    }
+}
+
+module.exports = { startCommand };

package/src/cli/commands/status.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { runCommand } = require('../ipc');
+
+async function statusCommand(messageId) {
+    if (!messageId) {
+        console.error('Usage: ib status <messageId>');
+        process.exit(1);
+    }
+
+    await runCommand({ type: 'status', messageId }, (res) => {
+        if (!res.ok) {
+            console.error(`❌ ${res.error}`);
+            return;
+        }
+
+        const icons = {
+            undelivered: '🕐',
+            intransit: '🚀',
+            delivered: '✅',
+        };
+
+        const labels = {
+            undelivered: 'Undelivered  (waiting for a carrier to pass through)',
+            intransit: 'In Transit   (virus is spreading through the network)',
+            delivered: 'Delivered    (recipient received and decrypted)',
+        };
+
+        const s = res.status;
+        const created = new Date(res.created_at).toLocaleString();
+        const expires = new Date(res.ttl).toLocaleString();
+
+        console.log(`\n${icons[s] || '❓'} Message Status`);
+        console.log(`   ID:          ${res.messageId}`);
+        console.log(`   To:          ${res.destination}`);
+        console.log(`   Status:      ${labels[s] || s}`);
+        console.log(`   Hops:        ${res.hop_count}`);
+        console.log(`   Created:     ${created}`);
+        console.log(`   Expires:     ${expires}\n`);
+    });
+}
+
+module.exports = { statusCommand };

package/src/cli/commands/stop.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { runCommand } = require('../ipc');
+
+async function stopCommand() {
+    await runCommand({ type: 'stop' }, (res) => {
+        if (res.ok) {
+            console.log('⛔ The Invisible Billion daemon stopped.');
+        } else {
+            console.error('❌ Stop failed:', res.error);
+        }
+    });
+}
+
+module.exports = { stopCommand };

package/src/cli/commands/sync.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const { runCommand } = require('../ipc');
+
+async function syncCommand() {
+    console.log('🔄 Triggering sync with all known peers...');
+    await runCommand({ type: 'sync' }, (res) => {
+        if (!res.ok) {
+            console.error('❌ Sync failed:', res.error);
+            return;
+        }
+
+        console.log(`\n🔄 Sync complete!\n`);
+        console.log(`   Pending messages:   ${res.pending}`);
+        console.log(`   Deliverable now:    ${res.deliverable} (peers with known IPs)`);
+        console.log(`   Known peers:        ${res.peers}`);
+
+        if (res.pending > 0 && res.deliverable === 0) {
+            console.log(`\n   ⏳ Messages are queued but destination peers are not`);
+            console.log(`      yet on this network. They will deliver automatically`);
+            console.log(`      when those peers appear. (This is Epidemic Routing)\n`);
+        } else if (res.deliverable > 0) {
+            console.log(`\n   📤 Delivery in progress — check status with:`);
+            console.log(`      ib status <messageId>\n`);
+        } else {
+            console.log(`\n   ✅ No pending messages.\n`);
+        }
+    });
+}
+
+module.exports = { syncCommand };

package/src/cli/ipc.js

@@ -0,0 +1,127 @@
+'use strict';
+
+/**
+ * CLI → Daemon IPC client.
+ *
+ * Connects to the daemon's IPC socket (Unix socket on Linux/macOS,
+ * named pipe on Windows), sends a newline-delimited JSON command,
+ * waits for the JSON response, then resolves.
+ *
+ * Never hangs — times out after 5 seconds.
+ */
+
+const net = require('net');
+const path = require('path');
+const os = require('os');
+
+const IB_DIR = path.join(os.homedir(), '.ib');
+
+function getIPCPath() {
+    if (process.platform === 'win32') {
+        return '\\\\.\\pipe\\ib-ipc'; //Windows uses named pipes.
+    }
+    return path.join(IB_DIR, 'daemon.sock'); //Unix socket for Linux/macOS.
+}
+
+const IPC_SOCKET = getIPCPath();
+const TIMEOUT_MS = 5000;
+
+/**
+ * Send a command object to the daemon and return the response.
+ *
+ * @param {object} command - e.g. { type: 'ping' } or { type: 'send', ... }
+ * @returns {Promise<object>} - The daemon's JSON response
+ */
+function sendCommand(command) {
+    return new Promise((resolve, reject) => {
+        const socket = new net.Socket();
+        let buffer = '';
+        let timedOut = false;
+
+        const timer = setTimeout(() => {
+            timedOut = true;
+            socket.destroy();
+            reject(new Error('TIMEOUT'));
+        }, TIMEOUT_MS);
+
+        socket.connect(IPC_SOCKET, () => {
+            socket.write(JSON.stringify(command) + '\n');
+        });
+
+        socket.on('data', (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+
+            for (const line of lines) {
+                if (!line.trim()) continue;
+                clearTimeout(timer);
+                try {
+                    const response = JSON.parse(line);
+                    socket.destroy();
+                    resolve(response);
+                } catch {
+                    socket.destroy();
+                    reject(new Error('Invalid response from daemon'));
+                }
+                return;
+            }
+        });
+
+        socket.on('error', (err) => {
+            if (timedOut) return;
+            clearTimeout(timer);
+            socket.destroy();
+            if (err.code === 'ENOENT' || err.code === 'ECONNREFUSED') {
+                reject(new Error('DAEMON_NOT_RUNNING'));
+            } else {
+                reject(err);
+            }
+        });
+
+        socket.on('close', () => {
+            if (timedOut) return;
+            clearTimeout(timer);
+            // If we got here without resolving, resolve with empty
+            resolve({ ok: false, error: 'Connection closed unexpectedly' });
+        });
+    });
+}
+
+/**
+ * Convenience wrapper: send a command and print the result.
+ * Handles "daemon not running" with a user-friendly message.
+ *
+ * @param {object} command
+ * @param {function} formatter - (response) => void — formats and prints the result
+ */
+async function runCommand(command, formatter) {
+    try {
+        const response = await sendCommand(command);
+        formatter(response);
+    } catch (err) {
+        if (err.message === 'DAEMON_NOT_RUNNING') {
+            console.error('❌ Daemon is not running. Start it with: ib start');
+        } else if (err.message === 'TIMEOUT') {
+            console.error('❌ Daemon is not responding (timeout). Try: ib stop && ib start');
+        } else {
+            console.error('❌ IPC error:', err.message);
+        }
+        process.exit(1);
+    }
+}
+
+/**
+ * Check if daemon is alive (ping).
+ * Returns true if responding, false otherwise.
+ */
+async function isDaemonRunning() {
+    try {
+        const res = await sendCommand({ type: 'ping' });
+        return res.ok === true;
+    } catch {
+        return false;
+    }
+}
+
+module.exports = { sendCommand, runCommand, isDaemonRunning, IPC_SOCKET };

package/src/crypto/encrypt.js

@@ -0,0 +1,100 @@
+'use strict';
+
+/**
+ * Hybrid encryption: AES-256-GCM (for arbitrary-length plaintext)
+ * + RSA-OAEP (to encrypt the AES key).
+ */
+
+const crypto = require('crypto');
+
+/**
+ * RSA encryption needs something called padding.
+ * Padding is extra data added before encryption to make RSA secure.
+ */
+const RSA_PADDING = crypto.constants.RSA_PKCS1_OAEP_PADDING;
+
+/**
+ * OAEP is a padding scheme for RSA encryption.
+ * It uses a hash function (SHA-256) to add randomness and security.
+ */
+
+const OAEP_HASH = 'sha256';
+
+//The crypto functions expect binary data, not strings.
+
+/**
+ * Encrypt a plaintext string for a recipient.
+ *
+ * @param {string} plaintext - The message to encrypt
+ * @param {string} recipientPublicKeyPem - Recipient's RSA public key (PEM)
+ * @returns {{ encryptedKey: string, iv: string, tag: string, ciphertext: string }}
+ */
+function encrypt(plaintext, recipientPublicKeyPem) {
+
+    //Generate a fresh random AES-256 key for this message only
+    const aesKey = crypto.randomBytes(32); // 256-bit
+    const iv = crypto.randomBytes(12);     // 96-bit IV for GCM
+
+    // Encrypt plaintext with AES-256-GCM
+    const cipher = crypto.createCipheriv('aes-256-gcm', aesKey, iv); // in decryption this process will happen secondly, then down one(Interms of decryption)
+    const ciphertextBuf = Buffer.concat([
+        cipher.update(plaintext, 'utf8'),
+        cipher.final(),
+    ]);
+    const tag = cipher.getAuthTag(); // while encrypting, we also generate a 16-byte authentication tag
+
+    // Encrypt the AES key with the recipient's RSA public key
+    const encryptedKey = crypto.publicEncrypt(
+        {
+            key: recipientPublicKeyPem, //hence this should also be binary-data?
+            padding: RSA_PADDING,
+            oaepHash: OAEP_HASH,
+        },
+        aesKey
+    );
+
+    return {
+        encryptedKey: encryptedKey.toString('hex'),
+        iv: iv.toString('hex'),//be careful with this syntax, dont cconfuse with the Buffer.from(string, 'hex')
+        tag: tag.toString('hex'),
+        ciphertext: ciphertextBuf.toString('hex'),
+    };
+}
+
+/**
+ * Decrypt a payload produced by encrypt().
+ *
+ * @param {{ encryptedKey: string, iv: string, tag: string, ciphertext: string }} payload
+ * @param {string} privateKeyPem - Recipient's RSA private key (PEM)
+ * @returns {string} - Decrypted plaintext
+ */
+function decrypt(payload, privateKeyPem) { //payload is the encrypted message
+    const { encryptedKey, iv, tag, ciphertext } = payload;
+
+    //unlocking rsa stuff
+    const aesKey = crypto.privateDecrypt(
+        {
+            key: privateKeyPem,
+            padding: RSA_PADDING,
+            oaepHash: OAEP_HASH,
+        },
+        Buffer.from(encryptedKey, 'hex')
+    );
+
+    // creating a decryption engine
+    const decipher = crypto.createDecipheriv(
+        'aes-256-gcm',
+        aesKey,
+        Buffer.from(iv, 'hex')
+    );
+    decipher.setAuthTag(Buffer.from(tag, 'hex'));
+
+    const plaintext = Buffer.concat([
+        decipher.update(Buffer.from(ciphertext, 'hex')),
+        decipher.final(),
+    ]);
+
+    return plaintext.toString('utf8');
+}
+
+module.exports = { encrypt, decrypt };

package/src/crypto/keys.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { IB_DIR } = require('../identity/index');
+
+const KEYS_DIR = path.join(IB_DIR, 'keys');
+const PUBLIC_KEY_FILE = path.join(KEYS_DIR, 'public.pem');
+const PRIVATE_KEY_FILE = path.join(KEYS_DIR, 'private.pem');
+
+//using RSA algorithm to generate keypair
+function generateKeypair() {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
+        modulusLength: 2048,
+        //use spki format for public key and pkcs8 format for private key
+        //pem is a text format for keys
+        publicKeyEncoding: { type: 'spki', format: 'pem' },
+        /**
+         * something like this
+         * -----BEGIN PUBLIC KEY-----
+         * MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
+         * -----END PUBLIC KEY-----
+         */
+        privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
+    });
+    return { publicKey, privateKey };
+}
+
+/**
+ * Load existing keypair from disk, or generate and save a new one.
+ * Returns { publicKey, privateKey } as PEM strings.
+ */
+function loadOrCreateKeypair() {
+    if (!fs.existsSync(KEYS_DIR)) {
+        fs.mkdirSync(KEYS_DIR, { recursive: true });
+    }
+
+    //if key already exists, then load it
+    if (fs.existsSync(PUBLIC_KEY_FILE) && fs.existsSync(PRIVATE_KEY_FILE)) {
+        const publicKey = fs.readFileSync(PUBLIC_KEY_FILE, 'utf8');
+        const privateKey = fs.readFileSync(PRIVATE_KEY_FILE, 'utf8');
+        return { publicKey, privateKey };
+    }
+
+    //if not, generate and save it
+    const { publicKey, privateKey } = generateKeypair();
+    fs.writeFileSync(PUBLIC_KEY_FILE, publicKey, 'utf8');
+    // Private key: restrict permissions on unix-like systems
+    /*
+    The number is in octal format.
+
+    0o600
+
+    Break it down:
+
+    Digit	Meaning
+    6	owner permissions
+    0	group permissions
+    0	others permissions
+    */
+    fs.writeFileSync(PRIVATE_KEY_FILE, privateKey, { encoding: 'utf8', mode: 0o600 });
+
+    console.log('🔑 RSA keypair generated and stored in ~/.ib/keys/');
+    return { publicKey, privateKey };
+}
+
+/**
+ * Load public key PEM for the local user.
+ * Throws if not found (daemon should call loadOrCreateKeypair first).
+ */
+function loadPublicKey() {
+    if (!fs.existsSync(PUBLIC_KEY_FILE)) {
+        throw new Error('No public key found. Run: ib start');
+    }
+    return fs.readFileSync(PUBLIC_KEY_FILE, 'utf8');
+}
+
+/**
+ * Load private key PEM for the local user, also used by daemon to sign messages
+ */
+function loadPrivateKey() {
+    if (!fs.existsSync(PRIVATE_KEY_FILE)) {
+        throw new Error('No private key found. Run: ib start');
+    }
+    return fs.readFileSync(PRIVATE_KEY_FILE, 'utf8');
+}
+
+module.exports = {
+    loadOrCreateKeypair,
+    loadPublicKey,
+    loadPrivateKey,
+    PUBLIC_KEY_FILE,
+    PRIVATE_KEY_FILE,
+};