naira-agent 1.0.0

package/README.md

@@ -0,0 +1,8 @@
+# Naira Payment CLI
+
+The Naira CLI provides a powerful financial layer for AI agents and developers. It supports transfers, bill payments, KYC, and session-based transactions.
+
+## 🚀 AI Agent Integration
+
+We support **all** AI agents via the **Skill Protocol**. Whether you are using Claude Code, Antigravity, or Cursor, you can integrate Naira Payment as a skill.
+

package/dist/cli/accounts-cli.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountsCommand = void 0;
+exports.registerAccountsCli = registerAccountsCli;
+const runtime_1 = require("../runtime");
+const api_1 = __importDefault(require("../utils/api"));
+const errors_1 = require("../utils/errors");
+class AccountsCommand {
+    static register(program) {
+        const instance = new AccountsCommand();
+        const accounts = program
+            .command('accounts')
+            .description('Manage your virtual bank accounts. You can list existing accounts or create a new dedicated virtual account for receiving funds.');
+        accounts
+            .command('list')
+            .description('Retrieve a list of all your active virtual bank accounts, showing the bank name, account number, and account holder name.')
+            .action(() => instance.list());
+    }
+    async list() {
+        try {
+            const { data } = await api_1.default.get('/naira/accounts');
+            if (!data || data.length === 0) {
+                runtime_1.defaultRuntime.log('No virtual accounts found. They are usually created automatically after successful KYC.');
+                return;
+            }
+            runtime_1.defaultRuntime.log('--- Virtual Accounts ---');
+            data.forEach((acc) => {
+                runtime_1.defaultRuntime.log(`${acc.bankName.padEnd(20)} | ${acc.accountNumber} | ${acc.accountName}`);
+            });
+            runtime_1.defaultRuntime.log('------------------------');
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Failed to fetch accounts'));
+        }
+    }
+}
+exports.AccountsCommand = AccountsCommand;
+function registerAccountsCli(program) {
+    AccountsCommand.register(program);
+}

package/dist/cli/balance-cli.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BalanceCommand = void 0;
+exports.registerBalanceCli = registerBalanceCli;
+const runtime_1 = require("../runtime");
+const api_1 = __importDefault(require("../utils/api"));
+const errors_1 = require("../utils/errors");
+class BalanceCommand {
+    static register(program) {
+        const instance = new BalanceCommand();
+        program
+            .command('balance')
+            .description('Retrieve the current available balance for your Jovita Naira account. The balance is returned in Naira (NGN).')
+            .action(() => instance.execute());
+    }
+    async execute() {
+        try {
+            const { data: balanceData } = await api_1.default.get('/naira/balance');
+            runtime_1.defaultRuntime.log(`Balance: ${balanceData.currency} ${balanceData.balance}`);
+            try {
+                const { data: accountData } = await api_1.default.get('/naira/accounts');
+                if (accountData && accountData.length > 0) {
+                    runtime_1.defaultRuntime.log('\n--- Linked Accounts ---');
+                    accountData.forEach((acc) => {
+                        runtime_1.defaultRuntime.log(`${acc.bankName}: ${acc.accountNumber} (${acc.accountName})`);
+                    });
+                }
+            }
+            catch (accountErr) {
+                runtime_1.defaultRuntime.warn('Could not fetch linked accounts.');
+            }
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Failed to fetch balance'));
+        }
+    }
+}
+exports.BalanceCommand = BalanceCommand;
+function registerBalanceCli(program) {
+    BalanceCommand.register(program);
+}

package/dist/cli/banks-cli.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BanksCommand = void 0;
+exports.registerBanksCli = registerBanksCli;
+const runtime_1 = require("../runtime");
+const api_1 = __importDefault(require("../utils/api"));
+const errors_1 = require("../utils/errors");
+class BanksCommand {
+    static register(program) {
+        const instance = new BanksCommand();
+        program
+            .command('banks')
+            .description('Fetch and list all supported banks and their respective bank codes for transfers. Use these codes when initiating a transfer or resolving an account.')
+            .action(() => instance.execute());
+    }
+    async execute() {
+        try {
+            const { data } = await api_1.default.get('/naira/banks');
+            if (!data || data.length === 0) {
+                runtime_1.defaultRuntime.log('No banks found.');
+                return;
+            }
+            runtime_1.defaultRuntime.log('--- Supported Banks ---');
+            data.forEach((bank) => {
+                runtime_1.defaultRuntime.log(`${bank.name.padEnd(40)} | ${bank.code}`);
+            });
+            runtime_1.defaultRuntime.log('-----------------------');
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Could not fetch banks'));
+        }
+    }
+}
+exports.BanksCommand = BanksCommand;
+function registerBanksCli(program) {
+    BanksCommand.register(program);
+}

