nyxora 26.6.19 → 26.6.21

package/packages/core/src/gateway/chat.ts

@@ -0,0 +1,85 @@
+import { intro, text, spinner, isCancel, cancel } from '@clack/prompts';
+import pc from 'picocolors';
+import fs from 'fs';
+import { getPath } from '../config/paths';
+
+export async function chatInteractive() {
+  const tokenFile = getPath('auth.token');
+  if (!fs.existsSync(tokenFile)) {
+    console.log(pc.red('❌ Nyxora daemon is not running. Please start it with `nyxora start`.'));
+    process.exit(1);
+  }
+
+  let token = fs.readFileSync(tokenFile, 'utf8').trim();
+  if (token.startsWith('{')) {
+    try {
+      const parsed = JSON.parse(token);
+      token = parsed.token;
+    } catch (e) {}
+  }
+
+  const logo = `
+███╗   ██╗██╗   ██╗██╗  ██╗ ██████╗ ██████╗  █████╗ 
+████╗  ██║╚██╗ ██╔╝╚██╗██╔╝██╔═══██╗██╔══██╗██╔══██╗
+██╔██╗ ██║ ╚████╔╝  ╚███╔╝ ██║   ██║██████╔╝███████║
+██║╚██╗██║  ╚██╔╝   ██╔██╗ ██║   ██║██╔══██╗██╔══██║
+██║ ╚████║   ██║   ██╔╝ ██╗╚██████╔╝██║  ██║██║  ██║
+╚═╝  ╚═══╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝
+  `;
+
+  console.log(pc.cyan(logo));
+  intro(pc.inverse(' Nyxora Interactive Shell '));
+  console.log(pc.gray('Type your message and press Enter. Type "exit" or press Ctrl+C to quit.\n'));
+
+  while (true) {
+    const input = await text({
+      message: pc.cyan('You:'),
+      placeholder: 'Send a message...',
+    });
+
+    if (isCancel(input) || input.toString().trim().toLowerCase() === 'exit' || input.toString().trim().toLowerCase() === 'quit') {
+      cancel('Chat session ended.');
+      process.exit(0);
+    }
+
+    const messageStr = input.toString().trim();
+    if (!messageStr) continue;
+
+    const s = 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(pc.red('API Error.'));
+        if (response.status === 401) {
+          console.log(pc.red('Unauthorized: Token is invalid. Please restart the daemon.'));
+          process.exit(1);
+        } else {
+          console.log(pc.red(`Gateway returned status ${response.status}`));
+        }
+        continue;
+      }
+
+      const data = await response.json();
+      s.stop(pc.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(pc.red('Connection failed.'));
+      console.log(pc.red(`Is the daemon running? (http://localhost:3000)`));
+    }
+  }
+}

package/packages/core/src/gateway/cli.ts

@@ -128,6 +128,69 @@ console.log(`================================`);
     }
   }
 
