nyxora 1.6.2 → 1.6.4

package/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.6.4]
+
+### Added
+- **Node.js Native Database Engine**: Migrated the core `logger.ts` memory subsystem to use the built-in `node:sqlite` engine (Node 22+), maintaining ultra-fast 100% synchronous operations while dramatically reducing dependency bloat.
+- **Next-Gen OS Keyring (N-API)**: Migrated `keytar` to `@napi-rs/keyring`. This replaces legacy C++ bindings with modern Rust/NAPI-RS, retaining identical OS-level security (Mac Keychain, Windows Credential Manager) while eliminating the `prebuild-install` deprecation warning and streamlining global installation.
+
+### Removed
+- `better-sqlite3` and `keytar` dependencies entirely removed from the monorepo architecture.
+
+## [1.6.3]
+
+### Added
+- Implemented **Zero-Click Multi-Session** for instantaneous chat creation and switching.
+- Introduced **Smart Auto-Naming** for automatic contextual session titles.
+
+### Changed
+- **Redesigned Sidebar Architecture**: enhanced utility-centric design, significantly reducing gaps for a compact, elegant look.
+- Integrated **OS-Native Keyring**, replacing legacy AES-256-GCM and Master Password mechanics.
+- Updated and cleaned up legacy cryptography references in VitePress guides and README.
+
+### Fixed
+- Resolved deeply-nested monorepo CI/CD deployment failures by isolating `package-lock.json` and mitigating peer-dependency conflicts.
+
 ## [1.4.5]
 
 ### Fixed

package/README.md

@@ -1,13 +1,13 @@
 # Nyxora Agent 🤖
 **Production-Grade Secure AI Execution Framework for Web3 Agents.**
 