package/dist/cli/beneficiary-cli.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeneficiaryCommand = void 0;
+exports.registerBeneficiaryCli = registerBeneficiaryCli;
+const runtime_1 = require("../runtime");
+const api_1 = __importDefault(require("../utils/api"));
+const errors_1 = require("../utils/errors");
+class BeneficiaryCommand {
+    static register(program) {
+        const instance = new BeneficiaryCommand();
+        const beneficiary = program
+            .command('beneficiary')
+            .description('Manage your saved beneficiaries for quick transfers. You can list saved beneficiaries or add new ones to your account.');
+        beneficiary
+            .command('list')
+            .description('Fetch and display all your saved beneficiaries, showing their names, bank codes, and account numbers.')
+            .action(() => instance.list());
+        beneficiary
+            .command('add')
+            .description('Save a new beneficiary to your account for future transfers. Requires a bank code, account number, and the beneficiary name.')
+            .requiredOption('-n, --name <string>', 'The name to save for this beneficiary')
+            .requiredOption('-a, --account <number>', 'The account number of the beneficiary')
+            .requiredOption('-b, --bank <bankCode>', 'The bank code of the beneficiary bank')
+            .option('--bank-name <string>', 'Bank name')
+            .action((opts) => instance.add(opts));
+    }
+    async list() {
+        try {
+            const { data } = await api_1.default.get('/naira/beneficiaries');
+            if (!data || data.length === 0) {
+                runtime_1.defaultRuntime.log('No beneficiaries saved.');
+                return;
+            }
+            runtime_1.defaultRuntime.log('--- Beneficiaries ---');
+            data.forEach((b) => {
+                runtime_1.defaultRuntime.log(`${b.accountName.padEnd(20)} | ${b.bankName.padEnd(15)} | ${b.accountNumber}`);
+            });
+            runtime_1.defaultRuntime.log('---------------------');
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Could not fetch beneficiaries'));
+        }
+    }
+    async add(opts) {
+        try {
+            const { data } = await api_1.default.post('/naira/beneficiaries', {
+                accountName: opts.name,
+                accountNumber: opts.account,
+                bankCode: opts.bank,
+                bankName: opts.bankName || 'Unknown Bank',
+            });
+            runtime_1.defaultRuntime.success(`Beneficiary ${data.accountName} added successfully.`);
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Could not add beneficiary'));
+        }
+    }
+}
+exports.BeneficiaryCommand = BeneficiaryCommand;
+function registerBeneficiaryCli(program) {
+    BeneficiaryCommand.register(program);
+}

package/dist/cli/bills-cli.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillsCommand = void 0;
+exports.registerBillsCli = registerBillsCli;
+const runtime_1 = require("../runtime");
+const api_1 = __importDefault(require("../utils/api"));
+const errors_1 = require("../utils/errors");
+class BillsCommand {
+    static register(program) {
+        const instance = new BillsCommand();
+        const bills = program
+            .command('bills')
+            .description('Pay for various bills including Airtime, Mobile Data, Cable TV, Electricity, and Betting. The command will guide you through selecting a biller and a service plan.');
+        bills
+            .command('categories')
+            .description('List bill categories')
+            .action(() => instance.listCategories());
+        bills
+            .command('billers')
+            .description('List billers for a category')
+            .requiredOption('-c, --category <type>', 'AIRTIME, DATA, TV, ELECTRICITY')
+            .action((opts) => instance.listBillers(opts.category));
+        bills
+            .command('plans')
+            .description('List plans for a biller')
+            .requiredOption('-c, --category <type>', 'AIRTIME, DATA, TV, ELECTRICITY')
+            .requiredOption('-b, --biller <id>', 'Biller ID')
+            .action((opts) => instance.listPlans(opts.category, opts.biller));
+        bills
+            .command('pay')
+            .description('Pay for a bill; include --session-token to skip OTP when a valid session exists')
+            .requiredOption('-c, --category <type>', 'AIRTIME, DATA, TV, ELECTRICITY')
+            .requiredOption('-b, --biller <id>', 'Biller ID')
+            .option('-p, --plan <id>', 'Plan/Variation ID (if required)')
+            .requiredOption('-t, --target <string>', 'Phone number, smartcard, or meter number')
+            .requiredOption('-a, --amount <number>', 'Amount')
+            .option('-s, --session-token <string>', 'Optional transaction session token')
+            .action((opts) => instance.executePay(opts));
+    }
+    listCategories() {
+        ['AIRTIME', 'DATA', 'TV', 'ELECTRICITY'].forEach(c => runtime_1.defaultRuntime.log(c));
+    }
+    async listBillers(category) {
+        try {
+            const { data } = await api_1.default.get('/naira/bills/billers', { params: { category } });
+            data.forEach((b) => runtime_1.defaultRuntime.log(`${b.id}: ${b.name}`));
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Failed to fetch billers'));
+        }
+    }
+    async listPlans(category, billerId) {
+        try {
+            const { data } = await api_1.default.get('/naira/bills/variations', { params: { category, billerId } });
+            data.forEach((v) => {
+                const id = v.id || v.variation_code;
+                const amount = v.amount ?? v.variation_amount;
+                const amountStr = (amount === '0' || amount === 0) ? 'Variable' : `N${amount}`;
+                runtime_1.defaultRuntime.log(`${id}: ${v.name} (${amountStr})`);
+            });
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Failed to fetch plans'));
+        }
+    }
+    async executePay(opts) {
+        try {
+            const amount = Number.parseFloat(opts.amount);
+            if (!Number.isFinite(amount) || amount <= 0) {
+                runtime_1.defaultRuntime.error('Amount must be a valid number greater than 0.');
+                return;
+            }
+            const { data } = await api_1.default.post('/naira/bills/pay', {
+                category: opts.category,
+                billerId: opts.biller,
+                variationId: opts.plan,
+                target: opts.target,
+                amount,
+            }, {
+                headers: opts.sessionToken
+                    ? { 'X-Transaction-Session': opts.sessionToken }
+                    : undefined,
+            });
+            if (data.status === 'pending_otp') {
+                runtime_1.defaultRuntime.log(`Payment pending. Email confirmation OTP sent to ${data.maskedEmail}`);
+                runtime_1.defaultRuntime.log(`Reference: ${data.reference}`);
+                runtime_1.defaultRuntime.log(`Confirm with: naira confirm -r ${data.reference} -c <code>`);
+            }
+            else {
+                runtime_1.defaultRuntime.success(`Payment successful!`);
+                runtime_1.defaultRuntime.log(`Reference: ${data.reference}`);
+                runtime_1.defaultRuntime.log(`Status:    ${data.status}`);
+                runtime_1.defaultRuntime.log(`Amount:    NGN ${data.amount}`);
+            }
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Payment failed'));
+        }
+    }
+}
+exports.BillsCommand = BillsCommand;
+function registerBillsCli(program) {
+    BillsCommand.register(program);
+}

