nyxora 26.6.19 → 26.6.21

package/README.md

@@ -24,6 +24,9 @@ It operates under a **Zero-Trust, Defense-in-Depth Cryptographically Bound Human
 *   **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.
 *   **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.
+*   **Stateless Policy Engine & DoS Resilience**: The Policy Engine operates as a 100% stateless cryptographic HMAC gatekeeper, hardened with resilient `try...catch` IPC interceptors to withstand Signer-level Denial of Service (Crash) 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.
 
 *   **Graceful SQLite WAL Shutdown**: Integrated `SIGTERM`/`SIGINT` interceptors ensure that when the daemon stops, active requests are safely terminated and SQLite Write-Ahead Logs (WAL) are securely flushed, preventing database corruption.
@@ -133,6 +136,12 @@ nyxora dashboard
 ```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)
@@ -159,6 +168,14 @@ npm start
 
 ---
 
+## ⚖️ Terms of Service
+
+By downloading, installing, or using the Nyxora AI Agent, you agree to our assumption of risk and liability limitations. Please ensure you review our legal policies before deploying the agent.
+
+> **🔗 [Read the Full Terms of Service Here](https://nyxoraai.github.io/Nyxora/terms)**
+
+---
+
 ## 📖 Official Documentation
 
 For complete technical deep-dives into our Cryptographic Architecture, please visit our official VitePress Documentation Site!
@@ -172,7 +189,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 (Multi-Sig Safe):** `0x490717E50D6434C348AA0D2bD5fe682392823708`
+- **EVM :** `0x490717E50D6434C348AA0D2bD5fe682392823708`
 
 ---
 **License:** MIT License

package/bin/nyxora.mjs

@@ -267,6 +267,34 @@ async function wallet(cliArgs) {
   await new Promise(resolve => child.on('close', resolve));
 }
 
+async function uninstall(cliArgs) {
+  const compiledCli = path.join(projectRoot, 'dist', 'packages/core/src/gateway/cli.js');
+  const useCompiled = fs.existsSync(compiledCli);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledCli, 'uninstall', ...cliArgs] : ['ts-node', '-T', 'packages/core/src/gateway/cli.ts', 'uninstall', ...cliArgs];
+  const child = spawn(cmd, args, {
+    cwd: projectRoot,
+    stdio: 'inherit',
+    env: { ...process.env, TS_NODE_CACHE: 'false' }
+  });
+  
+  await new Promise(resolve => child.on('close', resolve));
+}
+
+async function chat(cliArgs) {
+  const compiledCli = path.join(projectRoot, 'dist', 'packages/core/src/gateway/cli.js');
+  const useCompiled = fs.existsSync(compiledCli);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledCli, 'chat', ...cliArgs] : ['ts-node', '-T', 'packages/core/src/gateway/cli.ts', 'chat', ...cliArgs];
+  const child = spawn(cmd, args, {
+    cwd: projectRoot,
+    stdio: 'inherit',
+    env: { ...process.env, TS_NODE_CACHE: 'false' }
+  });
+  
+  await new Promise(resolve => child.on('close', resolve));
+}
+
 async function runDoctor() {
   const compiledCli = path.join(projectRoot, 'dist', 'packages/core/src/gateway/doctor.js');
   const useCompiled = fs.existsSync(compiledCli);
@@ -317,6 +345,8 @@ async function main() {
     case 'clear': await clearMemory(process.argv.slice(3)); break;
     case 'set-key': await setKey(process.argv.slice(3)); break;
     case 'wallet': await wallet(process.argv.slice(3)); break;
+    case 'chat': await chat(process.argv.slice(3)); break;
+    case 'uninstall': await uninstall(process.argv.slice(3)); break;
     case 'start': await start(); break;
     case 'stop': await stop(); break;
     case 'restart': await restart(); break;
@@ -341,6 +371,7 @@ Commands:
   start          Start the Nyxora background daemon
   stop           Stop the running daemon
   restart        Restart the daemon
+  chat           Chat interactively with the AI in terminal
   setup          Run the interactive Setup Wizard
   dashboard      Open the dashboard in your browser
   unlock         Unlock an inactive dashboard session
@@ -350,6 +381,7 @@ Commands:
   autostart      Enable/disable autostart on boot (usage: nyxora autostart enable)
   set-key        Securely save API Key (usage: nyxora set-key <provider> <key>)
   wallet         Manage your Web3 Wallet (usage: nyxora wallet update)
+  uninstall      Wipe AI memory, securely delete keys, and remove configuration
 
 Options:
   -v, --version  Show current version

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

@@ -315,6 +315,16 @@ async function processUserInput(input, role = 'user', onProgress, sessionId) {
                     }, sessionId);
                     continue;
                 }
+                if (!(0, skillManager_1.isSkillActive)(toolName)) {
+                    console.warn(picocolors_1.default.red(`[Security] Blocked illegal execution of disabled skill: ${toolName}`));
+                    result = `[System Error] Access denied: Skill '${toolName}' is currently disabled by the user.`;
+                    exports.logger.addEntry({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: result
+                    }, sessionId);
+                    continue;
+                }
                 try {
                     switch (toolName) {
                         case 'get_balance': {
@@ -327,7 +337,7 @@ async function processUserInput(input, role = 'user', onProgress, sessionId) {
                             break;
                         }
                         case 'get_price': {
-                            result = await (0, getPrice_1.getPrice)(args.coinId);
+                            result = await (0, getPrice_1.getPrice)(args.coinId, args.currency);
                             break;
                         }
                         case 'swap_token': {

package/dist/packages/core/src/config/parser.js

@@ -3,15 +3,92 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptDataSync = encryptDataSync;
+exports.decryptDataSync = decryptDataSync;
 exports.loadRpcConfig = loadRpcConfig;
 exports.saveRpcConfig = saveRpcConfig;
 exports.loadApiKeys = loadApiKeys;
 exports.saveApiKeys = saveApiKeys;
 exports.loadConfig = loadConfig;
 exports.saveConfig = saveConfig;
+exports.loadPolicyConfig = loadPolicyConfig;
 const fs_1 = __importDefault(require("fs"));
 const yaml_1 = __importDefault(require("yaml"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const crypto_1 = __importDefault(require("crypto"));
 const paths_1 = require("./paths");
+let cachedEncryptionKey = null;
+function getEncryptionKeySync() {
+    if (cachedEncryptionKey)
+        return cachedEncryptionKey;
+    let masterKeyRaw = process.env.NYXORA_MASTER_KEY;
+    if (!masterKeyRaw) {
+        try {
+            const { execSync } = require('child_process');
+            const output = execSync(`node -e "require('@napi-rs/keyring').Entry.prototype.getPassword.call(new (require('@napi-rs/keyring').Entry)('nyxora', 'config_master')).then(console.log).catch(()=>console.log(''))"`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+            const pk = output?.trim();
+            if (pk)
+                masterKeyRaw = pk;
+        }
+        catch (e) {
+            // Ignore
+        }
+    }
+    if (!masterKeyRaw) {
+        try {
+            const masterKeyPath = path_1.default.join(os_1.default.homedir(), '.nyxora', 'auth', 'master.key');
+            if (fs_1.default.existsSync(masterKeyPath)) {
+                masterKeyRaw = fs_1.default.readFileSync(masterKeyPath, 'utf8').trim();
+            }
+            else {
+                masterKeyRaw = crypto_1.default.randomBytes(32).toString('hex');
+                try {
+                    fs_1.default.writeFileSync(masterKeyPath, masterKeyRaw, { mode: 0o600 });
+                }
+                catch (e) { }
+            }
+        }
+        catch (e) {
+            masterKeyRaw = 'default_fallback_nyxora_key';
+        }
+    }
+    cachedEncryptionKey = crypto_1.default.createHash('sha256').update(masterKeyRaw).digest();
+    return cachedEncryptionKey;
+}
+function encryptDataSync(text) {
+    if (!text || text.startsWith('ENC:'))
+        return text;
+    const iv = crypto_1.default.randomBytes(12);
+    const cipher = crypto_1.default.createCipheriv('aes-256-gcm', getEncryptionKeySync(), iv);
+    let encrypted = cipher.update(text, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    const authTag = cipher.getAuthTag().toString('hex');
+    return `ENC:${iv.toString('hex')}:${authTag}:${encrypted}`;
+}
+function decryptDataSync(encryptedText) {
+    if (!encryptedText)
+        return encryptedText;
+    if (!encryptedText.startsWith('ENC:')) {
+        return encryptedText;
+    }
+    try {
+        const parts = encryptedText.split(':');
+        if (parts.length < 4)
+            return encryptedText;
+        const iv = Buffer.from(parts[1], 'hex');
+        const authTag = Buffer.from(parts[2], 'hex');
+        const encrypted = parts.slice(3).join(':');
+        const decipher = crypto_1.default.createDecipheriv('aes-256-gcm', getEncryptionKeySync(), iv);
+        decipher.setAuthTag(authTag);
+        let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    }
+    catch (e) {
+        return encryptedText; // return raw if decryption fails
+    }
+}
 function loadRpcConfig() {
     const rpcPath = (0, paths_1.getPath)('rpc_key.yaml');
     if (fs_1.default.existsSync(rpcPath)) {
@@ -51,8 +128,28 @@ function loadConfig() {
     try {
         const file = fs_1.default.readFileSync(configPath, 'utf8');
         const parsed = yaml_1.default.parse(file);
-        // Auto-migration logic: move llm.credentials to root credentials
         let needsSave = false;
+        // Decrypt credentials
+        if (parsed.credentials) {
+            for (const key in parsed.credentials) {
+                if (parsed.credentials[key]) {
+                    if (parsed.credentials[key].startsWith('ENC:'))
+                        needsSave = true;
+                    parsed.credentials[key] = decryptDataSync(parsed.credentials[key]);
+                }
+            }
+        }
+        if (parsed.integrations?.telegram?.bot_token) {
+            if (parsed.integrations.telegram.bot_token.startsWith('ENC:'))
+                needsSave = true;
+            parsed.integrations.telegram.bot_token = decryptDataSync(parsed.integrations.telegram.bot_token);
+        }
+        if (parsed.web3?.explorer_api_key) {
+            if (parsed.web3.explorer_api_key.startsWith('ENC:'))
+                needsSave = true;
+            parsed.web3.explorer_api_key = decryptDataSync(parsed.web3.explorer_api_key);
+        }
+        // Auto-migration logic: move llm.credentials to root credentials
         if (parsed.llm && parsed.llm.credentials) {
             if (!parsed.credentials) {
                 parsed.credentials = {};
@@ -74,7 +171,7 @@ function loadConfig() {
         // Auto-migration logic: move permissions to policy.yaml
         const policyPath = (0, paths_1.getPath)('policy.yaml');
         if (!fs_1.default.existsSync(policyPath)) {
-            const defaultPolicy = `max_usd_per_tx: ${parsed.permissions?.web3?.max_usd_per_tx || 999999999}\nwhitelist_only: false\nrequire_approval: true\n`;
+            const defaultPolicy = `auto_approve_limit_usd: 0\ncustom_llm_rules: []\n`;
             fs_1.default.writeFileSync(policyPath, defaultPolicy, 'utf8');
             console.log('[Config] Created default policy.yaml.');
         }
@@ -84,15 +181,14 @@ function loadConfig() {
         }
         if (needsSave) {
             try {
-                const yamlStr = yaml_1.default.stringify(parsed);
-                fs_1.default.writeFileSync(configPath, yamlStr, 'utf8');
-                console.log('[Config] Auto-migrated llm.credentials to root credentials.');
+                saveConfig(parsed);
+                console.log('[Config] Auto-migrated config file safely.');
             }
             catch (e) {
                 console.error('[Config] Failed to auto-migrate config file', e);
             }
         }
-        return {
+        const validatedConfig = {
             agent: parsed.agent || { name: 'Nyxora-Default', description: 'Your Personal Web3 Assistant.', default_chain: 'base', default_router: 'auto', default_slippage: 'auto' },
             llm: parsed.llm || {
                 provider: 'openai',
@@ -109,13 +205,18 @@ function loadConfig() {
             web3: { ...parsed.web3, rpc_urls: rpcUrls },
             integrations: parsed.integrations || {
                 telegram: { enabled: false }
-            }
+            },
+            skills: parsed.skills
         };
+        return validatedConfig;
     }
     catch (error) {
         if (error.code === 'ENOENT') {
             console.log('[Config] No config.yaml found. Using default configuration.');
         }
+        else if (error.name === 'YAMLError' || error.message?.includes('YAML')) {
+            console.warn('[Parser] YAML Parse Error:', error.message);
+        }
         else {
             console.error('[Config] Failed to load config.yaml. Using default configuration.', error);
         }
@@ -153,6 +254,7 @@ function saveConfig(newConfig) {
         if (configToSave.web3 && configToSave.web3.rpc_urls) {
             delete configToSave.web3.rpc_urls;
         }
+        // Keys are no longer encrypted before saving. They are stored in plain text.
         const yamlStr = yaml_1.default.stringify(configToSave);
         fs_1.default.writeFileSync(configPath, yamlStr, 'utf8');
     }
@@ -160,3 +262,15 @@ function saveConfig(newConfig) {
         console.error('Failed to save config.yaml', error);
     }
 }
+function loadPolicyConfig() {
+    const policyPath = (0, paths_1.getPath)('policy.yaml');
+    if (fs_1.default.existsSync(policyPath)) {
+        try {
+            return yaml_1.default.parse(fs_1.default.readFileSync(policyPath, 'utf8')) || {};
+        }
+        catch (e) {
+            console.error('[Config] Failed to parse policy.yaml', e);
+        }
+    }
+    return {};
+}

package/dist/packages/core/src/gateway/chat.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatInteractive = chatInteractive;
+const prompts_1 = require("@clack/prompts");
+const picocolors_1 = __importDefault(require("picocolors"));
+const fs_1 = __importDefault(require("fs"));
+const paths_1 = require("../config/paths");
+async function chatInteractive() {
+    const tokenFile = (0, paths_1.getPath)('auth.token');
+    if (!fs_1.default.existsSync(tokenFile)) {
+        console.log(picocolors_1.default.red('❌ Nyxora daemon is not running. Please start it with `nyxora start`.'));
+        process.exit(1);
+    }
+    let token = fs_1.default.readFileSync(tokenFile, 'utf8').trim();
+    if (token.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(token);
+            token = parsed.token;
+        }
+        catch (e) { }
+    }
+    const logo = `
+███╗   ██╗██╗   ██╗██╗  ██╗ ██████╗ ██████╗  █████╗ 
+████╗  ██║╚██╗ ██╔╝╚██╗██╔╝██╔═══██╗██╔══██╗██╔══██╗
+██╔██╗ ██║ ╚████╔╝  ╚███╔╝ ██║   ██║██████╔╝███████║
+██║╚██╗██║  ╚██╔╝   ██╔██╗ ██║   ██║██╔══██╗██╔══██║
+██║ ╚████║   ██║   ██╔╝ ██╗╚██████╔╝██║  ██║██║  ██║
+╚═╝  ╚═══╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝
+  `;
+    console.log(picocolors_1.default.cyan(logo));
+    (0, prompts_1.intro)(picocolors_1.default.inverse(' Nyxora Interactive Shell '));
+    console.log(picocolors_1.default.gray('Type your message and press Enter. Type "exit" or press Ctrl+C to quit.\n'));
+    while (true) {
+        const input = await (0, prompts_1.text)({
+            message: picocolors_1.default.cyan('You:'),
+            placeholder: 'Send a message...',
+        });
+        if ((0, prompts_1.isCancel)(input) || input.toString().trim().toLowerCase() === 'exit' || input.toString().trim().toLowerCase() === 'quit') {
+            (0, prompts_1.cancel)('Chat session ended.');
+            process.exit(0);
+        }
+        const messageStr = input.toString().trim();
+        if (!messageStr)
+            continue;
+        const s = (0, prompts_1.spinner)();
+        s.start('Thinking...');
+        try {
+            const response = await fetch('http://localhost:3000/api/chat', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-nyxora-token': token,
+                },
+                body: JSON.stringify({ message: messageStr, session_id: 'cli-chat' })
+            });
+            if (!response.ok) {
+                s.stop(picocolors_1.default.red('API Error.'));
+                if (response.status === 401) {
+                    console.log(picocolors_1.default.red('Unauthorized: Token is invalid. Please restart the daemon.'));
+                    process.exit(1);
+                }
+                else {
+                    console.log(picocolors_1.default.red(`Gateway returned status ${response.status}`));
+                }
+                continue;
+            }
+            const data = await response.json();
+            s.stop(picocolors_1.default.green('Nyxora:'));
+            let finalReply = data.response || '';
+            // Strip <think> tags for clean UI
+            finalReply = finalReply.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+            console.log(finalReply + '\n');
+        }
+        catch (error) {
+            s.stop(picocolors_1.default.red('Connection failed.'));
+            console.log(picocolors_1.default.red(`Is the daemon running? (http://localhost:3000)`));
+        }
+    }
+}