+  // Check for chat command
+  if (process.argv.includes('chat')) {
+    const { chatInteractive } = await import('./chat');
+    await chatInteractive();
+    process.exit(0);
+  }
+
+  // Check for uninstall command
+  if (process.argv.includes('uninstall')) {
+    console.log(pc.cyan('\n🗑️  Nyxora Uninstallation Wizard'));
+    
+    let shouldProceed = process.argv.includes('--force') || process.argv.includes('-y');
+    
+    if (!shouldProceed) {
+      const proceed = await confirm({
+        message: pc.bgRed(pc.white(' ⚠️ WARNING ')) + pc.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 (isCancel(proceed) || !proceed) process.exit(0);
+    }
+    
+    console.log(pc.gray('\nStarting cleanup process...'));
+    
+    // 1. Wipe AI Memory
+    try {
+      const { Logger } = require('../memory/logger');
+      const logger = new Logger();
+      logger.clear();
+      console.log(pc.green('✅ AI memory wiped successfully.'));
+    } catch (e: any) {
+      console.log(pc.gray('⚠️  Could not clear AI memory (may not exist).'));
+    }
+    
+    // 2. Delete OS Keyring entries
+    try {
+      const { Entry } = await import('@napi-rs/keyring');
+      const walletEntry = new Entry('nyxora', 'wallet');
+      try { await walletEntry.deletePassword(); } catch(e) {}
+      console.log(pc.green('✅ Wallet key removed from OS Keyring.'));
+      
+      const masterEntry = new Entry('nyxora', 'config_master');
+      try { await masterEntry.deletePassword(); } catch(e) {}
+      console.log(pc.green('✅ Master key removed from OS Keyring.'));
+    } catch (e: any) {
+      console.log(pc.gray('⚠️  Could not access OS Keyring.'));
+    }
+    
+    // 3. Delete ~/.nyxora directory
+    try {
+      const targetDir = path.join(os.homedir(), '.nyxora');
+      if (fs.existsSync(targetDir)) {
+        fs.rmSync(targetDir, { recursive: true, force: true });
+        console.log(pc.green('✅ Configuration directory (~/.nyxora) deleted.'));
+      }
+    } catch (e: any) {
+      console.log(pc.red(`❌ Failed to delete ~/.nyxora: ${e.message}`));
+    }
+    
+    console.log(pc.cyan('\n✨ Nyxora data has been completely removed.'));
+    console.log(pc.white('To complete the uninstallation, run:'));
+    console.log(pc.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) {

package/packages/core/src/gateway/server.ts

@@ -42,7 +42,7 @@ import { checkPortfolioToolDefinition } from '../web3/skills/checkPortfolio';
 import { marketAnalysisToolDefinition } from '../web3/skills/marketAnalysis';
 import { executeApprove, executeAaveSupply, executeVaultDeposit, executeUniv3Mint } from '../web3/skills/executeDefi';
 import { executeRevokeApproval } from '../web3/skills/revokeApprovals';
-import { isSkillActive, toggleSkill } from '../utils/skillManager';
+import { isSkillActive, toggleSkill, syncAllSkillsToConfig } from '../utils/skillManager';
 import { executeBridge, bridgeTokenToolDefinition } from '../web3/skills/bridgeToken';
 import { executeMintNft, mintNftToolDefinition } from '../web3/skills/mintNft';
 import { executeCustomTx, customTxToolDefinition } from '../web3/skills/customTx';
@@ -51,8 +51,11 @@ import { revokeApprovalToolDefinition } from '../web3/skills/revokeApprovals';
 import { vaultDepositToolDefinition } from '../web3/skills/yieldVault';
 import { provideLiquidityToolDefinition } from '../web3/skills/provideLiquidity';
 import { getTxHistoryToolDefinition } from '../web3/skills/getTxHistory';
-import { checkRegistryStatus } from '../web3/skills/checkRegistryStatus';
+import { checkRegistryStatus, checkRegistryStatusToolDefinition } from '../web3/skills/checkRegistryStatus';
 import { createLimitOrderToolDefinition } from '../web3/skills/createLimitOrder';
+import { getUserWhitelist, saveTokenToWhitelist, removeTokenFromWhitelist } from '../utils/userWhitelistManager';
+import { getTokenMetadata } from '../web3/utils/tokens';
+import { ChainName } from '../web3/config';
 
 // System Skills
 import { browseWebsiteToolDefinition } from '../system/skills/browseWeb';
@@ -84,6 +87,9 @@ import { ReflectionEngine } from '../memory/reflection';
 // Initialize Google Auth
 initGoogleAuth();
 
+// Synchronize all active skills to config.yaml on startup
+syncAllSkillsToConfig();
+
 import util from 'util';
 
 // Intercept console.log and console.error
@@ -331,8 +337,63 @@ app.post('/api/defi-keys', (req, res) => {
   }
 });
 
+const allSkills = [
+  getBalanceToolDefinition,
+  transferToolDefinition,
+  getPriceToolDefinition,
+  swapTokenToolDefinition,
+  bridgeTokenToolDefinition,
+  mintNftToolDefinition,
+  customTxToolDefinition,
+  checkAddressToolDefinition,
+  getMyAddressToolDefinition,
+  checkSecurityToolDefinition,
+  checkPortfolioToolDefinition,
+  marketAnalysisToolDefinition,
+  manageCustomTokensDefinition,
+  aaveSupplyToolDefinition,
+  revokeApprovalToolDefinition,
+  vaultDepositToolDefinition,
+  provideLiquidityToolDefinition,
+  getTxHistoryToolDefinition,
+  createLimitOrderToolDefinition,
+  checkRegistryStatusToolDefinition
+];
+
+const systemSkills = [
+  runTerminalCommandToolDefinition,
+  readLocalFileToolDefinition,
+  writeLocalFileToolDefinition,
+  generateExcelToolDefinition,
+  browseWebsiteToolDefinition,
+  updateSecurityPolicyToolDefinition,
+
+  analyzeDocumentToolDefinition,
+  searchWebToolDefinition,
+  readGmailInboxToolDefinition,
+  listCalendarEventsToolDefinition,
+  appendRowToSheetsToolDefinition,
+  readGoogleDocsToolDefinition,
+  readGoogleFormResponsesToolDefinition,
+  editLocalFileToolDefinition,
+  gitManagerToolDefinition,
+  xManagerToolDefinition,
+  notionWorkspaceToolDefinition,
+  audioTranscribeToolDefinition,
+  summarizeTextToolDefinition
+];
+
 app.get('/api/stats', (req, res) => {
-  res.json(Tracker.getStats());
+  const stats = Tracker.getStats();
+  const dbPath = getPath('memory.db');
+  
+  const activeWeb3 = allSkills.filter(s => isSkillActive(s.function.name)).length;
+  const activeSystem = systemSkills.filter(s => isSkillActive(s.function.name)).length;
+  
+  const totalSkills = allSkills.length + systemSkills.length;
+  const activeSkills = activeWeb3 + activeSystem;
+
+  res.json({ ...stats, memoryPath: dbPath, totalSkills, activeSkills });
 });
 
 app.get('/api/logs', (req, res) => {
@@ -340,28 +401,6 @@ app.get('/api/logs', (req, res) => {
 });
 
 app.get('/api/skills', (req, res) => {
-  const allSkills = [
-    getBalanceToolDefinition,
-    transferToolDefinition,
-    getPriceToolDefinition,
-    swapTokenToolDefinition,
-    bridgeTokenToolDefinition,
-    mintNftToolDefinition,
-    customTxToolDefinition,
-    checkAddressToolDefinition,
-    getMyAddressToolDefinition,
-    checkSecurityToolDefinition,
-    checkPortfolioToolDefinition,
-    marketAnalysisToolDefinition,
-    manageCustomTokensDefinition,
-    aaveSupplyToolDefinition,
-    revokeApprovalToolDefinition,
-    vaultDepositToolDefinition,
-    provideLiquidityToolDefinition,
-    getTxHistoryToolDefinition,
-    createLimitOrderToolDefinition
-  ];
-  
   const skillsWithStatus = allSkills.map(skill => ({
     ...skill,
     isActive: isSkillActive(skill.function.name)
@@ -371,29 +410,6 @@ app.get('/api/skills', (req, res) => {
 });
 
 app.get('/api/skills/system', (req, res) => {
-  const systemSkills = [
-    runTerminalCommandToolDefinition,
-    readLocalFileToolDefinition,
-    writeLocalFileToolDefinition,
-    generateExcelToolDefinition,
-    browseWebsiteToolDefinition,
-    updateSecurityPolicyToolDefinition,
-
-    analyzeDocumentToolDefinition,
-    searchWebToolDefinition,
-    readGmailInboxToolDefinition,
-    listCalendarEventsToolDefinition,
-    appendRowToSheetsToolDefinition,
-    readGoogleDocsToolDefinition,
-    readGoogleFormResponsesToolDefinition,
-    editLocalFileToolDefinition,
-    gitManagerToolDefinition,
-    xManagerToolDefinition,
-    notionWorkspaceToolDefinition,
-    audioTranscribeToolDefinition,
-    summarizeTextToolDefinition
-  ];
-  
   const skillsWithStatus = systemSkills.map(skill => ({
     ...skill,
     isActive: isSkillActive(skill.function.name)
@@ -411,6 +427,44 @@ app.post('/api/skills/toggle', (req, res) => {
   res.json({ success: true, skillName, active });
 });
 
+// Portfolio Whitelist Routes
+app.get('/api/portfolio/whitelist', async (req, res) => {
+  const whitelist = getUserWhitelist();
+  res.json(whitelist);
+});
+
+app.post('/api/portfolio/whitelist', async (req, res) => {
+  const { walletAddress, chainName, tokenAddress, symbol, decimals } = req.body;
+  if (!walletAddress || !chainName || !tokenAddress) {
+    return res.status(400).json({ error: 'Missing required fields' });
+  }
+  await saveTokenToWhitelist(walletAddress, chainName, tokenAddress, 'manual', symbol, decimals);
+  res.json({ success: true });
+});
+
+app.delete('/api/portfolio/whitelist', (req, res) => {
+  const { walletAddress, chainName, tokenAddress } = req.body;
+  if (!walletAddress || !chainName || !tokenAddress) {
+    return res.status(400).json({ error: 'Missing required fields' });
+  }
+  removeTokenFromWhitelist(walletAddress, chainName, tokenAddress);
+  res.json({ success: true });
+});
+
+app.get('/api/portfolio/token-metadata', async (req, res) => {
+  const { chain, address } = req.query;
+  if (!chain || !address || typeof address !== 'string') {
+    return res.status(400).json({ error: 'Missing chain or address' });
+  }
+  try {
+    const client = getPublicClient(chain as ChainName);
+    const metadata = await getTokenMetadata(client, address as `0x${string}`);
+    res.json(metadata);
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
 // Google Workspace Auth Routes
 app.get('/api/auth/google/url', (req, res) => {
   const url = getAuthUrl();
@@ -603,6 +657,7 @@ let cachedTrending: string[] | null = null;
 let lastTrendingFetch = 0;
 
 let cachedPrices: Record<string, number> = {};
+let cachedPriceChanges: Record<string, number> = {};
 let lastPricesFetch = 0;
 
 app.get('/api/trending', async (req, res) => {
@@ -629,16 +684,20 @@ app.get('/api/trending', async (req, res) => {
   }
 });
 
+app.get('/api/wallet', async (req, res) => {
+  try {
+    const userAddress = await getAddress();
+    res.json({ address: userAddress });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
 app.get('/api/portfolio', async (req, res) => {
   try {
     const userAddress = await getAddress();
-    const customTokensPath = path.join(getPath('custom_tokens.json'));
-    let customTokens: Record<string, any> = {};
-    if (fs.existsSync(customTokensPath)) {
-      try {
-        customTokens = JSON.parse(fs.readFileSync(customTokensPath, 'utf8'));
-      } catch (e) {}
-    }
+    const whitelist = getUserWhitelist();
+    const userCustomTokens = whitelist[userAddress.toLowerCase()] || [];
 
     const portfolio: Record<string, any[]> = {};
     
@@ -659,11 +718,15 @@ app.get('/api/portfolio', async (req, res) => {
           });
         }
 
-        // 2. Combine TOKEN_MAP and customTokens for this chain
+        // 2. Combine TOKEN_MAP and YAML whitelist for this chain
         const tokensToQuery = { ...((TOKEN_MAP as any)[chainName] || {}) };
-        if (customTokens[chainName]) {
-          Object.assign(tokensToQuery, customTokens[chainName]);
-        }
+        
+        // Inject whitelisted tokens
+        userCustomTokens.forEach(t => {
+          if (t.chainName === chainName && t.symbol && t.address) {
+            tokensToQuery[t.symbol.toUpperCase()] = t.address;
+          }
+        });
 
         // 3. Query all ERC-20 balances in parallel
         await Promise.all(Object.entries(tokensToQuery).map(async ([symbol, address]) => {
@@ -682,7 +745,9 @@ app.get('/api/portfolio', async (req, res) => {
             } as any);
 
             const [bal, decimals] = await Promise.all([balPromise, decPromise]) as [bigint, number];
-            if (bal > 0n) {
+            const isCustom = userCustomTokens.some(t => t.chainName === chainName && t.address === address);
+            
+            if (bal > 0n || isCustom) {
               portfolio[chainName].push({
                 symbol,
                 address,
@@ -722,10 +787,12 @@ app.get('/api/portfolio', async (req, res) => {
     const uniqueAddrs = Array.from(addressesToFetch);
     const now = Date.now();
     let priceMap = cachedPrices;
+    let changeMap = cachedPriceChanges;
 
     if (uniqueAddrs.length > 0 && now - lastPricesFetch > 2 * 60 * 1000) {
       try {
         const newPrices: Record<string, number> = {};
+        const newChanges: Record<string, number> = {};
         
         await Promise.all(uniqueAddrs.map(async (addr) => {
           try {
@@ -751,8 +818,10 @@ app.get('/api/portfolio', async (req, res) => {
                    
                    if (baseAddr === addr) {
                      newPrices[addr] = parseFloat(bestPair.priceUsd);
+                     newChanges[addr] = bestPair.priceChange?.h24 || 0;
                    } else if (quoteAddr === addr && bestPair.priceNative && parseFloat(bestPair.priceNative) > 0) {
                      newPrices[addr] = parseFloat(bestPair.priceUsd) / parseFloat(bestPair.priceNative);
+                     newChanges[addr] = bestPair.priceChange?.h24 || 0;
                    }
                  }
               }
@@ -765,7 +834,9 @@ app.get('/api/portfolio', async (req, res) => {
         console.log('DexScreener Fetched Prices:', newPrices);
         
         cachedPrices = { ...cachedPrices, ...newPrices };
+        cachedPriceChanges = { ...cachedPriceChanges, ...newChanges };
         priceMap = cachedPrices;
+        changeMap = cachedPriceChanges;
         lastPricesFetch = now;
       } catch (e) {
         console.error('DexScreener fetch error:', e);
@@ -780,6 +851,7 @@ app.get('/api/portfolio', async (req, res) => {
            lookupAddr = (((TOKEN_MAP as any)[chain]?.[wToken]) || '').toLowerCase();
         }
         t.priceUsd = priceMap[lookupAddr] || 0;
+        t.priceChange24h = changeMap[lookupAddr] || 0;
       }
     }
 

package/packages/core/src/gateway/setup.ts

@@ -7,24 +7,7 @@ import { getAppDir, getPath } from '../config/paths';
 import { loadConfig, saveConfig, saveApiKeys, saveRpcConfig } from '../config/parser';
 import crypto from 'crypto';
 
-function encryptKey(privateKey: string, password: string) {
-    const salt = crypto.randomBytes(16);
-    const key = crypto.pbkdf2Sync(password, salt, 100000, 32, 'sha256');
-    const iv = crypto.randomBytes(12);
-    
-    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
-    let encrypted = cipher.update(privateKey, 'utf8', 'hex');
-    encrypted += cipher.final('hex');
-    
-    const authTag = cipher.getAuthTag().toString('hex');
-    
-    return {
-        salt: salt.toString('hex'),
-        iv: iv.toString('hex'),
-        authTag,
-        encryptedData: encrypted
-    };
-}
+
 import { generatePrivateKey, privateKeyToAccount, generateMnemonic, mnemonicToAccount, english } from 'viem/accounts';
 
 export async function runSetupWizard() {
@@ -286,9 +269,9 @@ Provider: ${config.llm.provider}`;
       privateKey = '0x' + Buffer.from(account.getHdKey().privateKey!).toString('hex');
       log.success('New Wallet Generated!');
       log.info(`Address: ${account.address}`);
-      log.info(`Private Key: ${privateKey}`);
+      log.info(`Private Key: [REDACTED - Saved securely to vault]`);
       log.info(`Seed Phrase (Mnemonic): ${seedPhrase}`);
-      log.warn('IMPORTANT: Write down these 12 words (or the Private Key) NOW! This is your ONLY backup. The credentials have been securely injected into your local OS vault.');
+      log.warn('IMPORTANT: Write down these 12 words NOW! This is your ONLY backup. The credentials have been securely injected into your local OS vault.');
     }
   }
 
@@ -356,19 +339,32 @@ Provider: ${config.llm.provider}`;
     })) as string;
     if (isCancel(telegramToken)) return process.exit(0);
 
-    if (telegramToken && !authorizedChatId) {
+    if (telegramToken && telegramToken.trim() !== '') {
+      authorizedChatId = undefined;
+    }
+
+    const activeToken = telegramToken || config.integrations?.telegram?.bot_token;
+
+    if (activeToken && !authorizedChatId) {
       const s = spinner();
       const pin = Math.floor(100000 + Math.random() * 900000).toString();
       
       note(pc.cyan(`1. Open Telegram and search for your Bot.\n2. Send this exact message to your bot:\n\n   /auth ${pin}\n\nWaiting for your message...`), 'Telegram Pairing Required');
       s.start(`Waiting for /auth ${pin} on Telegram...`);
 
+      let bot: any = null;
       try {
         const { Telegraf } = require('telegraf');
-        const bot = new Telegraf(telegramToken);
+        bot = new Telegraf(activeToken);
         let paired = false;
 
+        let failedAttempts: Record<string, number> = {};
         bot.command('auth', (ctx: any) => {
+          const chatId = ctx.chat.id.toString();
+          if (failedAttempts[chatId] >= 5) {
+             return ctx.reply('❌ Too many failed attempts. You are locked out.');
+          }
+
           const text = ctx.message.text.split(' ');
           if (text[1] === pin) {
             authorizedChatId = ctx.chat.id;
@@ -376,6 +372,7 @@ Provider: ${config.llm.provider}`;
             ctx.reply('✅ Bot successfully paired with Nyxora!');
             bot.stop();
           } else {
+            failedAttempts[chatId] = (failedAttempts[chatId] || 0) + 1;
             ctx.reply('❌ Invalid PIN.');
           }
         });
@@ -383,12 +380,25 @@ Provider: ${config.llm.provider}`;
         bot.launch();
 
         // Wait until paired
-        while (!paired) {
+        let attempts = 0;
+        while (!paired && attempts < 120) {
           await new Promise(r => setTimeout(r, 1000));
+          attempts++;
+        }
+        if (!paired) {
+            s.stop('Timeout waiting for Telegram pairing. Setup will continue, but Telegram integration is disabled.');
+            try { bot.stop(); } catch(e) {}
+            authorizedChatId = undefined;
+            telegramToken = '';
+        } else {
+            s.stop(`Bot successfully paired with Chat ID: ${authorizedChatId}`);
         }
-        s.stop(`Bot successfully paired with Chat ID: ${authorizedChatId}`);
       } catch (err: any) {
         s.stop(`Failed to start bot listener: ${err.message}. You can pair it later.`);
+        // Try to stop the bot if it was initialized before the error (L17)
+        try { 
+          if (bot) bot.stop(); 
+        } catch(e) {}
       }
     }
   }
@@ -403,11 +413,11 @@ Provider: ${config.llm.provider}`;
   config.agent.default_chain = defaultChain as string;
   
   if (!config.skills) config.skills = { web3: [], os: [] } as any;
-  config.skills.web3 = activeWeb3Skills;
-  config.skills.os = activeOsSkills;
+  config.skills!.web3 = activeWeb3Skills;
+  config.skills!.os = activeOsSkills;
 
   if (!config.channels) config.channels = { active: [] } as any;
-  config.channels.active = activeChannels;
+  config.channels!.active = activeChannels;
 
   const newApiKeys: Record<string, string> = {};
   if (apiKey) {
@@ -442,6 +452,8 @@ Provider: ${config.llm.provider}`;
   
   if (authorizedChatId) {
     config.integrations.telegram.authorized_chat_id = authorizedChatId;
+  } else if (config.integrations.telegram) {
+    delete config.integrations.telegram.authorized_chat_id;
   }
 
   saveConfig(config);

package/packages/core/src/utils/formatter.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest';
+import { formatTransactionSuccess, formatTransactionError } from './formatter';
+import { PendingTransaction } from '../agent/transactionManager';
+
+describe('Formatter Utilities', () => {
+  it('should format transaction success correctly for swap', () => {
+    const tx: PendingTransaction = {
+      id: 'test-1',
+      type: 'swap',
+      chainName: 'ethereum',
+      status: 'pending',
+      nonce: "0",
+      details: {
+        fromToken: 'eth',
+        toToken: 'usdc',
+        amountStr: '1'
+      },
+      createdAt: Date.now()
+    };
+    const rawResult = '{"txHash":"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"}';
+    const output = formatTransactionSuccess(tx, rawResult);
+    expect(output).toContain('Network:** Ethereum');
+    expect(output).toContain('Action:** Swapped 1 ETH to USDC');
+    expect(output).toContain('Tx Hash:** `0x1234...cdef`');
+  });
+
+  it('should format transaction error correctly', () => {
+    const tx: PendingTransaction = {
+      id: 'test-2',
+      type: 'bridge',
+      chainName: 'base_sepolia',
+      status: 'failed',
+      nonce: "0",
+      details: {},
+      createdAt: Date.now()
+    };
+    const output = formatTransactionError(tx, 'Insufficient funds');
+    expect(output).toContain('Transaction Failed (Base Sepolia)');
+    expect(output).toContain('Error: Insufficient funds');
+  });
+});