package/dist/cli/confirm-cli.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmCommand = void 0;
+exports.registerConfirmCli = registerConfirmCli;
+const api_1 = __importDefault(require("../utils/api"));
+const runtime_1 = require("../runtime");
+const errors_1 = require("../utils/errors");
+class ConfirmCommand {
+    static async execute(opts) {
+        try {
+            const reference = opts.reference;
+            const code = opts.code;
+            if (!reference) {
+                runtime_1.defaultRuntime.error('Reference is required (--reference or -r)');
+                return;
+            }
+            if (!code) {
+                runtime_1.defaultRuntime.error('OTP code is required (--code or -c)');
+                return;
+            }
+            // Determine endpoint based on reference prefix
+            let endpoint;
+            if (reference.startsWith('TX-')) {
+                endpoint = '/naira/transfer/confirm';
+            }
+            else if (reference.startsWith('BILL-')) {
+                endpoint = '/naira/bills/confirm';
+            }
+            else if (reference.startsWith('SES-')) {
+                endpoint = '/naira/session/confirm';
+            }
+            else {
+                runtime_1.defaultRuntime.error('Invalid reference format. Must start with TX-, BILL-, or SES-');
+                return;
+            }
+            const response = await api_1.default.post(endpoint, { reference, code });
+            if (response.data) {
+                const { sessionToken, sessionExpiresIn, transaction } = response.data;
+                if (sessionToken && sessionExpiresIn) {
+                    runtime_1.defaultRuntime.log('Confirmation successful. Session token issued:');
+                    if (response.data.sessionId) {
+                        runtime_1.defaultRuntime.log(`Session ID: ${response.data.sessionId}`);
+                    }
+                    runtime_1.defaultRuntime.log(`Token: ${sessionToken}`);
+                    runtime_1.defaultRuntime.log(`Expires in: ${Math.floor(sessionExpiresIn / 60)} minutes`);
+                }
+                else {
+                    runtime_1.defaultRuntime.log('Transaction confirmed!');
+                }
+                if (transaction) {
+                    runtime_1.defaultRuntime.log('--- Transaction Details ---');
+                    runtime_1.defaultRuntime.log(`ID:        ${transaction.id}`);
+                    runtime_1.defaultRuntime.log(`Status:    ${transaction.status}`);
+                    runtime_1.defaultRuntime.log(`Reference: ${transaction.reference}`);
+                    if (transaction.amount) {
+                        runtime_1.defaultRuntime.log(`Amount:    ${transaction.currency || 'NGN'} ${transaction.amount}`);
+                    }
+                    if (transaction.description) {
+                        runtime_1.defaultRuntime.log(`Reason:    ${transaction.description}`);
+                    }
+                    runtime_1.defaultRuntime.log('---------------------------');
+                }
+                else if (response.data) {
+                    // Fallback for other non-transaction confirmations (like session) if transaction is not present
+                    const { transaction: _, sessionToken: __, sessionId: ___, ...rest } = response.data;
+                    if (Object.keys(rest).length > 0) {
+                        runtime_1.defaultRuntime.log(JSON.stringify(rest, null, 2));
+                    }
+                }
+            }
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Confirmation failed'));
+        }
+    }
+}
+exports.ConfirmCommand = ConfirmCommand;
+function registerConfirmCli(program) {
+    program
+        .command('confirm')
+        .description('Confirm a pending transfer, bill payment, or session request with an email OTP code')
+        .requiredOption('-r, --reference <string>', 'Reference (e.g. TX-ABC123, BILL-XYZ789, SES-XYZ123)')
+        .requiredOption('-c, --code <string>', 'Email confirmation OTP code')
+        .action((opts) => ConfirmCommand.execute(opts));
+}