package/dist/packages/core/src/gateway/cli.js

@@ -156,6 +156,69 @@ async function main() {
             process.exit(1);
         }
     }
+    // Check for chat command
+    if (process.argv.includes('chat')) {
+        const { chatInteractive } = await Promise.resolve().then(() => __importStar(require('./chat')));
+        await chatInteractive();
+        process.exit(0);
+    }
+    // Check for uninstall command
+    if (process.argv.includes('uninstall')) {
+        console.log(picocolors_1.default.cyan('\n🗑️  Nyxora Uninstallation Wizard'));
+        let shouldProceed = process.argv.includes('--force') || process.argv.includes('-y');
+        if (!shouldProceed) {
+            const proceed = await (0, prompts_1.confirm)({
+                message: picocolors_1.default.bgRed(picocolors_1.default.white(' ⚠️ WARNING ')) + picocolors_1.default.yellow(' This will PERMANENTLY WIPE the AI\'s local memory, securely delete your Private Key and Master Key from the OS Keyring, and remove all configuration.\n\nAre you absolutely sure you want to proceed?'),
+            });
+            if ((0, prompts_1.isCancel)(proceed) || !proceed)
+                process.exit(0);
+        }
+        console.log(picocolors_1.default.gray('\nStarting cleanup process...'));
+        // 1. Wipe AI Memory
+        try {
+            const { Logger } = require('../memory/logger');
+            const logger = new Logger();
+            logger.clear();
+            console.log(picocolors_1.default.green('✅ AI memory wiped successfully.'));
+        }
+        catch (e) {
+            console.log(picocolors_1.default.gray('⚠️  Could not clear AI memory (may not exist).'));
+        }
+        // 2. Delete OS Keyring entries
+        try {
+            const { Entry } = await Promise.resolve().then(() => __importStar(require('@napi-rs/keyring')));
+            const walletEntry = new Entry('nyxora', 'wallet');
+            try {
+                await walletEntry.deletePassword();
+            }
+            catch (e) { }
+            console.log(picocolors_1.default.green('✅ Wallet key removed from OS Keyring.'));
+            const masterEntry = new Entry('nyxora', 'config_master');
+            try {
+                await masterEntry.deletePassword();
+            }
+            catch (e) { }
+            console.log(picocolors_1.default.green('✅ Master key removed from OS Keyring.'));
+        }
+        catch (e) {
+            console.log(picocolors_1.default.gray('⚠️  Could not access OS Keyring.'));
+        }
+        // 3. Delete ~/.nyxora directory
+        try {
+            const targetDir = path_1.default.join(os_1.default.homedir(), '.nyxora');
+            if (fs_1.default.existsSync(targetDir)) {
+                fs_1.default.rmSync(targetDir, { recursive: true, force: true });
+                console.log(picocolors_1.default.green('✅ Configuration directory (~/.nyxora) deleted.'));
+            }
+        }
+        catch (e) {
+            console.log(picocolors_1.default.red(`❌ Failed to delete ~/.nyxora: ${e.message}`));
+        }
+        console.log(picocolors_1.default.cyan('\n✨ Nyxora data has been completely removed.'));
+        console.log(picocolors_1.default.white('To complete the uninstallation, run:'));
+        console.log(picocolors_1.default.green('  npm uninstall -g nyxora\n'));
+        process.exit(0);
+    }
     // 2. Setup boilerplate files if in global mode and they don't exist
     let isFirstBoot = false;
     if (isGlobalMode) {