-[![Version](https://img.shields.io/badge/version-1.6.2-blue.svg)](https://github.com/perasyudha/Nyxora)
+[![Version](https://img.shields.io/badge/version-1.6.3-blue.svg)](https://github.com/perasyudha/Nyxora)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Security: Production-Grade](https://img.shields.io/badge/Security-Production--Grade-blue.svg)](#️-advanced-security-threat-model)
 [![Execution: Cryptographic Approval](https://img.shields.io/badge/Execution-Cryptographic--Approval-orange.svg)](#️-advanced-security-threat-model)
 [![Privacy: Local-Only Keys](https://img.shields.io/badge/Privacy-Local--Only--Keys-success.svg)](#️-advanced-security-threat-model)
 
-Nyxora (v1.6.2) is a **secure, non-custodial runtime infrastructure for autonomous onchain agents** built with a robust Monorepo architecture (Node.js & React). Designed for autonomous workflows with a premium Glassmorphism UI dashboard and strict client-side key isolation. 
+Nyxora (v1.6.3) is a **secure, non-custodial runtime infrastructure for autonomous onchain agents** built with a robust Monorepo architecture (Node.js & React). Designed for autonomous workflows with a premium Glassmorphism UI dashboard and strict client-side key isolation. 
 
 It operates under an institutional-grade **Cryptographically Bound Human-in-the-Loop** execution model, ensuring that Remote AIs (LLMs) never have unilateral access to your funds.
 
@@ -15,20 +15,23 @@ It operates under an institutional-grade **Cryptographically Bound Human-in-the-
 
 ## 🔥 Key Features
 
-### Advanced Security Architecture (v1.6.2)
+### Advanced Security Architecture (v1.6.3)
 *   **3-Tier IPC Architecture**: Nyxora is split into isolated processes: **Core** (LLM Runtime), **Policy Engine** (Guardrails on port 3001), and **Signer Vault** (Isolated Key Manager on Unix Sockets).
 *   **Cryptographically Bound Approval**: Policy changes and transactions requested by the AI are drafted as hashes (`sha256`). Approval via the UI requires a challenge nonce, preventing Man-in-the-Middle (MITM) attacks.
 *   **Immutable Policy Guardrails**: Transaction limits (e.g. `max_usd_per_tx`) are strictly enforced by the Policy Engine. The LLM has zero write-access to bypass these rules.
+*   **Plugin Sandbox VM**: Execute community-built external skills securely inside an airtight Node.js `vm` chamber with zero access to your file system or terminal processes.
 
 ### Core Operations & Web3 Execution
 *   **System Automation & Full OS Access**: Instruct the agent to read/write local files, run terminal commands, and browse the web natively.
 *   **Anti-Rugpull & Security Scanner**: Nyxora can scan smart contracts via GoPlus Labs to detect Honeypots, Hidden Taxes, and malicious proxy upgrades before you buy.
 *   **Automated Limit Orders**: Set natural language rules (e.g., "Sell my PEPE if price drops below $0.001"). Nyxora runs a background cron monitor and executes the swap while you sleep (Auto-Approve Bypass configured safely).
+*   **Cross-Chain Hybrid Market Scanner**: Real-time asset tracking combining CoinGecko global data with DexScreener on-chain metrics across Ethereum, Base, Solana, BSC, and more.
 *   **PNL & Portfolio Tracking**: The AI scans your wallets and multiplies balances by live DEX prices to give you real-time Net Worth estimations.
 
 ### AI & UI Customization
-*   **Multi-LLM Support**: Seamlessly switch between Google Gemini, OpenAI, OpenRouter, or local Ollama models.
-*   **Premium Glassmorphism UI**: A gorgeous, resizable split-pane interface with Pseudo-Generative UI widgets (`<BalanceWidget>`, `<MarketWidget>`, `<SwapWidget>`).
+*   **Zero-Click Multi-Session**: Instantly create isolated chat sessions with smart auto-naming triggered by your first prompt, exactly like ChatGPT.
+*   **Dynamic Trending Tokens**: Live top 5 crypto assets feed directly injected into the dashboard, completely clickable for instant AI market analysis.
+*   **Premium Utility-Centric UI**: A sleek, dark-themed dashboard built for high readability and professional Web3 execution, featuring Pseudo-Generative UI widgets (`<BalanceWidget>`, `<MarketWidget>`, `<SwapWidget>`).
 *   **Deep Personalization**: Feed the agent custom rules via `user.md` and define its core persona via `IDENTITY.md`.
 
 ---
@@ -42,7 +45,7 @@ The following diagram illustrates Nyxora's **3-Tier Monorepo Architecture**, sho
 *Nyxora separates its duties into 3 independent layers for absolute security:*
 1. **🧠 Core (The AI Brain)**: The intelligent assistant that strategizes and plans transactions, but **never** holds your funds.
 2. **🛡️ Policy Engine (The Guard)**: The security guard that verifies the Brain's plans. If the AI attempts to send funds exceeding your set limits, this engine automatically blocks it.
-3. **🔒 Signer Vault (The Safe)**: The offline vault where your Private Keys are securely locked. It only signs transactions after they pass all rigorous security checks.
+3. **🔒 Signer Vault (The Safe)**: The offline vault where your Private Keys are securely locked natively in your OS Keyring (GNOME Keyring / macOS Keychain / Windows Credential Manager). It only signs transactions after they pass all rigorous security checks.
 
 *(Note: Despite the multi-layered security process appearing lengthy, the internal system validation and cryptographic signing occurs in **milliseconds**, ensuring zero latency bottlenecks).*
 
@@ -63,12 +66,16 @@ The easiest and fastest way to use Nyxora is to install it globally via NPM. Thi
 # 1. Install Nyxora globally
 npm install -g nyxora@latest
 
-# 2. Run the Interactive Setup Wizard (API Keys, Wallet, Model Selection)
+# 2. Run the Interactive Setup Wizard (API Keys, Wallet, Telegram)
 nyxora setup
 
-# 3. Start the Nyxora Orchestrator and Dashboard
-nyxora
+# 3. Start the Nyxora background daemon
+nyxora start
+
+# 4. Open the Web Dashboard
+nyxora dashboard
 ```
+> **⚠️ IMPORTANT:** Whenever you re-run `nyxora setup` or manually edit the config files, you **must restart the daemon** by running `nyxora restart` for the changes to take effect.
 
 ### Local Development (From Source)
 If you wish to modify the code or run from source, you can use the Monorepo architecture.
@@ -83,13 +90,16 @@ npm install
 # 2. Build the Dashboard UI
 npm run build
 
-# 3. Interactive Setup Wizard (API Keys, Wallet, Model Selection)
+# 3. Interactive Setup Wizard (API Keys, Wallet, Telegram)
 npm run setup
 
-# 4. Start the Nyxora Orchestrator
+# 4. Start the Nyxora background daemon
 npm start
+
+# 5. Open the Web Dashboard
+npm run dashboard
 ```
-*`npm start` will automatically boot the Core, Policy Engine, Signer Vault, and Local Dashboard UI.*
+> **⚠️ IMPORTANT:** Whenever you re-run `npm run setup` or manually edit the config files, you **must restart the daemon** by running `npm run restart` for the changes to take effect.
 
 ---
 

package/SECURITY.md

@@ -19,21 +19,7 @@ To achieve this, Nyxora uses a **3-Tier Monorepo IPC (Inter-Process Communicatio
 ### The Security Flow
 When the LLM processes a transaction instruction (e.g., swapping tokens), the lifecycle is as follows:
 
-```text
-[1] User (Dashboard/Telegram) ──> Sends prompt "Please swap ETH to USDC"
-                                      │
-[2] Core Runtime (LLM)        <── Understands context & generates JSON Tool Call
-                                      │
-[3] Policy Engine             <── Receives payload, evaluates rules & limits
-                                      │
-[4] User (Dashboard/Telegram) <── (If Auth required) Requests Approval (Challenge Nonce)
-                                      │
-[5] Signer Vault              <── Receives certified instruction from Policy
-                                      │
-[6] Blockchain RPC            <── Signer Vault signs & broadcasts to RPC
-                                      │
-[7] User (Dashboard/Telegram) <── Success status returned to chat interface
-```
+![Nyxora Security Flow](https://raw.githubusercontent.com/perasyudha/Nyxora/main/assets/security-flow.png)
 
 The diagram above illustrates the lifecycle of a transaction initiated from the user interface. Due to Nyxora's layered architecture, the LLM in the Core Runtime acts solely as a planner generating transaction data structures. The actual cryptographic execution and signing are strictly locked and fully controlled by the Policy Engine and Signer Vault after you provide authorization.
 
@@ -41,7 +27,22 @@ The diagram above illustrates the lifecycle of a transaction initiated from the
 
 ---
 
-## 2. Advanced Cryptographic Security
+## 2. OS-Native Keyring Integration
+
+Nyxora completely eliminates the need for manual "Master Passwords" or custom AES-GCM keystore files by delegating Private Key encryption directly to your Operating System's trusted Keyring.
+
+*   **Linux:** Integrates seamlessly with `Secret Service API / GNOME Keyring` via `libsecret`.
+*   **macOS:** Utilizes the native `Keychain Access`.
+*   **Windows:** Uses `Windows Credential Manager`.
+
+When the background daemon boots via `nyxora start`, the Signer Vault process reads the Private Key directly from the OS Keyring without requiring human intervention. This ensures the daemon can safely persist across reboots while maintaining institutional-grade encryption at rest.
+
+### Secure Fallback Storage
+In headless server environments (e.g., VPS, Docker) where a GUI Keyring is unavailable, Nyxora gracefully falls back to a strictly permissioned `.env` / `vault.key` file mechanism. This file is programmatically enforced with `chmod 0600` permissions (Read/Write for owner only), preventing access by other system users.
+
+---
+
+## 3. Advanced Cryptographic Security
 
 To prevent advanced Man-in-the-Middle (MITM) attacks and UI compromises, Nyxora is adopting the following cryptographic standards:
 
@@ -68,13 +69,16 @@ Every approval UI prompt utilizes a **Single-Use Challenge Nonce** with a strict
 
 ---
 
-## 3. Plugin Sandboxing
+## 4. Plugin Sandboxing (Node.js VM Isolation)
+
+Community plugins and custom skills are NEVER executed directly at the OS level. Instead, Nyxora creates an airtight **Virtual Machine (VM) Sandbox** in memory. 
 
-Community plugins and custom skills are executed inside a sandboxed environment.
-*   **Restricted FS Access:** Plugins cannot arbitrarily read your `~/.nyxora` keystore directory.
-*   **Restricted Shell Exec:** Arbitrary shell commands are disabled for third-party skills to prevent malicious `curl | bash` supply chain payloads.
+To prevent Supply Chain Attacks, the sandbox **permanently blacklists** critical native modules:
+*   `fs` (File System): Plugins cannot read or steal local keystore files.
+*   `child_process`: Plugins cannot spawn silent background terminals or malicious `curl | bash` supply chain payloads.
+*   `os`, `net`, `cluster`: Blocked to prevent network-level exploitation.
 
-## 4. Reporting Vulnerabilities
+## 5. Reporting Vulnerabilities
 
 If you discover a vulnerability in the Nyxora architecture, please DO NOT open a public issue.
 Instead, email the core maintainer directly at **ainyxor@gmail.com**.

package/bin/nyxora.mjs

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.join(__dirname, '..');
+
+const appDir = path.join(os.homedir(), '.nyxora');
+const pidFile = path.join(appDir, 'daemon.pid');
+const logFile = path.join(appDir, 'gateway.log');
+const tokenFile = path.join(appDir, 'auth.token');
+
+if (!fs.existsSync(appDir)) {
+  fs.mkdirSync(appDir, { recursive: true });
+}
+
+const command = process.argv[2];
+
+function isDaemonRunning(pidStr) {
+  if (!pidStr) return false;
+  try {
+    process.kill(parseInt(pidStr, 10), 0);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+async function getDaemonPid() {
+  if (fs.existsSync(pidFile)) {
+    const pidStr = fs.readFileSync(pidFile, 'utf8').trim();
+    if (isDaemonRunning(pidStr)) {
+      return parseInt(pidStr, 10);
+    } else {
+      fs.unlinkSync(pidFile);
+    }
+  }
+  return null;
+}
+
+async function start() {
+  const pid = await getDaemonPid();
+  if (pid) {
+    console.log(`Nyxora is already running (PID: ${pid}). Use 'nyxora restart' to restart.`);
+    return;
+  }
+
+  console.log('Starting Nyxora daemon...');
+  
+  const out = fs.openSync(logFile, 'a');
+  const err = fs.openSync(logFile, 'a');
+  
+  // Clean up any stale sockets first
+  const socketPath = '/tmp/nyxora-signer.sock';
+  if (fs.existsSync(socketPath)) {
+    try {
+        fs.unlinkSync(socketPath);
+    } catch(e) {}
+  }
+
+  const child = spawn('npx', ['ts-node', '-T', 'launcher.ts'], {
+    cwd: projectRoot,
+    detached: true,
+    stdio: ['ignore', out, err],
+    env: { ...process.env, TS_NODE_CACHE: 'false' }
+  });
+
+  child.unref();
+
+  if (child.pid) {
+    fs.writeFileSync(pidFile, child.pid.toString());
+    console.log(`Nyxora daemon started (PID: ${child.pid}).`);
+    console.log(`Logs are available at: ${logFile}`);
+  }
+}
+
+async function stop() {
+  const pid = await getDaemonPid();
+  if (pid) {
+    console.log(`Stopping Nyxora daemon (PID: ${pid})...`);
+    try {
+      process.kill(-pid, 'SIGTERM');
+      console.log('Nyxora stopped gracefully.');
+    } catch (e) {
+      console.error('Failed to kill process:', e.message);
+    }
+    try {
+      fs.unlinkSync(pidFile);
+    } catch(e) {}
+  } else {
+    console.log('Nyxora is not running.');
+  }
+}
+
+async function restart() {
+  await stop();
+  setTimeout(start, 1000);
+}
+
+async function dashboard() {
+  const pid = await getDaemonPid();
+  if (!pid) {
+    console.log("Nyxora is not running. Start it first with 'nyxora start'.");
+    return;
+  }
+
+  if (fs.existsSync(tokenFile)) {
+    const token = fs.readFileSync(tokenFile, 'utf8').trim();
+    const url = `http://localhost:3000?token=${token}`;
+    console.log(`Opening Dashboard at ${url}`);
+    try {
+        const { default: open } = await import('open');
+        await open(url);
+    } catch(e) {
+        console.error("Failed to open browser. Please manually open:", url);
+    }
+  } else {
+    console.log("Dashboard token not found. The daemon might still be starting.");
+  }
+}
+
+async function cleanLogs() {
+  if (fs.existsSync(logFile)) {
+    fs.writeFileSync(logFile, '');
+    console.log('Logs have been cleared.');
+  } else {
+    console.log('No logs found to clear.');
+  }
+}
+
+async function autostart(action) {
+  const isLinux = process.platform === 'linux';
+  const isMac = process.platform === 'darwin';
+  const isWin = process.platform === 'win32';
+  
+  if (isLinux) {
+    const autostartDir = path.join(os.homedir(), '.config', 'autostart');
+    const desktopFile = path.join(autostartDir, 'nyxora.desktop');
+    
+    if (action === 'enable') {
+      if (!fs.existsSync(autostartDir)) fs.mkdirSync(autostartDir, { recursive: true });
+      const binPath = path.resolve(projectRoot, 'bin', 'nyxora.mjs');
+      const desktopContent = `[Desktop Entry]
+Type=Application
+Exec=node ${binPath} start
+Hidden=false
+NoDisplay=false
+X-GNOME-Autostart-enabled=true
+Name=Nyxora Daemon
+Comment=Start Nyxora in the background
+`;
+      fs.writeFileSync(desktopFile, desktopContent);
+      console.log('Autostart enabled for Linux (XDG Autostart).');
+    } else if (action === 'disable') {
+      if (fs.existsSync(desktopFile)) fs.unlinkSync(desktopFile);
+      console.log('Autostart disabled.');
+    } else {
+      console.log("Usage: nyxora autostart [enable|disable]");
+    }
+  } else if (isMac) {
+    const plistDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+    const plistFile = path.join(plistDir, 'com.nyxora.gateway.plist');
+    if (action === 'enable') {
+      if (!fs.existsSync(plistDir)) fs.mkdirSync(plistDir, { recursive: true });
+      const binPath = path.resolve(projectRoot, 'bin', 'nyxora.mjs');
+      const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.nyxora.gateway</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${process.execPath}</string>
+        <string>${binPath}</string>
+        <string>start</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+</dict>
+</plist>`;
+      fs.writeFileSync(plistFile, plistContent);
+      console.log('Autostart enabled for macOS (LaunchAgent).');
+    } else if (action === 'disable') {
+      if (fs.existsSync(plistFile)) fs.unlinkSync(plistFile);
+      console.log('Autostart disabled.');
+    }
+  } else if (isWin) {
+    console.log("For Windows, please use Task Scheduler or add a shortcut to the Startup folder.");
+  } else {
+    console.log("Unsupported OS for autostart script.");
+  }
+}
+
+async function setup() {
+  console.log("Running Nyxora Setup Wizard...");
+  const child = spawn('npx', ['ts-node', '-T', 'packages/core/src/gateway/setup-cli.ts'], {
+    cwd: projectRoot,
+    stdio: 'inherit',
+    env: { ...process.env, TS_NODE_CACHE: 'false' }
+  });
+  
+  await new Promise(resolve => child.on('close', resolve));
+}
+
+async function main() {
+  switch (command) {
+    case 'setup': await setup(); break;
+    case 'start': await start(); break;
+    case 'stop': await stop(); break;
+    case 'restart': await restart(); break;
+    case 'dashboard': await dashboard(); break;
+    case 'clean-logs': await cleanLogs(); break;
+    case 'autostart': await autostart(process.argv[3]); break;
+    default:
+      console.log(`
+Nyxora CLI Manager
+Usage: nyxora <command>
+
+Commands:
+  start          Start the Nyxora background daemon
+  stop           Stop the running daemon
+  restart        Restart the daemon
+  dashboard      Open the dashboard in your browser
+  clean-logs     Clear the daemon logs
+  autostart      Enable/disable autostart on boot (usage: nyxora autostart enable)
+`);
+  }
+}
+
+main().catch(console.error);

package/launcher.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const INTERNAL_AUTH_TOKEN = crypto_1.default.randomBytes(64).toString('hex');
 console.log(`[Launcher] Generated Internal Auth Token: ${INTERNAL_AUTH_TOKEN.substring(0, 8)}...`);
 const env = {
@@ -34,10 +35,14 @@ if (fs_1.default.existsSync(socketPath)) {
     console.log(`[Launcher] Removing stale unix socket at ${socketPath}`);
     fs_1.default.unlinkSync(socketPath);
 }
-const signer = spawnService('Signer', 'npx', ['ts-node', '-T', 'packages/signer/src/server.ts'], env);
+const signerPath = path_1.default.join(__dirname, 'packages/signer/src/server.ts');
+const signer = spawnService('Signer', 'npx', ['ts-node', '-T', signerPath], env);
 setTimeout(() => {
-    const policy = spawnService('Policy', 'npx', ['ts-node', '-T', 'packages/policy/src/server.ts'], env);
+    const policyPath = path_1.default.join(__dirname, 'packages/policy/src/server.ts');
+    const policy = spawnService('Policy', 'npx', ['ts-node', '-T', policyPath], env);
     setTimeout(() => {
-        const core = spawnService('Core', 'npx', ['ts-node', '-T', 'packages/core/src/gateway/cli.ts'], env, true);
+        const corePath = path_1.default.join(__dirname, 'packages/core/src/gateway/cli.ts');
+        const args = process.argv.slice(2);
+        const core = spawnService('Core', 'npx', ['ts-node', '-T', corePath, ...args], env, true);
     }, 1000);
 }, 1000);

package/launcher.ts

@@ -9,7 +9,8 @@ console.log(`[Launcher] Generated Internal Auth Token: ${INTERNAL_AUTH_TOKEN.sub
 const env = {
   ...process.env,
   INTERNAL_AUTH_TOKEN,
-  SIGNER_SOCKET_PATH: '/tmp/nyxora-signer.sock'
+  SIGNER_SOCKET_PATH: '/tmp/nyxora-signer.sock',
+  TS_NODE_CACHE: 'false'
 };
 
 const spawnService = (name: string, command: string, args: string[], env: any, inheritStdio: boolean = false) => {
@@ -40,16 +41,42 @@ if (fs.existsSync(socketPath)) {
   fs.unlinkSync(socketPath);
 }
 
+const children: ReturnType<typeof spawn>[] = [];
+
 const signerPath = path.join(__dirname, 'packages/signer/src/server.ts');
 const signer = spawnService('Signer', 'npx', ['ts-node', '-T', signerPath], env);
+children.push(signer);
 
 setTimeout(() => {
   const policyPath = path.join(__dirname, 'packages/policy/src/server.ts');
   const policy = spawnService('Policy', 'npx', ['ts-node', '-T', policyPath], env);
+  children.push(policy);
   
   setTimeout(() => {
     const corePath = path.join(__dirname, 'packages/core/src/gateway/cli.ts');
     const args = process.argv.slice(2);
     const core = spawnService('Core', 'npx', ['ts-node', '-T', corePath, ...args], env, true);
+    children.push(core);
   }, 1000);
 }, 1000);
+
+// Ensure all child processes are killed when launcher exits
+const cleanup = () => {
+  console.log('\n[Launcher] Shutting down all services...');
+  children.forEach(child => {
+    if (!child.killed && child.pid) {
+      try {
+        process.kill(child.pid, 'SIGKILL');
+      } catch (e) {}
+    }
+  });
+  // Kill any stray ts-node processes left behind by npx
+  try {
+    require('child_process').execSync('pkill -f ts-node');
+  } catch (e) {}
+  process.exit(0);
+};
+
+process.on('SIGINT', cleanup);
+process.on('SIGTERM', cleanup);
+process.on('exit', cleanup);

package/package.json

@@ -1,18 +1,24 @@
 {
   "name": "nyxora",
-  "version": "1.6.2",
+  "version": "1.6.4",
+  "license": "MIT",
   "workspaces": [
     "packages/*"
   ],
+  "bin": {
+    "nyxora": "bin/nyxora.mjs"
+  },
   "scripts": {
-    "start": "ts-node -T launcher.ts",
+    "start": "node ./bin/nyxora.mjs start",
+    "stop": "node ./bin/nyxora.mjs stop",
+    "restart": "node ./bin/nyxora.mjs restart",
+    "dashboard": "node ./bin/nyxora.mjs dashboard",
+    "setup": "node ./bin/nyxora.mjs setup",
     "build": "npm run build --workspace=dashboard",
-    "setup": "ts-node -T packages/core/src/gateway/cli.ts setup",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
     "@clack/prompts": "^1.4.0",
-    "better-sqlite3": "^12.10.0",
     "concurrently": "^9.2.1",
     "cors": "^2.8.6",
     "dotenv": "^17.4.2",
@@ -20,7 +26,7 @@
     "express-rate-limit": "^7.5.0",
     "helmet": "^8.0.0",
     "jsonwebtoken": "^9.0.2",
-    "node-telegram-bot-api": "^0.67.0",
+    "@napi-rs/keyring": "^1.3.0",
     "open": "^11.0.0",
     "openai": "^6.39.0",
     "picocolors": "^1.1.1",
@@ -34,8 +40,5 @@
     "@types/jsonwebtoken": "^9.0.5",
     "@types/node": "^25.9.1",
     "vitepress": "^1.6.4"
-  },
-  "bin": {
-    "nyxora": "./bin/nyxora.js"
   }
 }

package/packages/core/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@nyxora/core",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "private": true,
   "main": "src/gateway/server.ts",
   "dependencies": {
     "@clack/prompts": "^1.4.0",
-    "better-sqlite3": "^12.10.0",
     "cors": "^2.8.6",
     "express": "^5.2.1",
-    "helmet": "^8.0.0",
     "express-rate-limit": "^7.5.0",
-    "node-telegram-bot-api": "^0.67.0",
+    "helmet": "^8.0.0",
+    "isolated-vm": "^6.1.2",
     "open": "^11.0.0",
     "openai": "^6.39.0",
+    "telegraf": "^4.16.3",
     "yaml": "^2.9.0"
   }
 }

package/packages/core/src/agent/reasoning.ts

@@ -181,12 +181,12 @@ If the user doesn't specify a chain, default to: ${config.agent.default_chain}.`
   return basePrompt;
 }
 
-export async function processUserInput(input: string, role: 'user' | 'system' = 'user', onProgress?: (msg: string) => void): Promise<string> {
+export async function processUserInput(input: string, role: 'user' | 'system' = 'user', onProgress?: (msg: string) => void, sessionId?: string): Promise<string> {
   const config = loadConfig();
   // Add input to memory
-  logger.addEntry({ role, content: input });
+  logger.addEntry({ role, content: input }, sessionId);
 
-  const history = logger.getHistory();
+  const history = logger.getHistory(sessionId);
   
   // Format messages for OpenAI
   const messages: any[] = [
@@ -258,7 +258,7 @@ export async function processUserInput(input: string, role: 'user' | 'system' =
       role: 'assistant',
       content: responseMessage.content || "",
       tool_calls: responseMessage.tool_calls,
-    });
+    }, sessionId);
 
     // Check if the model wants to call a tool
     if (responseMessage.tool_calls && responseMessage.tool_calls.length > 0) {
@@ -422,13 +422,13 @@ export async function processUserInput(input: string, role: 'user' | 'system' =
           tool_call_id: toolCall.id,
           name: toolName,
           content: result,
-        });
+        }, sessionId);
       }
 
       // Second call to get the final answer after tool execution
       const secondMessages = [
         { role: 'system', content: getSystemPrompt() },
-        ...logger.getHistory()
+        ...logger.getHistory(sessionId)
           .filter(m => !(m.role === 'tool' && !m.tool_call_id))
           .map(m => {
             let role = m.role;
@@ -454,13 +454,15 @@ export async function processUserInput(input: string, role: 'user' | 'system' =
       Tracker.addEvent('llm.final_response', { provider: config.llm.provider });
 
       const finalContent = secondResponse.choices[0].message.content || "";
-      logger.addEntry({ role: 'assistant', content: finalContent });
+      logger.addEntry({ role: 'assistant', content: finalContent }, sessionId);
       return finalContent;
     }
 
     return responseMessage.content || "No response generated.";
   } catch (error: any) {
     console.error("LLM Error:", error);
-    return `Error connecting to AI Provider: ${error.message}`;
+    const errorMsg = '⚠️ All models are temporarily rate-limited. Please try again in a few minutes.';
+    logger.addEntry({ role: 'assistant', content: errorMsg }, sessionId);
+    return errorMsg;
   }
 }

package/packages/core/src/config/parser.ts

@@ -24,12 +24,13 @@ export interface NyxoraConfig {
     path: string;
   };
   web3?: {
-    rpc_urls?: Record<string, string>;
+    rpc_urls?: Record<string, string | string[]>;
   };
   integrations?: {
     telegram?: {
       enabled: boolean;
       bot_token?: string;
+      authorized_chat_id?: number;
     };
   };
   permissions?: {