package/dist/cli/history-cli.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryCommand = void 0;
+exports.registerHistoryCli = registerHistoryCli;
+const runtime_1 = require("../runtime");
+const api_1 = __importDefault(require("../utils/api"));
+const errors_1 = require("../utils/errors");
+class HistoryCommand {
+    static register(program) {
+        const instance = new HistoryCommand();
+        program
+            .command('history')
+            .description('View your recent transaction history, including transfers, bill payments, and deposits. Shows status, amount, and reference for each transaction.')
+            .option('-l, --limit <number>', 'Maximum number of transactions to display (default: 10)', '10')
+            .option('-o, --offset <number>', 'Offset for pagination', '0')
+            .action((opts) => instance.execute(opts));
+    }
+    async execute(opts) {
+        try {
+            const limit = Number.parseInt(opts.limit, 10);
+            const offset = Number.parseInt(opts.offset, 10);
+            if (!Number.isInteger(limit) || limit < 1) {
+                runtime_1.defaultRuntime.error('Limit must be an integer greater than 0.');
+                return;
+            }
+            if (!Number.isInteger(offset) || offset < 0) {
+                runtime_1.defaultRuntime.error('Offset must be an integer greater than or equal to 0.');
+                return;
+            }
+            const { data } = await api_1.default.get('/naira/history', {
+                params: {
+                    limit,
+                    offset,
+                }
+            });
+            if (!data || data.length === 0) {
+                runtime_1.defaultRuntime.log('No transactions found.');
+                return;
+            }
+            runtime_1.defaultRuntime.log('--- Transaction History ---');
+            data.forEach((tx) => {
+                const date = new Date(tx.createdAt).toLocaleString();
+                const amount = tx.amount.toLocaleString('en-NG', { style: 'currency', currency: tx.currency || 'NGN' });
+                const type = tx.type.padEnd(12);
+                const status = tx.status.padEnd(8);
+                runtime_1.defaultRuntime.log(`[${date}] ${type} | ${status} | ${amount} | Ref: ${tx.reference}`);
+                if (tx.description) {
+                    runtime_1.defaultRuntime.log(`  Description: ${tx.description}`);
+                }
+            });
+            runtime_1.defaultRuntime.log('---------------------------');
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Could not fetch history'));
+        }
+    }
+}
+exports.HistoryCommand = HistoryCommand;
+function registerHistoryCli(program) {
+    HistoryCommand.register(program);
+}

package/dist/cli/kyc-cli.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KYCCommand = void 0;
+exports.registerKYCCli = registerKYCCli;
+const runtime_1 = require("../runtime");
+const api_1 = __importDefault(require("../utils/api"));
+const errors_1 = require("../utils/errors");
+class KYCCommand {
+    static register(program) {
+        const instance = new KYCCommand();
+        program
+            .command('kyc')
+            .description('Perform KYC (Know Your Customer) verification to upgrade your account limits.')
+            .option('-t, --type <type>', 'Identity type (bvn, nin)')
+            .requiredOption('-n, --number <string>', 'ID number')
+            .requiredOption('-f, --firstname <string>', 'First name')
+            .requiredOption('-l, --lastname <string>', 'Last name')
+            .requiredOption('-d, --dob <string>', 'Date of birth (YYYY-MM-DD)')
+            .action((opts) => instance.execute(opts));
+    }
+    async execute(opts) {
+        try {
+            const { data } = await api_1.default.post('/naira/kyc/verify', {
+                type: opts.type,
+                idNumber: opts.number,
+                firstname: opts.firstname,
+                lastname: opts.lastname,
+                dob: opts.dob,
+            });
+            if (data.status === 'VERIFIED') {
+                runtime_1.defaultRuntime.success(`Verified successfully!`);
+            }
+            else {
+                runtime_1.defaultRuntime.warn(`Verification status: ${data.status}`);
+            }
+            runtime_1.defaultRuntime.log(`Message: ${data.message}`);
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Verification failed'));
+        }
+    }
+}
+exports.KYCCommand = KYCCommand;
+function registerKYCCli(program) {
+    KYCCommand.register(program);
+}

package/dist/cli/login-cli.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoginCommand = void 0;
+exports.registerLoginCli = registerLoginCli;
+const axios_1 = __importDefault(require("axios"));
+const crypto = __importStar(require("crypto"));
+const runtime_1 = require("../runtime");
+const api_1 = __importDefault(require("../utils/api"));
+const config_1 = __importDefault(require("../utils/config"));
+const errors_1 = require("../utils/errors");
+const MAX_POLL_DURATION_MS = 5 * 60 * 1000; // 5 minutes
+const MAX_POLL_ATTEMPTS = 60;
+class LoginCommand {
+    static register(program) {
+        const instance = new LoginCommand();
+        program
+            .command('login')
+            .description('Authenticate your CLI session with the Jovita Payment Server using the Device Flow. This will provide a link and a user code for you to approve in your browser.')
+            .action(() => instance.execute());
+    }
+    async execute() {
+        try {
+            const agentName = process.env.NAIRA_AGENT_NAME?.trim() ||
+                process.env.AGENT_NAME?.trim() ||
+                'Naira CLI';
+            let deviceId = config_1.default.get('deviceId');
+            if (!deviceId) {
+                deviceId = crypto.randomUUID();
+                config_1.default.set('deviceId', deviceId);
+            }
+            const { data } = await api_1.default.post('/auth/device/authorize', {
+                client_id: deviceId,
+                client_name: agentName,
+            });
+            runtime_1.defaultRuntime.log(`Visit: ${data.verification_uri_complete || data.verification_uri}`);
+            if (!data.verification_uri_complete) {
+                runtime_1.defaultRuntime.log(`Enter Code: ${data.user_code}`);
+            }
+            runtime_1.defaultRuntime.log(`Waiting for approval...`);
+            const pollInterval = data.interval * 1000 || 5000;
+            const device_code = data.device_code;
+            const client_id = deviceId;
+            const client_name = agentName;
+            const startTime = Date.now();
+            let attempts = 0;
+            const poll = setInterval(async () => {
+                attempts++;
+                if (attempts > MAX_POLL_ATTEMPTS || (Date.now() - startTime) > MAX_POLL_DURATION_MS) {
+                    clearInterval(poll);
+                    runtime_1.defaultRuntime.error('Login timed out. Please try again.');
+                    process.exit(1);
+                }
+                try {
+                    const tokenRes = await api_1.default.post('/auth/device/token', {
+                        device_code,
+                        client_id,
+                        client_name,
+                        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                    });
+                    if (tokenRes.data.access_token) {
+                        clearInterval(poll);
+                        config_1.default.set('accessToken', tokenRes.data.access_token);
+                        config_1.default.set('refreshToken', tokenRes.data.refresh_token);
+                        runtime_1.defaultRuntime.success('Successfully authenticated!');
+                        process.exit(0);
+                    }
+                }
+                catch (err) {
+                    if (axios_1.default.isAxiosError(err)) {
+                        const errorRes = err.response?.data;
+                        const errorMessage = errorRes?.message || errorRes?.error;
+                        if (errorMessage === 'authorization_pending') {
+                            return;
+                        }
+                        clearInterval(poll);
+                        runtime_1.defaultRuntime.error(errorMessage || 'Login failed');
+                        process.exit(1);
+                    }
+                }
+            }, pollInterval);
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Failed to initiate login'));
+        }
+    }
+}
+exports.LoginCommand = LoginCommand;
+function registerLoginCli(program) {
+    LoginCommand.register(program);
+}

