nyxora 26.6.23 → 26.6.25

package/README.md

@@ -3,7 +3,7 @@
 
 
 [![Status: Alpha](https://img.shields.io/badge/Status-Alpha-red.svg)](#)
-[![Built on Arbitrum](https://img.shields.io/badge/Built_on-Arbitrum-28A0F0?style=flat&logo=arbitrum&logoColor=white)](https://arbitrum.io/)
+[![Built on Base](https://img.shields.io/badge/Built_on-Base-0052FF?style=flat&logo=base&logoColor=white)](https://base.org/)
 [![MCP Supported](https://img.shields.io/badge/MCP-Supported-blue.svg)](#)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Security: Defense-in-Depth](https://img.shields.io/badge/Security-Defense--in--Depth-blue.svg)](#️-advanced-security-threat-model)
@@ -21,9 +21,9 @@ It operates under a **Zero-Trust, Defense-in-Depth Cryptographically Bound Human
 ## 🔥 Key Features
 
 ### Advanced Security Architecture
-*   **🛡️ On-Chain AI Kill-Switch**: Nyxora is governed by an Arbitrum Smart Contract (`NyxoraAgentRegistry`). Users have absolute cryptographic power to instantly paralyze the AI's on-chain execution if compromised, solving the Web3 AI safety dilemma. [Read more about our Arbitrum Architecture](https://nyxoraai.github.io/Nyxora/security/smart-contract)
+*   **🛡️ On-Chain AI Kill-Switch**: Nyxora is governed by a Base Smart Contract (`NyxoraAgentRegistry`). Users have absolute cryptographic power to instantly paralyze the AI's on-chain execution if compromised, solving the Web3 AI safety dilemma. [Read more about our Base Architecture](https://nyxoraai.github.io/Nyxora/security/smart-contract)
 *   **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).
-*   **DeFi Configuration BYOK & UI Masking**: All aggregator and provider API keys are strictly isolated via a Bring Your Own Keys (BYOK) architecture into a heavily guarded `~/.nyxora/defi_keys.yaml` file. The local web Dashboard masks these injected secrets using `***********` and `IS_SET` censorship, completely neutralizing malicious browser extensions from exfiltrating your keys.
+*   **DeFi & Market Configuration BYOK & UI Masking**: All aggregator, provider, and oracle API keys are strictly isolated via a Bring Your Own Keys (BYOK) architecture into heavily guarded `~/.nyxora/defi_keys.yaml` and `~/.nyxora/market_keys.yaml` files. The local web Dashboard masks these injected secrets using `***********` and `IS_SET` censorship, completely neutralizing malicious browser extensions from exfiltrating your keys.
 *   **Approval Replay Protection (Nonce Guard)**: Transactions requested by the AI are drafted as hashes and signed with a randomized 16-byte Nonce. The `/api/transactions/:id/approve` endpoint strictly enforces Nonce matching to completely eliminate double-spending and Replay Attacks.
 *   **Native Asset Parameter Tampering Protection**: The internal cryptographic HMAC signature rigorously binds `toAddress`, `txData`, and `valueWei`, rendering the system mathematically immune to Native Token (ETH/BNB) destination or amount hijacking via Indirect Prompt Injections.
 *   **Human-in-the-Loop Memory Approval**: AI-extracted permanent behavioral rules are strictly quarantined in a `pending` state until explicitly authorized by the user via the Dashboard, neutralizing Persistent Memory Poisoning vectors.
@@ -35,10 +35,10 @@ It operates under a **Zero-Trust, Defense-in-Depth Cryptographically Bound Human
 ### 🌐 Web3 Skills (On-Chain)
 *   **Security Scanner**: Nyxora can scan smart contracts via GoPlus Labs to detect Honeypots, Hidden Taxes, and malicious proxy upgrades before you buy.
 *   **Advanced DeFi Optimization**: Autonomously supply assets to Aave V3, deposit into Beefy/Yearn Auto-Compounder Vaults, manage Uniswap V3 Liquidity (LP), and instantly revoke infinite approvals to secure your wallet. Features intelligent Transaction Chaining to auto-approve allowances prior to execution.
-*   **6-Engine Meta-Aggregator & Anti-MEV**: The core engine interfaces with a powerful 6-Engine Meta-Aggregator (**1inch, 0x, LI.FI, Relay, OpenOcean, and KyberSwap**) to route tokens cross-chain, ensuring absolute maximum liquidity depth.
+*   **Extensible 8-Engine Meta-Aggregator & Anti-MEV**: The core engine interfaces with a powerful, extensible Meta-Aggregator (**1inch, 0x, LI.FI, Relay, OpenOcean, KyberSwap, ArbitrumBridge, and OpBridge**) via a dynamic Provider Registry to route tokens cross-chain, ensuring absolute maximum liquidity depth.
 *   **Adaptive Auto Slippage Protection**: Nyxora enforces a dynamic and adaptive **'auto' slippage** by default to leverage dynamic MEV-protection from these industry-standard aggregators. However, the user retains absolute control to override this dynamically—either globally via the Dashboard Settings or on a per-transaction basis through NLP chat commands (e.g., *"Swap 1 ETH to PEPE with 10% slippage"*).
 
-*   **Dual-Routing Market Intelligence Engine**: Real-time asset tracking utilizing a sophisticated API Waterfall. Symbol queries are routed to CoinGecko/CEXs for global FDV, while Contract Addresses trigger DexScreener for live on-chain liquidity metrics across all networks.
+*   **Dual-Routing Market Intelligence & Smart Fallback Engine**: Real-time asset tracking utilizing a sophisticated API Waterfall. Symbol queries are routed to CoinGecko/CoinMarketCap Pro endpoints (if BYOK is configured) or gracefully fall back to public endpoints. Contract Addresses seamlessly trigger DexScreener for live on-chain liquidity metrics across all networks, guaranteeing robust discovery even for unlisted memecoins.
 *   **Asynchronous Watchdog Agents**: Seamlessly spawn detached background instances for long-running monitoring tasks (e.g., *"Notify me when $ETH drops below $2500"*), leaving your primary chat session free for other operations.
 *   **"Lean Degen" Auto-Whitelist**: Automatically intercepts Contract Addresses (CAs) whenever you check balances or swap tokens, saving them to your localized `user_whitelist.json` for future tracking.
 *   **Dynamic Portfolio Engine**: Merges standard tokens, your custom Degen CAs, and CoinGecko's daily trending list into a single hyper-fast Multicall scan to deliver a clean, spam-free PnL portfolio report in under 1 second.
@@ -95,58 +95,27 @@ To dive deeper into the technical details of our Zero-Knowledge security archite
 
 ---
 
-## 1. 🚀 Quick Start & Installation
+## 🚀 Quick Start & Installation
 
-### Global Installation via NPM (Recommended)
-The easiest and fastest way to use Nyxora is to install it globally via NPM. This ensures you get the latest version and can run Nyxora from anywhere on your machine.
+### Option 1: Global Installation (Recommended)
+Nyxora can be installed globally via NPM, allowing you to use the `nyxora` CLI command from anywhere on your machine.
 
-The fastest way to install Nyxora is via our automated installation script:
-
-**For Linux & macOS (Bash):**
 ```bash
-curl -fsSL https://nyxoraai.github.io/Nyxora/install.sh | bash
-```
-
-**For Windows (PowerShell):**
-```powershell
-iwr https://nyxoraai.github.io/Nyxora/install.ps1 -useb | iex
-```
-
-Alternatively, you can install it manually on any operating system using NPM:
+# Install globally
+npm install -g nyxora
 
-```bash
-npm install -g nyxora@latest
-```
-
-### 2. Run the Interactive Setup Wizard (API Keys, Wallet, Telegram)
-```bash
+# Run the interactive setup wizard (API Keys, Wallet, Telegram)
 nyxora setup
-```
 
-### 3. Start the Nyxora background daemon
-```bash
+# Start the background daemon
 nyxora start
-```
 
-### 4. Open the Web Dashboard
-```bash
+# Open the interactive UI dashboard
 nyxora dashboard
 ```
 
-### Utility: Atomically clear the AI's short-term and long-term memory
-```bash
-nyxora clear --force
-```
-
-### Utility: Clean Uninstallation
-To completely remove Nyxora, wipe the AI's local memory, and securely delete your Private Key from the OS Keyring before uninstalling the NPM package:
-```bash
-nyxora uninstall
-```
-> **⚠️ 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.
+### Option 2: Local Development (Source Code)
+Nyxora operates on a Monorepo architecture. To run it locally from the source code, modify its behaviors, or contribute to the repository, follow these steps:
 
 ```bash
 git clone https://github.com/nyxoraAI/Nyxora.git
@@ -158,14 +127,16 @@ npm install
 # 2. Build the Dashboard UI
 npm run build
 
-# 3. Interactive Setup Wizard (API Keys, Wallet, Telegram)
+# 3. Interactive Setup Wizard
 npm run setup
 
 # 4. Start the Application
 npm start
 ```
+
 *(If you are actively developing and modifying the source code, use `npm run dev` to enable hot-reloading for the frontend and backend).*
-> **⚠️ IMPORTANT:** Whenever you re-run `npm run setup` or manually edit the config files, you **must restart the dev server** for the changes to take effect.
+
+> **⚠️ IMPORTANT:** Whenever you re-run `nyxora setup` or manually edit the config files, you **must restart the server** for the changes to take effect.
 
 ---
 
@@ -188,7 +159,7 @@ For complete technical deep-dives into our Cryptographic Architecture, please vi
 **❤️ Support the Project**
 
 Building and maintaining a highly secure, zero-trust architecture takes significant time and resources. If you love what we are building, you can help us keep Nyxora open, secure, and constantly evolving by sending a coffee our way:
-- **EVM :** `0x490717E50D6434C348AA0D2bD5fe682392823708`
+- **EVM :** `0xF5726f0F185d6304f30c9BAE95c477471E29F14f`
 
 ---
 **License:** MIT License

package/dist/packages/core/src/agent/cronManager.js

@@ -37,7 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cronManager = void 0;
-const cron = __importStar(require("node-cron"));
+const croner_1 = require("croner");
 const parser_1 = require("../config/parser");
 const telegram_1 = require("../gateway/telegram");
 const crypto_1 = require("crypto");
@@ -47,10 +47,13 @@ class CronManager {
     addJob(expression, prompt) {
         const id = (0, crypto_1.randomUUID)();
         // Validate expression
-        if (!cron.validate(expression)) {
+        try {
+            new croner_1.Cron(expression);
+        }
+        catch (e) {
             throw new Error(`Invalid cron expression: ${expression}`);
         }
-        const task = cron.schedule(expression, async () => {
+        const task = new croner_1.Cron(expression, async () => {
             console.log(picocolors_1.default.cyan(`[Cron] Executing job ${id}: "${prompt}"`));
             try {
                 // Dynamically import processUserInput to avoid circular dependencies

package/dist/packages/core/src/agent/llmProvider.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiAdapter = exports.AnthropicAdapter = exports.OpenAIAdapter = void 0;
+class OpenAIAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async chat(request) {
+        const response = await this.client.chat.completions.create(request);
+        return {
+            message: {
+                content: response.choices[0].message.content,
+                tool_calls: response.choices[0].message.tool_calls
+            }
+        };
+    }
+}
+exports.OpenAIAdapter = OpenAIAdapter;
+class AnthropicAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async chat(request) {
+        let systemPrompt = '';
+        const anthropicMessages = [];
+        for (const m of request.messages) {
+            if (m.role === 'system') {
+                systemPrompt = m.content;
+                continue;
+            }
+            if (m.role === 'user') {
+                anthropicMessages.push({ role: 'user', content: m.content });
+            }
+            else if (m.role === 'assistant') {
+                const blocks = [];
+                if (m.content)
+                    blocks.push({ type: 'text', text: m.content });
+                if (m.tool_calls) {
+                    m.tool_calls.forEach((tc) => {
+                        try {
+                            blocks.push({
+                                type: 'tool_use',
+                                id: tc.id,
+                                name: tc.function.name,
+                                input: JSON.parse(tc.function.arguments)
+                            });
+                        }
+                        catch (e) { }
+                    });
+                }
+                anthropicMessages.push({ role: 'assistant', content: blocks.length > 0 ? blocks : m.content });
+            }
+            else if (m.role === 'tool') {
+                anthropicMessages.push({
+                    role: 'user',
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: m.tool_call_id,
+                            content: m.content
+                        }
+                    ]
+                });
+            }
+        }
+        // Merge consecutive roles (Anthropic strictly requires alternating user/assistant)
+        const mergedAnthropic = [];
+        for (const m of anthropicMessages) {
+            const last = mergedAnthropic[mergedAnthropic.length - 1];
+            if (last && last.role === m.role) {
+                if (Array.isArray(last.content) && Array.isArray(m.content)) {
+                    last.content.push(...m.content);
+                }
+                else if (typeof last.content === 'string' && typeof m.content === 'string') {
+                    last.content += '\n\n' + m.content;
+                }
+                else if (Array.isArray(last.content) && typeof m.content === 'string') {
+                    last.content.push({ type: 'text', text: m.content });
+                }
+                else if (typeof last.content === 'string' && Array.isArray(m.content)) {
+                    last.content = [{ type: 'text', text: last.content }, ...m.content];
+                }
+            }
+            else {
+                mergedAnthropic.push(m);
+            }
+        }
+        let anthropicTools = undefined;
+        if (request.tools) {
+            anthropicTools = request.tools.map(t => ({
+                name: t.function.name,
+                description: t.function.description,
+                input_schema: t.function.parameters
+            }));
+        }
+        const response = await this.client.messages.create({
+            model: request.model,
+            system: systemPrompt,
+            messages: mergedAnthropic,
+            tools: anthropicTools,
+            temperature: request.temperature,
+            max_tokens: request.max_tokens || 4096
+        });
+        let contentStr = null;
+        let toolCalls = [];
+        for (const block of response.content) {
+            if (block.type === 'text') {
+                contentStr = (contentStr || '') + block.text;
+            }
+            else if (block.type === 'tool_use') {
+                toolCalls.push({
+                    id: block.id,
+                    type: 'function',
+                    function: {
+                        name: block.name,
+                        arguments: JSON.stringify(block.input)
+                    }
+                });
+            }
+        }
+        return {
+            message: {
+                content: contentStr,
+                tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+            }
+        };
+    }
+}
+exports.AnthropicAdapter = AnthropicAdapter;
+class GeminiAdapter {
+    apiKey;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    async chat(request) {
+        let systemInstruction = '';
+        const contents = [];
+        for (const m of request.messages) {
+            if (m.role === 'system') {
+                systemInstruction = m.content;
+                continue;
+            }
+            if (m.role === 'user') {
+                contents.push({ role: 'user', parts: [{ text: m.content }] });
+            }
+            else if (m.role === 'assistant') {
+                const parts = [];
+                if (m.content)
+                    parts.push({ text: m.content });
+                if (m.tool_calls) {
+                    m.tool_calls.forEach((tc) => {
+                        try {
+                            parts.push({
+                                functionCall: {
+                                    name: tc.function.name,
+                                    args: JSON.parse(tc.function.arguments)
+                                }
+                            });
+                        }
+                        catch (e) { }
+                    });
+                }
+                contents.push({ role: 'model', parts: parts });
+            }
+            else if (m.role === 'tool') {
+                contents.push({
+                    role: 'user',
+                    parts: [{
+                            functionResponse: {
+                                name: m.name || 'unknown_tool',
+                                response: { result: m.content }
+                            }
+                        }]
+                });
+            }
+        }
+        // Merge adjacent messages of the same role
+        const mergedContents = [];
+        for (const m of contents) {
+            const last = mergedContents[mergedContents.length - 1];
+            if (last && last.role === m.role) {
+                last.parts.push(...m.parts);
+            }
+            else {
+                mergedContents.push(m);
+            }
+        }
+        let tools = undefined;
+        if (request.tools && request.tools.length > 0) {
+            tools = [{
+                    functionDeclarations: request.tools.map(t => ({
+                        name: t.function.name,
+                        description: t.function.description,
+                        parameters: t.function.parameters
+                    }))
+                }];
+        }
+        const payload = {
+            contents: mergedContents,
+            generationConfig: {
+                temperature: request.temperature || 0.7,
+            },
+            safetySettings: [
+                { category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_NONE' },
+                { category: 'HARM_CATEGORY_HARASSMENT', threshold: 'BLOCK_NONE' },
+                { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_NONE' },
+                { category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'BLOCK_NONE' }
+            ]
+        };
+        if (systemInstruction) {
+            payload.systemInstruction = { parts: [{ text: systemInstruction }] };
+        }
+        if (tools) {
+            payload.tools = tools;
+        }
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${request.model}:generateContent?key=${this.apiKey}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(payload)
+        });
+        if (!response.ok) {
+            const errText = await response.text();
+            throw new Error(`Gemini API Error: ${response.status} ${response.statusText} - ${errText}`);
+        }
+        const data = await response.json();
+        let contentStr = null;
+        let toolCalls = [];
+        if (data.candidates && data.candidates.length > 0) {
+            const candidate = data.candidates[0];
+            if (candidate.finishReason && candidate.finishReason !== 'STOP') {
+                console.warn(`[LLM] Gemini API returned finishReason: ${candidate.finishReason}`);
+            }
+            if (candidate.content && candidate.content.parts) {
+                for (const part of candidate.content.parts) {
+                    if (part.text) {
+                        contentStr = (contentStr || '') + part.text;
+                    }
+                    else if (part.functionCall) {
+                        toolCalls.push({
+                            id: `call_${Math.random().toString(36).substring(7)}`,
+                            type: 'function',
+                            function: {
+                                name: part.functionCall.name,
+                                arguments: JSON.stringify(part.functionCall.args || {})
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            message: {
+                content: contentStr,
+                tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+            }
+        };
+    }
+}
+exports.GeminiAdapter = GeminiAdapter;