nyxora 26.7.2 → 26.7.4

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

@@ -102,7 +102,9 @@ function loadRpcConfig() {
 function saveRpcConfig(rpcUrls) {
     const rpcPath = (0, paths_1.getPath)('rpc_key.yaml');
     try {
-        fs_1.default.writeFileSync(rpcPath, yaml_1.default.stringify(rpcUrls), 'utf8');
+        const tempPath = rpcPath + '.tmp.' + Date.now();
+        fs_1.default.writeFileSync(tempPath, yaml_1.default.stringify(rpcUrls), 'utf8');
+        fs_1.default.renameSync(tempPath, rpcPath);
     }
     catch (error) {
         console.error('Failed to save rpc_key.yaml', error);
@@ -203,7 +205,8 @@ function loadConfig() {
             memory: parsed.memory || { type: 'file', path: './memory.json' },
             web3: { ...parsed.web3, rpc_urls: rpcUrls },
             integrations: parsed.integrations || {
-                telegram: { enabled: false }
+                telegram: { enabled: false },
+                discord: { enabled: false }
             },
             security: parsed.security || { dashboard_password: '123456' },
             skills: parsed.skills
@@ -244,7 +247,8 @@ function loadConfig() {
             memory: { type: 'file', path: './memory.json' },
             web3: { rpc_urls: rpcUrls },
             integrations: {
-                telegram: { enabled: false }
+                telegram: { enabled: false },
+                discord: { enabled: false }
             }
         };
         cachedNyxoraConfig = defaultConfig;
@@ -263,7 +267,9 @@ function saveConfig(newConfig) {
         }
         // 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');
+        const tempPath = configPath + '.tmp.' + Date.now();
+        fs_1.default.writeFileSync(tempPath, yamlStr, 'utf8');
+        fs_1.default.renameSync(tempPath, configPath);
     }
     catch (error) {
         console.error('Failed to save config.yaml', error);

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

@@ -48,13 +48,14 @@ async function chatInteractive() {
         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' })
+            // Use SSE streaming endpoint for real-time token output
+            const params = new URLSearchParams({
+                message: messageStr,
+                session_id: 'cli-chat',
+                token,
+            });
+            const response = await fetch(`http://localhost:3000/api/chat/stream?${params}`, {
+                headers: { 'x-nyxora-token': token },
             });
             if (!response.ok) {
                 s.stop(picocolors_1.default.red('API Error.'));
@@ -67,12 +68,54 @@ async function chatInteractive() {
                 }
                 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');
+            let firstChunk = true;
+            let finalReply = '';
+            // Read SSE stream line by line
+            const reader = response.body?.getReader();
+            const decoder = new TextDecoder();
+            if (reader) {
+                let buffer = '';
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (!line.startsWith('data: '))
+                            continue;
+                        const raw = line.slice(6).trim();
+                        if (raw === '[DONE]')
+                            break;
+                        try {
+                            const data = JSON.parse(raw);
+                            if (data.progress) {
+                                // Show tool progress on same line, overwriting previous
+                                if (firstChunk) {
+                                    s.stop(picocolors_1.default.cyan('Nyxora:'));
+                                    firstChunk = false;
+                                }
+                                process.stdout.write(`\r${picocolors_1.default.italic(picocolors_1.default.gray(data.progress))}   `);
+                            }
+                            if (data.chunk) {
+                                if (firstChunk) {
+                                    s.stop(picocolors_1.default.green('Nyxora:'));
+                                    process.stdout.write('\n');
+                                    firstChunk = false;
+                                }
+                                // Clear progress line if any, then write chunk
+                                finalReply += data.chunk;
+                                process.stdout.write(data.chunk);
+                            }
+                        }
+                        catch { }
+                    }
+                }
+            }
+            // Newline after streaming completes
+            if (!firstChunk)
+                process.stdout.write('\n\n');
             // Check for pending transactions
             try {
                 const txRes = await fetch('http://localhost:3000/api/transactions', {

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

@@ -39,6 +39,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const safeLogger_1 = require("../utils/safeLogger");
 (0, safeLogger_1.initSafeLogger)();
+const dns_1 = __importDefault(require("dns"));
+// Fix Node 18+ native fetch randomly failing on dual-stack VPS (IPv6 issues)
+dns_1.default.setDefaultResultOrder('ipv4first');
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDiscordBot = startDiscordBot;
+const discord_js_1 = require("discord.js");
+const reasoning_1 = require("../agent/reasoning");
+const parser_1 = require("../config/parser");
+let discordClient = null;
+function startDiscordBot() {
+    const config = (0, parser_1.loadConfig)();
+    const token = config.integrations?.discord?.bot_token;
+    if (!token || !config.integrations?.discord?.enabled) {
+        console.log('[Discord] Bot is disabled or missing bot_token in config.yaml.');
+        return;
+    }
+    discordClient = new discord_js_1.Client({
+        intents: [
+            discord_js_1.GatewayIntentBits.Guilds,
+            discord_js_1.GatewayIntentBits.GuildMessages,
+            discord_js_1.GatewayIntentBits.MessageContent,
+        ],
+    });
+    discordClient.once('ready', () => {
+        console.log(`🤖 Discord Bot is online and logged in as ${discordClient?.user?.tag}`);
+    });
+    discordClient.on('messageCreate', async (message) => {
+        // Ignore messages from bots
+        if (message.author.bot)
+            return;
+        // Check if the bot is mentioned
+        if (discordClient?.user && message.mentions.has(discordClient.user)) {
+            // Strip the mention from the message
+            const prompt = message.content.replace(new RegExp(`<@!?${discordClient.user.id}>`, 'g'), '').trim();
+            if (!prompt)
+                return;
+            console.log(`[Discord] Received mention from ${message.author.username} in #${message.channel.name}: ${prompt}`);
+            // Send initial thinking indicator
+            let replyMessage = null;
+            try {
+                replyMessage = await message.reply('⏳ *Thinking...*');
+            }
+            catch (err) {
+                console.error('[Discord] Failed to send initial reply', err);
+                return;
+            }
+            const onProgress = async (progressText) => {
+                try {
+                    if (replyMessage) {
+                        await replyMessage.edit(`*${progressText}*`);
+                    }
+                }
+                catch (err) {
+                    // Ignore minor edit errors
+                }
+            };
+            try {
+                const sessionId = `discord_${message.author.id}`;
+                const response = await (0, reasoning_1.processUserInput)(prompt, 'user', onProgress, sessionId);
+                // Clean up thought blocks if any
+                let finalResponse = response.replace(/<thought>[\s\S]*?<\/thought>\n?/g, '').replace(/<think>[\s\S]*?<\/think>\n?/g, '');
+                if (replyMessage) {
+                    // Discord has a 2000 character limit per message
+                    if (finalResponse.length > 2000) {
+                        await replyMessage.edit(finalResponse.slice(0, 1997) + '...');
+                    }
+                    else {
+                        await replyMessage.edit(finalResponse);
+                    }
+                }
+            }
+            catch (error) {
+                console.error('[Discord] Error processing message:', error);
+                if (replyMessage) {
+                    await replyMessage.edit('❌ Sorry, I encountered an error while processing your request.');
+                }
+            }
+        }
+    });
+    discordClient.login(token).catch(err => {
+        console.error('[Discord] Failed to login:', err);
+    });
+}

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

@@ -15,7 +15,9 @@ const CREDENTIALS_PATH = (0, paths_1.getPath)('google-credentials.json');
 const FALLBACK_TOKEN_PATH = (0, paths_1.getPath)('google-tokens.json');
 const SCOPES = [
     'https://www.googleapis.com/auth/gmail.readonly',
+    'https://www.googleapis.com/auth/gmail.send',
     'https://www.googleapis.com/auth/calendar.readonly',
+    'https://www.googleapis.com/auth/calendar.events',
     'https://www.googleapis.com/auth/documents.readonly',
     'https://www.googleapis.com/auth/spreadsheets',
     'https://www.googleapis.com/auth/forms.responses.readonly',

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

@@ -51,19 +51,22 @@ const customTx_1 = require("../web3/skills/customTx");
 const executeDefi_1 = require("../web3/skills/executeDefi");
 const revokeApprovals_1 = require("../web3/skills/revokeApprovals");
 const telegram_1 = require("./telegram");
+const discordAdapter_1 = require("./discordAdapter");
 const bridgeWatcher_1 = require("../agent/bridgeWatcher");
 const eventListener_1 = require("../web3/eventListener");
 const googleAuthModule_1 = require("./googleAuthModule");
 const legalGenerator_1 = require("./legalGenerator");
 const episodic_1 = require("../memory/episodic");
 const reflection_1 = require("../memory/reflection");
-const honchoDaemon_1 = require("../agent/honchoDaemon");
+const nyxDaemon_1 = require("../agent/nyxDaemon");
 // Initialize Google Auth
 (0, googleAuthModule_1.initGoogleAuth)();
-// Start Background Honcho Daemon
-honchoDaemon_1.honchoDaemon.start();
+// Start Background Nyx Daemon
+nyxDaemon_1.nyxDaemon.start();
 // Synchronize all active skills to config.yaml on startup
 (0, skillManager_1.syncAllSkillsToConfig)();
+// Start messaging adapters
+(0, discordAdapter_1.startDiscordBot)();
 const util_1 = __importDefault(require("util"));
 // Intercept console.log and console.error
 const originalLog = console.log;
@@ -115,7 +118,7 @@ app.use('/api', (req, res, next) => {
     if (allowedPaths.includes(currentPath) || allowedPaths.includes(currentPath.replace(/\/$/, ''))) {
         return next();
     }
-    const token = req.headers['x-nyxora-token'];
+    const token = req.headers['x-nyxora-token'] || req.query.token;
     const validation = (0, state_1.validateToken)(token);
     if (!validation.valid) {
         console.error(`[Auth] Rejected ${req.method} ${req.originalUrl} - Received invalid token.`);
@@ -174,7 +177,9 @@ app.post('/api/upload-google-credentials', (req, res) => {
         const credsPath = (0, paths_1.getPath)('google-credentials.json');
         // The format needs to wrap it in "web" or "installed"
         const finalPayload = credentials.client_id ? { installed: credentials } : credentials;
-        fs_1.default.writeFileSync(credsPath, JSON.stringify(finalPayload, null, 2));
+        const tempPath = credsPath + '.tmp.' + Date.now();
+        fs_1.default.writeFileSync(tempPath, JSON.stringify(finalPayload, null, 2));
+        fs_1.default.renameSync(tempPath, credsPath);
         // Re-initialize google auth module
         (0, googleAuthModule_1.initGoogleAuth)();
         res.json({ success: true });
@@ -609,7 +614,7 @@ app.post('/api/transactions/:id/approve', async (req, res) => {
         transactionManager_1.txManager.updateStatus(id, 'approved', 'Executing on-chain...');
         res.json({ success: true, status: 'processing', message: 'Transaction submitted to background processing.' });
         // Execute in background
-        (async () => {
+        const txPromise = (async () => {
             try {
                 let result = '';
                 if (tx.type === 'transfer') {
@@ -689,6 +694,7 @@ app.post('/api/transactions/:id/approve', async (req, res) => {
                 reasoning_1.logger.addEntry({ role: 'assistant', content: `❌ **Transaction Failed**\n\n${err.message}` }, sessionId);
             }
         })();
+        transactionManager_1.txManager.trackPromise(txPromise);
     }
     catch (err) {
         transactionManager_1.txManager.updateStatus(req.params.id, 'failed', err.message);
@@ -975,7 +981,47 @@ app.post('/api/chat', async (req, res) => {
         res.status(500).json({ error: error.message });
     }
 });
-// --- Memory API Endpoints ---
+// --- Streaming Chat Endpoint (SSE) ---
+// Sends LLM tokens to the client as they arrive via Server-Sent Events.
+// The old /api/chat endpoint remains untouched for backward compatibility.
+app.get('/api/chat/stream', async (req, res) => {
+    const { message, session_id } = req.query;
+    if (!message) {
+        res.status(400).json({ error: 'Message is required' });
+        return;
+    }
+    // Setup SSE headers
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no'); // Disable Nginx buffering
+    res.flushHeaders();
+    const sendEvent = (data) => {
+        res.write(`data: ${JSON.stringify(data)}\n\n`);
+    };
+    const onChunk = (text) => sendEvent({ chunk: text });
+    const onProgress = (msg) => sendEvent({ progress: msg });
+    try {
+        await (0, reasoning_1.processUserInputStream)(message, onChunk, onProgress, session_id);
+        // Trigger memory mechanisms after response completes
+        resetIdleTimer(session_id);
+        messageCounter++;
+        if (messageCounter >= 5) {
+            messageCounter = 0;
+            reflection_1.ReflectionEngine.runReflection(session_id).then(() => {
+                const { PromotionEngine } = require('../memory/promotionEngine');
+                PromotionEngine.runPromotionAndDecay();
+            }).catch(console.error);
+        }
+    }
+    catch (err) {
+        sendEvent({ error: err.message });
+    }
+    finally {
+        res.write('data: [DONE]\n\n');
+        res.end();
+    }
+});
 app.get('/api/memory', (req, res) => {
     try {
         const memories = episodic_1.episodicDB.getMemories();
@@ -988,9 +1034,10 @@ app.get('/api/memory', (req, res) => {
 app.delete('/api/memory/all', (req, res) => {
     try {
         episodic_1.episodicDB.clearAllMemories();
+        episodic_1.episodicDB.clearAllPersonas();
         const { PromotionEngine } = require('../memory/promotionEngine');
         PromotionEngine.runPromotionAndDecay();
-        res.json({ success: true, message: "Episodic memory wiped completely." });
+        res.json({ success: true, message: "Episodic memory and persona traits wiped completely." });
     }
     catch (error) {
         res.status(500).json({ error: error.message });
@@ -1158,11 +1205,13 @@ async function startServer() {
         }
     });
     let isShuttingDown = false;
-    const gracefulShutdown = () => {
+    const gracefulShutdown = async () => {
         if (isShuttingDown)
             return;
         isShuttingDown = true;
         console.log('[Nyxora Gateway] Received shutdown signal. Closing server...');
+        // Wait for active transactions
+        await transactionManager_1.txManager.waitForAll(10000);
         if (server.closeAllConnections) {
             server.closeAllConnections();
         }

package/dist/packages/core/src/gateway/setup-ml.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupMlEngine = setupMlEngine;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const prompts_1 = require("@clack/prompts");
+const appDir = path_1.default.join(os_1.default.homedir(), '.nyxora');
+const mlEngineDir = path_1.default.join(appDir, 'ml-engine');
+const venvDir = path_1.default.join(mlEngineDir, 'venv');
+const sourceReqPath = path_1.default.join(process.cwd(), 'packages', 'ml-engine', 'requirements.txt');
+function runCommand(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, { cwd, stdio: 'ignore' });
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Command ${command} ${args.join(' ')} failed with code ${code}`));
+        });
+        child.on('error', reject);
+    });
+}
+async function setupMlEngine() {
+    console.log(picocolors_1.default.cyan('\n⚙️  Initializing Universal Python ML Engine...\n'));
+    const s = (0, prompts_1.spinner)();
+    try {
+        if (!fs_1.default.existsSync(mlEngineDir)) {
+            fs_1.default.mkdirSync(mlEngineDir, { recursive: true });
+        }
+        s.start('Creating Python Virtual Environment (venv)...');
+        if (!fs_1.default.existsSync(venvDir)) {
+            await runCommand('python3', ['-m', 'venv', venvDir], mlEngineDir);
+        }
+        s.stop(picocolors_1.default.green('Virtual Environment created successfully.'));
+        s.start('Installing heavy Data Science & AI dependencies (this may take a while)...');
+        const pipPath = path_1.default.join(venvDir, 'bin', 'pip');
+        // Upgrade pip
+        await runCommand(pipPath, ['install', '--upgrade', 'pip'], mlEngineDir);
+        // Install requirements
+        if (fs_1.default.existsSync(sourceReqPath)) {
+            await runCommand(pipPath, ['install', '-r', sourceReqPath], mlEngineDir);
+            s.stop(picocolors_1.default.green('Dependencies installed successfully.'));
+        }
+        else {
+            s.stop(picocolors_1.default.yellow('requirements.txt not found. Skipping dependency installation.'));
+        }
+        (0, prompts_1.note)('The Python Sidecar is ready.\nIt will automatically start in the background when you run `nyxora start`.', 'ML Engine Configured');
+    }
+    catch (error) {
+        s.stop(picocolors_1.default.red('Failed to setup ML Engine.'));
+        console.error(picocolors_1.default.red(`Error: ${error.message}`));
+        console.log(picocolors_1.default.yellow('\nPlease ensure python3 and python3-venv are installed on your system.'));
+    }
+}
+// Allow running directly
+if (require.main === module) {
+    setupMlEngine().then(() => process.exit(0));
+}

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

@@ -23,13 +23,33 @@ async function runSetupWizard() {
   `;
     console.log(picocolors_1.default.cyan(logo));
     (0, prompts_1.intro)(picocolors_1.default.inverse(' Nyxora CLI Setup '));
+    try {
+        const nodeVersion = parseInt(process.versions.node.split('.')[0], 10);
+        if (nodeVersion < 18) {
+            console.error(picocolors_1.default.red(`\n❌ Unsupported Node.js version. Nyxora requires Node.js 18 or higher. You are running v${process.versions.node}`));
+            process.exit(1);
+        }
+        const { execSync } = require('child_process');
+        const pythonCmd = process.platform === 'win32' ? 'python' : 'python3';
+        const pyVersionStr = execSync(`${pythonCmd} -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        const [major, minor] = pyVersionStr.split('.').map(Number);
+        if (major < 3 || (major === 3 && minor < 10)) {
+            console.error(picocolors_1.default.red(`\n❌ Unsupported Python version. Nyxora ML Engine requires Python 3.10+. You are running v${pyVersionStr}`));
+            process.exit(1);
+        }
+        (0, prompts_1.note)(`Node.js: v${process.versions.node}\nPython: v${pyVersionStr}`, 'System Requirements Met');
+    }
+    catch (error) {
+        console.error(picocolors_1.default.red(`\n❌ Python 3 is not installed or not in your PATH. Nyxora requires Python 3.10+ for the ML Engine.`));
+        process.exit(1);
+    }
     const appDir = (0, paths_1.getAppDir)();
     const config = (0, parser_1.loadConfig)();
     const disclaimer = `Nyxora is a Web3 Assistant that operates with full access under your control.
 
 Critical Precautions:
-- Your Private Key is the lifeblood of your assets. NEVER copy or share the keystore.json file.
-- Any instructions you provide via Telegram or Dashboard can trigger on-chain transactions.
+- Your Private Key is the lifeblood of your assets. NEVER copy or share your vault.key file or OS Keyring password.
+- Any instructions you provide via Telegram, Discord, or the Dashboard can trigger on-chain transactions.
 - It is recommended to use a smart AI model for maximum accuracy.
 
 By using Nyxora, you retain full control over your own keys.`;
@@ -300,6 +320,7 @@ Provider: ${config.llm.provider}`;
         message: '💬 Select Integration Channels to enable:',
         options: [
             { value: 'telegram', label: 'Telegram Bot', hint: 'Requires Token' },
+            { value: 'discord', label: 'Discord Bot', hint: 'Requires Token' },
             { value: 'dashboard', label: 'Local Web Dashboard', hint: 'enabled by default' },
         ],
         initialValues: ['dashboard'],
@@ -405,6 +426,15 @@ Provider: ${config.llm.provider}`;
             }
         }
     }
+    const setupDiscord = activeChannels.includes('discord');
+    let discordToken = '';
+    if (setupDiscord) {
+        discordToken = (await (0, prompts_1.password)({
+            message: 'Enter Discord Bot Token (Leave empty if already set):',
+        }));
+        if ((0, prompts_1.isCancel)(discordToken))
+            return process.exit(0);
+    }
     // --- SAVING ---
     // Update Config.yaml
     config.llm.provider = provider;
@@ -456,6 +486,12 @@ Provider: ${config.llm.provider}`;
     else if (config.integrations.telegram) {
         delete config.integrations.telegram.authorized_chat_id;
     }
+    if (!config.integrations.discord)
+        config.integrations.discord = { enabled: false };
+    config.integrations.discord.enabled = setupDiscord;
+    if (setupDiscord && discordToken) {
+        config.integrations.discord.bot_token = discordToken;
+    }
     (0, parser_1.saveConfig)(config);
     // Sync disabled_skills.json based on user selection
     const allWeb3Skills = [
@@ -507,7 +543,7 @@ Provider: ${config.llm.provider}`;
         getBalance: 'get_balance',
         getMyAddress: 'get_my_address',
         checkPortfolio: 'check_portfolio',
-        getPrice: 'get_price',
+        getPrice: 'get_price_and_fiat_value',
         marketAnalysis: 'analyze_market',
         getTxHistory: 'get_tx_history',
         checkSecurity: 'check_token_security',