package/dist/cli/logout-cli.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogoutCommand = void 0;
+exports.registerLogoutCli = registerLogoutCli;
+const runtime_1 = require("../runtime");
+const api_1 = __importDefault(require("../utils/api"));
+const config_1 = __importDefault(require("../utils/config"));
+const errors_1 = require("../utils/errors");
+class LogoutCommand {
+    static register(program) {
+        const instance = new LogoutCommand();
+        program
+            .command('logout')
+            .description('Terminate your current Jovita CLI session and securely remove your authentication token from the local machine.')
+            .action(() => instance.execute());
+    }
+    async execute() {
+        try {
+            const refreshToken = config_1.default.get('refreshToken');
+            await api_1.default.post('/auth/logout', {
+                refresh_token: refreshToken
+            }).catch(() => {
+                runtime_1.defaultRuntime.warn('Could not notify server. Token may still be valid server-side.');
+            });
+            config_1.default.delete('accessToken');
+            config_1.default.delete('refreshToken');
+            config_1.default.delete('user');
+            config_1.default.delete('deviceId');
+            runtime_1.defaultRuntime.success('Logged out successfully from this device.');
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'An unexpected error occurred during logout.'));
+        }
+    }
+}
+exports.LogoutCommand = LogoutCommand;
+function registerLogoutCli(program) {
+    LogoutCommand.register(program);
+}

package/dist/cli/profile-cli.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileCommand = void 0;
+exports.registerProfileCli = registerProfileCli;
+const runtime_1 = require("../runtime");
+const api_1 = __importDefault(require("../utils/api"));
+const errors_1 = require("../utils/errors");
+class ProfileCommand {
+    static register(program) {
+        const instance = new ProfileCommand();
+        program
+            .command('profile')
+            .description('Display your user profile information, including name, email, and current KYC (Know Your Customer) verification status.')
+            .action(() => instance.execute());
+    }
+    async execute() {
+        try {
+            const { data } = await api_1.default.get('/naira/profile');
+            const { profile, balance } = data;
+            runtime_1.defaultRuntime.log('--- User Profile ---');
+            runtime_1.defaultRuntime.log(`Name:   ${profile.firstname} ${profile.lastname}`);
+            runtime_1.defaultRuntime.log(`Email:  ${profile.email}`);
+            runtime_1.defaultRuntime.log(`Phone:  ${profile.phone || 'N/A'}`);
+            runtime_1.defaultRuntime.log(`Status: ${profile.status}`);
+            runtime_1.defaultRuntime.log(`KYC:    Tier ${profile.kycTier} (${profile.kycVerificationStatus})`);
+            runtime_1.defaultRuntime.log(`Balance: NGN ${balance.toLocaleString()}`);
+            runtime_1.defaultRuntime.log('--------------------');
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Failed to fetch profile'));
+        }
+    }
+}
+exports.ProfileCommand = ProfileCommand;
+function registerProfileCli(program) {
+    ProfileCommand.register(program);
+}

package/dist/cli/resolve-cli.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolveCommand = void 0;
+exports.registerResolveCli = registerResolveCli;
+const runtime_1 = require("../runtime");
+const api_1 = __importDefault(require("../utils/api"));
+const errors_1 = require("../utils/errors");
+class ResolveCommand {
+    static register(program) {
+        const instance = new ResolveCommand();
+        program
+            .command('resolve')
+            .description('Resolve a bank account number to an account name. This is useful for verifying recipient details before initiating a transfer.')
+            .requiredOption('-b, --bank <bankCode>', 'The bank code of the recipient bank (e.g., 100004 for OPay)')
+            .requiredOption('-a, --account <number>', 'The account number to resolve')
+            .action((opts) => instance.execute(opts));
+    }
+    async execute(opts) {
+        try {
+            const { data } = await api_1.default.post('/naira/transfer/resolve', {
+                bankCode: opts.bank,
+                accountNumber: opts.account,
+            });
+            if (!data || !data.accountName) {
+                runtime_1.defaultRuntime.error('Could not resolve account name. Please verify the bank code and account number.');
+                return;
+            }
+            runtime_1.defaultRuntime.log('--- Account Details ---');
+            runtime_1.defaultRuntime.log(`Account Name:   ${data.accountName}`);
+            runtime_1.defaultRuntime.log(`Account Number: ${opts.account}`);
+            runtime_1.defaultRuntime.log(`Bank Code:      ${opts.bank}`);
+            runtime_1.defaultRuntime.log('-----------------------');
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Account resolution failed'));
+        }
+    }
+}
+exports.ResolveCommand = ResolveCommand;
+function registerResolveCli(program) {
+    ResolveCommand.register(program);
+}

