@neuraiproject/neurai-depin-terminal 1.0.1 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuraiproject/neurai-depin-terminal",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "description": "Neurai DePIN terminal messaging client",
   "type": "module",
   "main": "dist/index.cjs",
@@ -22,17 +22,19 @@
   },
   "scripts": {
     "start": "node src/index.js",
-    "bundle": "esbuild src/index.js --bundle --platform=node --format=cjs --outfile=dist/index.cjs --minify --alias:term.js=./src/lib/empty.js --alias:pty.js=./src/lib/empty.js --log-override:empty-import-meta=silent",
+    "bundle": "esbuild src/index.js --bundle --platform=node --format=cjs --outfile=dist/index.cjs --minify --external:charsm --alias:term.js=./src/lib/empty.js --alias:pty.js=./src/lib/empty.js --log-override:empty-import-meta=silent",
     "prepublishOnly": "npm run bundle",
     "build": "npm run bundle && NODE_NO_WARNINGS=1 pkg dist/index.cjs --targets node18-linux-x64,node18-macos-x64,node18-win-x64 --output bin/neurai-depin-terminal --compress GZip"
   },
   "pkg": {
     "assets": [
-      "node_modules/@neuraiproject/neurai-depin-msg/dist/neurai-depin-msg.js"
+      "node_modules/@neuraiproject/neurai-depin-msg/dist/neurai-depin-msg.js",
+      "node_modules/charsm/dist/lip.wasm",
+      "node_modules/charsm/dist/binary/**/*"
     ],
     "scripts": [
-      "node_modules/blessed/lib/**/*.js",
-      "node_modules/blessed-contrib/lib/**/*.js"
+      "node_modules/charsm/dist/**/*.js",
+      "node_modules/charsm/dist/**/*.mjs"
     ]
   },
   "keywords": [
@@ -45,12 +47,11 @@
   "author": "Neurai Community",
   "license": "MIT",
   "dependencies": {
-    "@neuraiproject/neurai-depin-msg": "^2.1.1",
-    "@neuraiproject/neurai-jswallet": "0.12.8",
-    "@neuraiproject/neurai-key": "^2.8.6",
-    "blessed": "^0.1.81",
-    "blessed-contrib": "^4.11.0",
+    "@neuraiproject/neurai-depin-msg": "^2.1.3",
+    "@neuraiproject/neurai-jswallet": "0.12.10",
+    "@neuraiproject/neurai-key": "^2.8.7",
     "chalk": "^5.3.0",
+    "charsm": "^0.2.0",
     "readline": "^1.3.0"
   },
   "devDependencies": {

package/src/config/ConfigManager.js

@@ -36,22 +36,28 @@ export class ConfigManager {
    * Encrypt private key using AES-256-GCM
    * @param {string} privateKey - Plain text private key in WIF format
    * @param {string} password - Password for encryption
-   * @returns {string} Encrypted data in format: salt:iv:authTag:encrypted (hex)
+   * @returns {Promise<string>} Encrypted data in format: salt:iv:authTag:encrypted (hex)
    * @throws {EncryptionError} If encryption fails
    */
-  encryptPrivateKey(privateKey, password) {
+  async encryptPrivateKey(privateKey, password) {
     try {
       const salt = crypto.randomBytes(ENCRYPTION.SALT_LENGTH);
-      const key = crypto.scryptSync(
-        password,
-        salt,
-        ENCRYPTION.KEY_LENGTH,
-        {
-          N: ENCRYPTION.SCRYPT_COST,
-          r: ENCRYPTION.SCRYPT_BLOCK_SIZE,
-          p: ENCRYPTION.SCRYPT_PARALLELIZATION
-        }
-      );
+      const key = await new Promise((resolve, reject) => {
+        crypto.scrypt(
+          password,
+          salt,
+          ENCRYPTION.KEY_LENGTH,
+          {
+            N: ENCRYPTION.SCRYPT_COST,
+            r: ENCRYPTION.SCRYPT_BLOCK_SIZE,
+            p: ENCRYPTION.SCRYPT_PARALLELIZATION
+          },
+          (err, derivedKey) => {
+            if (err) reject(err);
+            else resolve(derivedKey);
+          }
+        );
+      });
       const iv = crypto.randomBytes(ENCRYPTION.IV_LENGTH);
       const cipher = crypto.createCipheriv(ENCRYPTION.ALGORITHM, key, iv);
 
@@ -69,10 +75,10 @@ export class ConfigManager {
    * Decrypt private key using AES-256-GCM
    * @param {string} encryptedData - Encrypted data in format: salt:iv:authTag:encrypted
    * @param {string} password - Password for decryption
-   * @returns {string} Decrypted private key in WIF format
+   * @returns {Promise<string>} Decrypted private key in WIF format
    * @throws {EncryptionError} If decryption fails or password is incorrect
    */
-  decryptPrivateKey(encryptedData, password) {
+  async decryptPrivateKey(encryptedData, password) {
     try {
       const parts = encryptedData.split(':');
       if (parts.length !== 4) {
@@ -84,16 +90,22 @@ export class ConfigManager {
       const authTag = Buffer.from(parts[2], 'hex');
       const encrypted = parts[3];
 
-      const key = crypto.scryptSync(
-        password,
-        salt,
-        ENCRYPTION.KEY_LENGTH,
-        {
-          N: ENCRYPTION.SCRYPT_COST,
-          r: ENCRYPTION.SCRYPT_BLOCK_SIZE,
-          p: ENCRYPTION.SCRYPT_PARALLELIZATION
-        }
-      );
+      const key = await new Promise((resolve, reject) => {
+        crypto.scrypt(
+          password,
+          salt,
+          ENCRYPTION.KEY_LENGTH,
+          {
+            N: ENCRYPTION.SCRYPT_COST,
+            r: ENCRYPTION.SCRYPT_BLOCK_SIZE,
+            p: ENCRYPTION.SCRYPT_PARALLELIZATION
+          },
+          (err, derivedKey) => {
+            if (err) reject(err);
+            else resolve(derivedKey);
+          }
+        );
+      });
       const decipher = crypto.createDecipheriv(ENCRYPTION.ALGORITHM, key, iv);
       decipher.setAuthTag(authTag);
 
@@ -126,10 +138,13 @@ export class ConfigManager {
       const password = await readPassword('Enter password to decrypt private key: ');
 
       try {
-        privateKey = this.decryptPrivateKey(this.config.privateKey, password);
+        process.stdout.write('Verifying password...');
+        privateKey = await this.decryptPrivateKey(this.config.privateKey, password);
+        process.stdout.write('\r\x1b[K'); // Clear the "Verifying..." line
         decrypted = true;
         console.log('✓ Private key decrypted successfully\n');
       } catch (error) {
+        process.stdout.write('\r\x1b[K'); // Clear the "Verifying..." line
         if (attempts < maxAttempts) {
           console.log(`✗ Incorrect password. ${maxAttempts - attempts} attempts remaining.\n`);
         } else {
@@ -258,7 +273,9 @@ export class ConfigManager {
 
     // Get password and encrypt private key
     const password = await this.promptForPasswordCreation();
-    const encryptedPrivateKey = this.encryptPrivateKey(privateKey, password);
+    process.stdout.write('Encrypting private key...');
+    const encryptedPrivateKey = await this.encryptPrivateKey(privateKey, password);
+    process.stdout.write('\r\x1b[K'); // Clear the "Encrypting..." line
     console.log('✓ Private key encrypted successfully\n');
 
     // Create new readline for remaining questions

package/src/constants.js

@@ -48,6 +48,11 @@ export const MESSAGE = {
   FORCE_POLL_DELAY: 2000
 };
 
+// Recipient cache
+export const RECIPIENT_CACHE = {
+  REFRESH_MS: 60000
+};
+
 // Token Validation
 export const TOKEN = {
   PREFIX: '&',
@@ -57,9 +62,10 @@ export const TOKEN = {
 // UI Layout
 export const UI = {
   TOP_BAR_HEIGHT: 2,
+  TAB_BAR_HEIGHT: 1,
   INPUT_BOX_HEIGHT: 3,
   STATUS_BAR_HEIGHT: 1,
-  MESSAGE_BOX_OFFSET: 6, // top bar + input + status
+  MESSAGE_BOX_OFFSET: 7, // top bar + tab bar + input + status
   SCROLLBAR_CHAR: ' '
 };
 
@@ -94,11 +100,13 @@ export const RPC_METHODS = {
   DEPIN_SUBMIT_MSG: 'depinsubmitmsg',
   DEPIN_GET_MSG_INFO: 'depingetmsginfo',
   LIST_ADDRESSES_BY_ASSET: 'listaddressesbyasset',
-  GET_PUBKEY: 'getpubkey'
+  GET_PUBKEY: 'getpubkey',
+  LIST_DEPIN_ADDRESSES: 'listdepinaddresses'
 };
 
 // Terminal Control Sequences
 export const TERMINAL = {
+  ENTER_ALT_SCREEN: '\x1b[?1049h',
   EXIT_ALT_SCREEN: '\x1b[?1049l',
   SHOW_CURSOR: '\x1b[?25h',
   RESET_ATTRIBUTES: '\x1b[0m',
@@ -143,7 +151,9 @@ export const ERROR_MESSAGES = {
   INVALID_RPC_URL: 'Invalid RPC URL',
   CONNECTION_ERROR: 'Connection error',
   TOKEN_NOT_OWNED: 'This address does not own the configured token',
-  PUBKEY_NOT_REVEALED: 'Public key not revealed on blockchain'
+  PUBKEY_NOT_REVEALED: 'Public key not revealed on blockchain',
+  INVALID_PRIVATE_MESSAGE_FORMAT: 'Private message format: @address message',
+  RECIPIENT_PUBKEY_NOT_REVEALED: 'Recipient public key not revealed on blockchain'
 };
 
 // Success Messages
@@ -162,10 +172,10 @@ export const INFO_MESSAGES = {
   LOADING_LIBRARY: 'Loading DePIN library...',
   INITIALIZING_WALLET: 'Initializing wallet...',
   STARTING_UI: 'Starting terminal interface...',
-  PRESS_CTRL_C: 'Press Ctrl+C to exit.',
+  PRESS_CTRL_C: 'Press ESC or CTRL+C to exit.',
   CONNECTING: 'Attempting to connect to DePIN server...',
   RECONNECTING: 'Reconnecting, check server configuration',
-  SENDING: 'Sending message to all token holders...',
+  SENDING: 'Sending message...',
   VERIFYING_TOKEN: 'Verifying token ownership...',
   VERIFYING_PUBKEY: 'Verifying public key...'
 };
@@ -192,6 +202,9 @@ export const TIME = {
 export const BLESSED_KEYS = {
   QUIT: ['C-c', 'escape'],
   SEND: ['enter', 'C-s'],
+  TAB_NEXT: ['C-right'],
+  TAB_PREV: ['C-left'],
+  TAB_CLOSE: ['C-w'],
   SCROLL_UP: ['up'],
   SCROLL_DOWN: ['down']
 };

package/src/domain/messageTypes.js

@@ -0,0 +1,26 @@
+/**
+ * Shared message type helpers
+ * @module domain/messageTypes
+ */
+
+export const MESSAGE_TYPES = {
+  GROUP: 'group',
+  PRIVATE: 'private'
+};
+
+export const normalizeMessageType = (rawType) => {
+  if (typeof rawType === 'string') {
+    const lowered = rawType.toLowerCase();
+    if (lowered === MESSAGE_TYPES.PRIVATE) {
+      return MESSAGE_TYPES.PRIVATE;
+    }
+    if (lowered === MESSAGE_TYPES.GROUP) {
+      return MESSAGE_TYPES.GROUP;
+    }
+  }
+  return MESSAGE_TYPES.GROUP;
+};
+
+export const isPrivateMessage = (rawType) => {
+  return normalizeMessageType(rawType) === MESSAGE_TYPES.PRIVATE;
+};

package/src/errors.js

@@ -147,3 +147,20 @@ export function extractErrorMessage(error, fallback = 'Unknown error') {
 
   return fallback;
 }
+
+/**
+ * Check if an error is a known/expected application error
+ * @param {Error} error - Error object
+ * @returns {boolean} True if error is a known application error
+ */
+export function isKnownError(error) {
+  return error instanceof DepinError;
+}
+
+/**
+ * Check if debug mode is enabled
+ * @returns {boolean} True if debug mode is enabled
+ */
+export function isDebugMode() {
+  return process.env.DEPIN_DEBUG === '1' || process.env.NODE_ENV === 'development';
+}

package/src/index.js

@@ -13,21 +13,25 @@ import { RpcService } from './services/RpcService.js';
 import { MessageStore } from './messaging/MessageStore.js';
 import { MessagePoller } from './messaging/MessagePoller.js';
 import { MessageSender } from './messaging/MessageSender.js';
-import { TerminalUI } from './ui/TerminalUI.js';
+import { RecipientDirectory } from './messaging/RecipientDirectory.js';
+import { CharsmUI } from './ui/CharsmUI.js';
 import {
   INFO_MESSAGES,
   SUCCESS_MESSAGES,
   ERROR_MESSAGES,
   WARNING_MESSAGES,
   MESSAGE,
+  RECIPIENT_CACHE,
   HASH,
   ICONS
 } from './constants.js';
-import { extractErrorMessage } from './errors.js';
+import { extractErrorMessage, isKnownError, isDebugMode } from './errors.js';
+import { MESSAGE_TYPES } from './domain/messageTypes.js';
+import { emergencyTerminalCleanup, drainInput } from './utils.js';
 
 /**
  * Global UI instance for cleanup on exit
- * @type {TerminalUI|null}
+ * @type {CharsmUI|null}
  */
 let uiInstance = null;
 
@@ -91,17 +95,31 @@ async function initializeRpc(config) {
  * @returns {Object} Messaging components (store, poller, sender)
  */
 function initializeMessaging(config, walletManager, rpcService, neuraiDepinMsg) {
+  const recipientDirectory = new RecipientDirectory(config, rpcService, neuraiDepinMsg);
   const messageStore = new MessageStore();
-  const messagePoller = new MessagePoller(config, rpcService, messageStore, neuraiDepinMsg, walletManager);
-  const messageSender = new MessageSender(config, walletManager, rpcService, neuraiDepinMsg);
-
-  return { messageStore, messagePoller, messageSender };
+  const messagePoller = new MessagePoller(
+    config,
+    rpcService,
+    messageStore,
+    neuraiDepinMsg,
+    walletManager,
+    recipientDirectory
+  );
+  const messageSender = new MessageSender(
+    config,
+    walletManager,
+    rpcService,
+    neuraiDepinMsg,
+    recipientDirectory
+  );
+
+  return { messageStore, messagePoller, messageSender, recipientDirectory };
 }
 
 /**
  * Connect poller events to UI
  * @param {MessagePoller} messagePoller - Message poller instance
- * @param {TerminalUI} ui - Terminal UI instance
+ * @param {CharsmUI} ui - Terminal UI instance
  * @param {RpcService} rpcService - RPC service instance
  */
 function connectPollerToUI(messagePoller, ui, rpcService, onRpcDown) {
@@ -162,21 +180,39 @@ function connectPollerToUI(messagePoller, ui, rpcService, onRpcDown) {
 
 /**
  * Connect UI send action to message sender
- * @param {TerminalUI} ui - Terminal UI instance
+ * @param {CharsmUI} ui - Terminal UI instance
  * @param {MessageSender} messageSender - Message sender instance
  * @param {MessagePoller} messagePoller - Message poller instance
  */
-function connectSenderToUI(ui, messageSender, getMessagePoller) {
+function connectSenderToUI(ui, messageSender, getMessageStore, getMessagePoller) {
   ui.onSend(async (message) => {
     ui.updateSendStatus(INFO_MESSAGES.SENDING, 'info');
 
     try {
       const result = await messageSender.send(message);
+      const hashPreview = result.hash
+        ? `${result.hash.slice(0, HASH.DISPLAY_LENGTH)}...`
+        : 'N/A';
+
+      if (result.messageType === MESSAGE_TYPES.PRIVATE && result.messageHash && result.recipientAddress) {
+        const store = getMessageStore();
+        if (store) {
+          store.registerOutgoingPrivateMessage(result.messageHash, result.recipientAddress);
+        }
+        ui.openPrivateTab(result.recipientAddress, true);
+      }
 
-      ui.updateSendStatus(
-        `Message sent to ${result.recipients} recipients. Hash: ${result.hash.slice(0, HASH.DISPLAY_LENGTH)}...`,
-        'success'
-      );
+      if (result.messageType === MESSAGE_TYPES.PRIVATE) {
+        ui.updateSendStatus(
+          `Private message sent to ${result.recipientAddress}. Hash: ${hashPreview}`,
+          'success'
+        );
+      } else {
+        ui.updateSendStatus(
+          `Message sent to ${result.recipients} recipients. Hash: ${hashPreview}`,
+          'success'
+        );
+      }
 
       // Force a poll after sending to see the message
       setTimeout(() => {
@@ -195,7 +231,7 @@ function connectSenderToUI(ui, messageSender, getMessagePoller) {
 /**
  * Perform initial connection check and update UI
  * @param {RpcService} rpcService - RPC service instance
- * @param {TerminalUI} ui - Terminal UI instance
+ * @param {CharsmUI} ui - Terminal UI instance
  */
 async function performInitialConnectionCheck(rpcService, ui) {
   if (rpcService.isConnected()) {
@@ -206,7 +242,10 @@ async function performInitialConnectionCheck(rpcService, ui) {
         connected: true,
         lastPoll: null
       });
-      ui.showSuccess(SUCCESS_MESSAGES.CONNECTED);
+      const connectedMsgHash = ui.showSuccess(SUCCESS_MESSAGES.CONNECTED);
+      setTimeout(() => {
+        ui.removeMessage(connectedMsgHash);
+      }, 10000);
     } catch (error) {
       // Pool info check failed, continue without it
       ui.updateTopBar({
@@ -231,7 +270,7 @@ async function performInitialConnectionCheck(rpcService, ui) {
  * @param {RpcService} rpcService - RPC service
  * @param {WalletManager} walletManager - Wallet manager
  * @param {Object} config - Configuration
- * @param {TerminalUI} ui - UI instance
+ * @param {CharsmUI} ui - UI instance
  * @param {MessagePoller} messagePoller - Message poller instance
  */
 function startVerificationLoop(rpcService, walletManager, config, ui, getMessagePoller, resetMessagingAfterReconnect) {
@@ -340,12 +379,28 @@ function startVerificationLoop(rpcService, walletManager, config, ui, getMessage
  */
 async function main() {
   try {
+    // Emergency cleanup to ensure terminal is in a clean state
+    emergencyTerminalCleanup();
+
     console.log('Neurai DePIN Terminal');
     console.log('=====================\n');
 
     // 1. Load configuration
     const config = await initializeConfig();
 
+    // Comprehensive stdin cleanup after password prompt
+    if (process.stdin.isTTY) {
+      process.stdin.removeAllListeners('data');
+      process.stdin.removeAllListeners('keypress');
+      process.stdin.setRawMode(false);
+
+      // Use shared robust flushing logic
+      await drainInput(process.stdin);
+
+      // Wait one tick for everything to stabilize
+      await new Promise(resolve => setImmediate(resolve));
+    }
+
     // 2. Load DePIN library
     const neuraiDepinMsg = await initializeLibrary();
 
@@ -356,7 +411,7 @@ async function main() {
     const rpcService = await initializeRpc(config);
 
     // 5. Initialize messaging components
-    const { messageStore, messagePoller, messageSender } = initializeMessaging(
+    const { messageStore, messagePoller, messageSender, recipientDirectory } = initializeMessaging(
       config,
       walletManager,
       rpcService,
@@ -368,17 +423,36 @@ async function main() {
       messageStore,
       messagePoller,
       messageSender,
-      detachPollerUi: null
+      recipientDirectory,
+      detachPollerUi: null,
+      recipientRefreshInterval: null
+    };
+
+    const refreshRecipientCache = async (force = false) => {
+      try {
+        await messaging.messageSender.refreshRecipientCache(force);
+      } catch (error) {
+        // Non-fatal: keep existing cache if any
+      }
     };
 
     // 6. Initialize UI
     console.log(INFO_MESSAGES.STARTING_UI);
     console.log('');
-    const ui = new TerminalUI(config, walletManager, rpcService);
+    const ui = await CharsmUI.create(config, walletManager, rpcService);
     uiInstance = ui;
+    ui.setRecipientProvider(
+      () => messaging.messageSender.getPrivateRecipientAddresses(),
+      () => messaging.messageSender.getCachedPrivateRecipientAddresses()
+    );
 
     // 7. Get initial pool info and check connection
     await performInitialConnectionCheck(rpcService, ui);
+    refreshRecipientCache(true);
+    messaging.recipientRefreshInterval = setInterval(
+      () => refreshRecipientCache(true),
+      RECIPIENT_CACHE.REFRESH_MS
+    );
 
     let onRpcDownHandler = null;
 
@@ -416,7 +490,8 @@ async function main() {
         rpcService,
         messaging.messageStore,
         neuraiDepinMsg,
-        walletManager
+        walletManager,
+        messaging.recipientDirectory
       );
 
       // Mark as disconnected so the first poll is a full sync
@@ -427,11 +502,13 @@ async function main() {
       // Refresh pool info like at startup
       await performInitialConnectionCheck(rpcService, ui);
 
+      await refreshRecipientCache(true);
       messaging.messagePoller.start();
       await messaging.messagePoller.poll();
     };
 
     const getMessagePoller = () => messaging.messagePoller;
+    const getMessageStore = () => messaging.messageStore;
 
     // 8. Create verification loop (Single retry mechanism)
     const verification = startVerificationLoop(
@@ -448,7 +525,7 @@ async function main() {
     attachCurrentPollerToUI();
 
     // 10. Connect message sending from UI
-    connectSenderToUI(ui, messaging.messageSender, getMessagePoller);
+    connectSenderToUI(ui, messaging.messageSender, getMessageStore, getMessagePoller);
 
     // 11. Start verification loop (after wiring listeners)
     verification.start();
@@ -459,7 +536,10 @@ async function main() {
     }
 
     // 13. Show instructions
-    ui.showInfo(INFO_MESSAGES.PRESS_CTRL_C);
+    const exitMsgHash = ui.showInfo(INFO_MESSAGES.PRESS_CTRL_C);
+    setTimeout(() => {
+      ui.removeMessage(exitMsgHash);
+    }, 10000);
 
   } catch (error) {
     if (uiInstance) {
@@ -467,10 +547,20 @@ async function main() {
     }
 
     const errorMsg = extractErrorMessage(error, 'Unknown error');
-    console.error('Fatal error:', errorMsg);
 
-    if (error.stack) {
-      console.error(error.stack);
+    // For known errors, show a clean message. For unknown errors or debug mode, show stack trace
+    if (isKnownError(error)) {
+      console.error('\n✗ Error:', errorMsg);
+      if (isDebugMode() && error.stack) {
+        console.error('\nStack trace:');
+        console.error(error.stack);
+      }
+    } else {
+      console.error('\n✗ Fatal error:', errorMsg);
+      if (error.stack) {
+        console.error('\nStack trace:');
+        console.error(error.stack);
+      }
     }
 
     process.exit(1);
@@ -486,10 +576,19 @@ process.on('unhandledRejection', (error) => {
   }
 
   const errorMsg = extractErrorMessage(error, 'Unknown error');
-  console.error('Unhandled error:', errorMsg);
 
-  if (error && error.stack) {
-    console.error(error.stack);
+  if (isKnownError(error)) {
+    console.error('\n✗ Error:', errorMsg);
+    if (isDebugMode() && error && error.stack) {
+      console.error('\nStack trace:');
+      console.error(error.stack);
+    }
+  } else {
+    console.error('\n✗ Unhandled error:', errorMsg);
+    if (error && error.stack) {
+      console.error('\nStack trace:');
+      console.error(error.stack);
+    }
   }
 
   process.exit(1);
@@ -525,4 +624,4 @@ process.on('exit', () => {
 });
 
 // Execute main function
-main();
+main();