package/dist/cli/session-cli.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionCommand = void 0;
+exports.registerSessionCli = registerSessionCli;
+const api_1 = __importDefault(require("../utils/api"));
+const runtime_1 = require("../runtime");
+const errors_1 = require("../utils/errors");
+class SessionCommand {
+    static async request(opts) {
+        try {
+            const durationMinutes = opts.duration ? Number.parseInt(opts.duration, 10) : undefined;
+            const response = await api_1.default.post('/naira/session/request', { label: opts.label, durationMinutes });
+            const data = response.data;
+            runtime_1.defaultRuntime.log(data.message || 'Session request submitted.');
+            if (data.sessionToken && data.sessionExpiresIn) {
+                runtime_1.defaultRuntime.log(`Session issued immediately: ${data.sessionId}`);
+                runtime_1.defaultRuntime.log(`Token: ${data.sessionToken}`);
+                if (data.sessionExpiresIn) {
+                    runtime_1.defaultRuntime.log(`Expires in: ${Math.floor(data.sessionExpiresIn / 60)} minutes`);
+                }
+                return;
+            }
+            if (data.reference && data.reference.startsWith('SES-')) {
+                runtime_1.defaultRuntime.log(`Reference: ${data.reference}`);
+                runtime_1.defaultRuntime.log(`Confirm with: naira-agent confirm -r ${data.reference} -c <code>`);
+            }
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Failed to request session'));
+        }
+    }
+    static async getStatus() {
+        try {
+            const response = await api_1.default.get('/naira/session/status');
+            const data = response.data;
+            if (!data.active) {
+                runtime_1.defaultRuntime.log('No active transaction sessions.');
+                return;
+            }
+            runtime_1.defaultRuntime.log(`Active transaction sessions: ${data.count ?? 1}`);
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Failed to get session status'));
+        }
+    }
+    static async revoke(opts) {
+        try {
+            await api_1.default.post('/naira/session/revoke', { sessionId: opts?.sessionId });
+            runtime_1.defaultRuntime.log(opts?.sessionId ? `Session ${opts.sessionId} revoked.` : 'All transaction sessions revoked.');
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Failed to revoke session'));
+        }
+    }
+    static async listSessions() {
+        try {
+            const response = await api_1.default.get('/naira/session');
+            const sessions = response.data;
+            if (!Array.isArray(sessions) || sessions.length === 0) {
+                runtime_1.defaultRuntime.log('No active transaction sessions.');
+                return;
+            }
+            runtime_1.defaultRuntime.log('Active transaction sessions:');
+            sessions.forEach((s) => {
+                runtime_1.defaultRuntime.log(`- [${s.sessionId}] ${s.label || 'unlabeled'} | ${s.durationMinutes ?? '?'} mins | expires ${new Date(s.expiresAt).toLocaleString()}`);
+                runtime_1.defaultRuntime.log(`  token: ${s.token}`);
+            });
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Failed to list sessions'));
+        }
+    }
+}
+exports.SessionCommand = SessionCommand;
+function registerSessionCli(program) {
+    const session = program
+        .command('session')
+        .description('Manage transaction sessions (request, list, status, revoke)');
+    session
+        .command('request')
+        .description('Request a transaction session for task execution (OTP confirmation required when OTP is enabled)')
+        .option('-l, --label <string>', 'Optional label (e.g. bulk payouts, nightly bot)')
+        .option('-d, --duration <minutes>', 'Session duration in minutes (5-120, default 30)')
+        .action((opts) => SessionCommand.request(opts));
+    session
+        .command('status')
+        .description('Check whether any transaction sessions are currently active')
+        .action(() => SessionCommand.getStatus());
+    session
+        .command('list')
+        .description('List active transaction sessions with labels, expiry, and token values')
+        .action(() => SessionCommand.listSessions());
+    session
+        .command('revoke')
+        .description('Revoke transaction sessions (all by default, or one via --session-id)')
+        .option('-i, --session-id <string>', 'Revoke a specific session by ID')
+        .action((opts) => SessionCommand.revoke(opts));
+}

package/dist/cli/settings-cli.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsCommand = void 0;
+exports.registerSettingsCli = registerSettingsCli;
+const api_1 = __importDefault(require("../utils/api"));
+const runtime_1 = require("../runtime");
+const errors_1 = require("../utils/errors");
+class SettingsCommand {
+    static register(program) {
+        const settings = program
+            .command('settings')
+            .description('Manage account settings');
+        const otp = settings
+            .command('otp')
+            .description('Email confirmation OTP settings for transactions');
+        otp
+            .command('enable')
+            .description('Enable email confirmation OTP for transactions')
+            .action(() => SettingsCommand.enableOtp());
+        otp
+            .command('disable')
+            .description('Disable email confirmation OTP for transactions')
+            .action(() => SettingsCommand.disableOtp());
+        otp
+            .command('status')
+            .description('Check email confirmation OTP status')
+            .action(() => SettingsCommand.otpStatus());
+    }
+    static async enableOtp() {
+        try {
+            const { data } = await api_1.default.post('/naira/settings/otp/enable');
+            runtime_1.defaultRuntime.success('Email confirmation OTP enabled for transactions.');
+            runtime_1.defaultRuntime.log(`Status: ${data.enabled ? 'enabled' : 'disabled'}`);
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Failed to enable OTP'));
+        }
+    }
+    static async disableOtp() {
+        try {
+            const { data } = await api_1.default.post('/naira/settings/otp/disable');
+            runtime_1.defaultRuntime.log('Email confirmation OTP disabled. Transactions will execute immediately.');
+            runtime_1.defaultRuntime.log(`Status: ${data.enabled ? 'enabled' : 'disabled'}`);
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Failed to disable OTP'));
+        }
+    }
+    static async otpStatus() {
+        try {
+            const { data } = await api_1.default.get('/naira/settings/otp/status');
+            runtime_1.defaultRuntime.log(`Email confirmation OTP: ${data.enabled ? 'enabled' : 'disabled'}`);
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Failed to get OTP status'));
+        }
+    }
+}
+exports.SettingsCommand = SettingsCommand;
+function registerSettingsCli(program) {
+    SettingsCommand.register(program);
+}

package/dist/cli/transfer-cli.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferCommand = void 0;
+exports.registerTransferCli = registerTransferCli;
+const api_1 = __importDefault(require("../utils/api"));
+const runtime_1 = require("../runtime");
+const errors_1 = require("../utils/errors");
+class TransferCommand {
+    static async execute(opts) {
+        try {
+            const amount = Number.parseFloat(opts.amount);
+            if (!Number.isFinite(amount) || amount <= 0) {
+                runtime_1.defaultRuntime.error('Amount must be a valid number greater than 0.');
+                return;
+            }
+            const response = await api_1.default.post('/naira/transfer', {
+                bankCode: opts.bankCode,
+                accountNumber: opts.accountNumber,
+                amount,
+                reason: opts.reason || 'Transfer',
+            }, {
+                headers: opts.sessionToken
+                    ? { 'X-Transaction-Session': opts.sessionToken }
+                    : undefined,
+            });
+            const data = response.data;
+            if (data.status === 'pending_otp') {
+                runtime_1.defaultRuntime.log(`Transaction pending. Email confirmation OTP sent to ${data.maskedEmail}`);
+                runtime_1.defaultRuntime.log(`Reference: ${data.reference}`);
+                runtime_1.defaultRuntime.log(`Confirm with: naira confirm -r ${data.reference} -c <code>`);
+            }
+            else {
+                runtime_1.defaultRuntime.success('Transfer initiated successfully!');
+                runtime_1.defaultRuntime.log(`Reference: ${data.reference}`);
+                runtime_1.defaultRuntime.log(`Status:    ${data.status}`);
+                runtime_1.defaultRuntime.log(`Amount:    NGN ${data.amount}`);
+            }
+        }
+        catch (err) {
+            runtime_1.defaultRuntime.error((0, errors_1.sanitizeErrorMessage)(err, 'Transfer failed'));
+        }
+    }
+}
+exports.TransferCommand = TransferCommand;
+function registerTransferCli(program) {
+    program
+        .command('transfer')
+        .description('Initiate a bank transfer; include --session-token to skip OTP when a valid session exists')
+        .requiredOption('-b, --bank-code <string>', 'Destination bank code')
+        .requiredOption('-a, --account-number <string>', 'Destination account number')
+        .requiredOption('-m, --amount <number>', 'Amount in Naira')
+        .option('-r, --reason <string>', 'Transfer reason/narration')
+        .option('-s, --session-token <string>', 'Optional transaction session token')
+        .action((opts) => TransferCommand.execute(opts));
+}

package/dist/index.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const login_cli_1 = require("./cli/login-cli");
+const balance_cli_1 = require("./cli/balance-cli");
+const transfer_cli_1 = require("./cli/transfer-cli");
+const bills_cli_1 = require("./cli/bills-cli");
+const confirm_cli_1 = require("./cli/confirm-cli");
+const history_cli_1 = require("./cli/history-cli");
+const beneficiary_cli_1 = require("./cli/beneficiary-cli");
+const banks_cli_1 = require("./cli/banks-cli");
+const accounts_cli_1 = require("./cli/accounts-cli");
+const profile_cli_1 = require("./cli/profile-cli");
+const settings_cli_1 = require("./cli/settings-cli");
+const logout_cli_1 = require("./cli/logout-cli");
+const resolve_cli_1 = require("./cli/resolve-cli");
+const session_cli_1 = require("./cli/session-cli");
+const { version } = require('../package.json');
+const program = new commander_1.Command();
+program
+    .name('naira-agent')
+    .description('CLI for Naira Payments: transfers, bill payments, KYC, account operations, and OTP-gated transaction sessions for AI or long-running tasks.')
+    .version(version);
+(0, login_cli_1.registerLoginCli)(program);
+(0, balance_cli_1.registerBalanceCli)(program);
+(0, transfer_cli_1.registerTransferCli)(program);
+(0, bills_cli_1.registerBillsCli)(program);
+(0, confirm_cli_1.registerConfirmCli)(program);
+(0, history_cli_1.registerHistoryCli)(program);
+(0, beneficiary_cli_1.registerBeneficiaryCli)(program);
+(0, banks_cli_1.registerBanksCli)(program);
+(0, accounts_cli_1.registerAccountsCli)(program);
+(0, profile_cli_1.registerProfileCli)(program);
+(0, settings_cli_1.registerSettingsCli)(program);
+(0, logout_cli_1.registerLogoutCli)(program);
+(0, resolve_cli_1.registerResolveCli)(program);
+(0, session_cli_1.registerSessionCli)(program);
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/dist/runtime.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRuntime = exports.Runtime = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+class Runtime {
+    log(message) {
+        console.log(message);
+    }
+    error(message) {
+        console.error(chalk_1.default.red(`Error: ${message}`));
+    }
+    success(message) {
+        console.log(chalk_1.default.green(message));
+    }
+    warn(message) {
+        console.log(chalk_1.default.yellow(`Warning: ${message}`));
+    }
+}
+exports.Runtime = Runtime;
+exports.defaultRuntime = new Runtime();

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/api.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const config_1 = __importDefault(require("./config"));
+const api = axios_1.default.create({
+    baseURL: config_1.default.get('serverUrl'),
+    timeout: 30_000,
+});
+const retriedRequests = new WeakSet();
+api.interceptors.request.use((req) => {
+    const token = config_1.default.get('accessToken');
+    if (token) {
+        req.headers.Authorization = `Bearer ${token}`;
+    }
+    return req;
+});
+api.interceptors.response.use((response) => {
+    if (response.data && typeof response.data === 'object' && 'data' in response.data) {
+        return { ...response, data: response.data.data };
+    }
+    return response;
+}, async (error) => {
+    const originalRequest = error.config;
+    if (!originalRequest) {
+        return Promise.reject(error);
+    }
+    if (error.response?.status === 401 && !retriedRequests.has(originalRequest)) {
+        retriedRequests.add(originalRequest);
+        const refreshToken = config_1.default.get('refreshToken');
+        if (refreshToken) {
+            try {
+                const { data } = await axios_1.default.post(`${config_1.default.get('serverUrl')}/auth/refresh`, {
+                    refresh_token: refreshToken,
+                });
+                const payload = data?.data ?? data;
+                const nextAccessToken = payload?.access_token;
+                const nextRefreshToken = payload?.refresh_token;
+                if (typeof nextAccessToken === 'string' && nextAccessToken.length > 0) {
+                    config_1.default.set('accessToken', nextAccessToken);
+                }
+                else {
+                    config_1.default.delete('accessToken');
+                }
+                if (typeof nextRefreshToken === 'string' && nextRefreshToken.length > 0) {
+                    config_1.default.set('refreshToken', nextRefreshToken);
+                }
+                else {
+                    config_1.default.delete('refreshToken');
+                }
+                if (!nextAccessToken) {
+                    return Promise.reject(new Error('Token refresh did not return an access token'));
+                }
+                originalRequest.headers = originalRequest.headers || {};
+                originalRequest.headers.Authorization = `Bearer ${nextAccessToken}`;
+                return api(originalRequest);
+            }
+            catch (refreshError) {
+                config_1.default.delete('accessToken');
+                config_1.default.delete('refreshToken');
+                config_1.default.delete('user');
+                return Promise.reject(refreshError);
+            }
+        }
+    }
+    return Promise.reject(error);
+});
+exports.default = api;

package/dist/utils/config.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const conf_1 = __importDefault(require("conf"));
+const schema = {
+    serverUrl: {
+        type: 'string',
+        default: 'https://api-naira.usebuildera.com/api',
+    },
+    accessToken: {
+        type: 'string',
+    },
+    refreshToken: {
+        type: 'string',
+    },
+    deviceId: {
+        type: 'string',
+    },
+    user: {
+        type: 'object',
+        properties: {
+            email: { type: 'string' },
+            firstname: { type: 'string' },
+            lastname: { type: 'string' },
+        }
+    }
+};
+const config = new conf_1.default({
+    schema,
+    projectName: 'naira-agent',
+    cwd: path_1.default.join(os_1.default.homedir(), '.naira-agent'),
+    configName: 'config'
+});
+// Restrict config file to owner-only read/write (0600)
+// Prevents other users/processes from reading stored tokens
+try {
+    fs_1.default.chmodSync(config.path, 0o600);
+}
+catch {
+    // Ignore if file doesn't exist yet — will be created on first write
+}
+exports.default = config;

package/dist/utils/errors.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeErrorMessage = sanitizeErrorMessage;
+const axios_1 = __importDefault(require("axios"));
+const MAX_ERROR_LENGTH = 200;
+/**
+ * Extract a safe, user-facing error message from an unknown error.
+ * Strips stack traces and truncates excessively long messages.
+ */
+function sanitizeErrorMessage(err, fallback) {
+    if (axios_1.default.isAxiosError(err)) {
+        const serverMessage = err.response?.data?.message;
+        if (typeof serverMessage === 'string' && serverMessage.length > 0) {
+            return serverMessage.slice(0, MAX_ERROR_LENGTH);
+        }
+        return fallback;
+    }
+    if (err instanceof Error) {
+        // Never expose raw stack traces
+        return err.message.slice(0, MAX_ERROR_LENGTH);
+    }
+    return fallback;
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "naira-agent",
+  "version": "1.0.0",
+  "description": "Terminal client for NairaAgent system",
+  "main": "dist/index.js",
+  "bin": {
+    "naira-agent": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run --config vitest.config.ts",
+    "lint": "echo \"Error: no lint specified\" && exit 0",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "conf": "^11.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.8.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2",
+    "vitest": "^2.1.8"
+  }
+}