nyxora 1.0.0

package/src/agent/reasoning.ts

@@ -0,0 +1,232 @@
+import * as dotenv from 'dotenv';
+dotenv.config();
+
+import fs from 'fs';
+import path from 'path';
+import { OpenAI } from 'openai';
+import { loadConfig } from '../config/parser';
+import { Logger } from '../memory/logger';
+import { Tracker } from '../gateway/tracker';
+import { getBalanceToolDefinition, getBalance } from '../web3/skills/getBalance';
+import { transferToolDefinition, transferNative } from '../web3/skills/transfer';
+import { getPriceToolDefinition, getPrice } from '../web3/skills/getPrice';
+import { swapTokenToolDefinition, swapToken } from '../web3/skills/swapToken';
+import { getPath } from '../config/paths';
+
+export const logger = new Logger();
+
+let currentKeyIndex = 0;
+
+function getOpenAI(): OpenAI {
+  const config = loadConfig();
+  
+  if (config.llm.provider === 'ollama') {
+    return new OpenAI({
+      baseURL: process.env.OLLAMA_BASE_URL ? `${process.env.OLLAMA_BASE_URL}/v1` : 'http://localhost:11434/v1',
+      apiKey: 'ollama', // API key is not required for local Ollama
+    });
+  }
+
+  // Get API key from config (UI) or fallback to .env
+  let apiKey = '';
+  
+  if (config.llm.api_keys && config.llm.api_keys.length > 0) {
+    // Filter out empty keys
+    const keys = config.llm.api_keys.filter(k => k.trim() !== '');
+    if (keys.length > 0) {
+      currentKeyIndex = currentKeyIndex % keys.length;
+      apiKey = keys[currentKeyIndex];
+      console.log(`[LLM] Using rotated API Key (${currentKeyIndex + 1}/${keys.length}): ${apiKey.substring(0, 4)}...`);
+      currentKeyIndex++; // Increment for next request
+    }
+  }
+
+  // Fallbacks if no valid keys found in config
+  if (!apiKey) {
+    if (config.llm.provider === 'gemini') {
+      apiKey = process.env.GEMINI_API_KEY || '';
+    } else {
+      apiKey = process.env.OPENAI_API_KEY || '';
+    }
+    if (!apiKey) {
+      throw new Error(`No API Key found for ${config.llm.provider} in config or .env`);
+    }
+    console.log(`[LLM] Using default API Key from .env`);
+  }
+
+  if (config.llm.provider === 'gemini') {
+    return new OpenAI({
+      baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+      apiKey: apiKey,
+    });
+  } else {
+    return new OpenAI({
+      apiKey: apiKey,
+    });
+  }
+}
+
+function getSystemPrompt() {
+  const config = loadConfig();
+  let basePrompt = `You are an autonomous Web3 agent operating on EVM chains.
+You are equipped with a native wallet. 
+CRITICAL RULE: You must always reply in the exact same language that the user uses to talk to you. If the user speaks Indonesian, reply in Indonesian. If they speak English, reply in English.
+CRITICAL RULE: If the user asks to check "my balance", "saldo saya", or anything about their own wallet, DO NOT ask them for an address. You must immediately call the get_balance tool and LEAVE THE ADDRESS PARAMETER EMPTY. The system will automatically use the injected private key wallet.
+Always use the tools to interact with the blockchain.
+If the user doesn't specify a chain, default to: ${config.agent.default_chain}.`;
+
+  // Read IDENTITY.md for core AI persona
+  try {
+    const identityMdPath = getPath('IDENTITY.md');
+    if (fs.existsSync(identityMdPath)) {
+      const identityInstructions = fs.readFileSync(identityMdPath, 'utf8');
+      basePrompt += `\n\n--- CORE IDENTITY & PERSONA ---\n${identityInstructions}`;
+    }
+  } catch (error) {
+    console.error('Failed to read IDENTITY.md:', error);
+  }
+
+  // Read user.md for custom instructions
+  try {
+    const userMdPath = getPath('user.md');
+    if (fs.existsSync(userMdPath)) {
+      const customInstructions = fs.readFileSync(userMdPath, 'utf8');
+      basePrompt += `\n\n--- CUSTOM USER INSTRUCTIONS ---\n${customInstructions}`;
+    }
+  } catch (error) {
+    console.error('Failed to read user.md:', error);
+  }
+
+  return basePrompt;
+}
+
+export async function processUserInput(input: string): Promise<string> {
+  const config = loadConfig();
+  // Add user input to memory
+  logger.addEntry({ role: 'user', content: input });
+
+  const history = logger.getHistory();
+  
+  // Format messages for OpenAI
+  const messages: any[] = [
+    { role: 'system', content: getSystemPrompt() },
+    ...history.map(m => {
+      const msg: any = { role: m.role, content: m.content || "" };
+      if (m.name) msg.name = m.name;
+      if (m.tool_call_id) msg.tool_call_id = m.tool_call_id;
+      if (m.tool_calls) msg.tool_calls = m.tool_calls;
+      return msg;
+    })
+  ];
+
+  try {
+    if (config.llm.provider !== 'openai' && config.llm.provider !== 'ollama' && config.llm.provider !== 'gemini') {
+      return `Provider ${config.llm.provider} is configured, but currently only OpenAI, Ollama, and Gemini adapters are implemented.`;
+    }
+
+    const openai = getOpenAI();
+    const response = await openai.chat.completions.create({
+      model: config.llm.model,
+      temperature: config.llm.temperature,
+      messages: messages,
+      tools: [getBalanceToolDefinition as any, transferToolDefinition as any, getPriceToolDefinition as any, swapTokenToolDefinition as any],
+      tool_choice: "auto",
+    });
+
+    const responseMessage = response.choices[0].message;
+    
+    // Log tracking
+    Tracker.addMessage();
+    if (response.usage?.total_tokens) {
+      Tracker.addTokens(response.usage.total_tokens, config.llm.provider);
+    }
+    Tracker.addEvent('llm.response', { provider: config.llm.provider, tool_calls: responseMessage.tool_calls?.length || 0 });
+
+    // Log assistant response
+    logger.addEntry({
+      role: 'assistant',
+      content: responseMessage.content || "",
+      tool_calls: responseMessage.tool_calls,
+    });
+
+    // Check if the model wants to call a tool
+    if (responseMessage.tool_calls && responseMessage.tool_calls.length > 0) {
+      for (const _toolCall of responseMessage.tool_calls) {
+        const toolCall = _toolCall as any;
+        if (toolCall.function.name === 'get_balance') {
+          const args = JSON.parse(toolCall.function.arguments);
+          const balanceResult = await getBalance(args.chainName, args.address);
+          
+          logger.addEntry({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            name: toolCall.function.name,
+            content: balanceResult,
+          });
+        } else if (toolCall.function.name === 'transfer_native') {
+          const args = JSON.parse(toolCall.function.arguments);
+          const transferResult = await transferNative(args.chainName, args.toAddress, args.amountEth);
+          
+          logger.addEntry({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            name: toolCall.function.name,
+            content: transferResult,
+          });
+        } else if (toolCall.function.name === 'get_price') {
+          const args = JSON.parse(toolCall.function.arguments);
+          const priceResult = await getPrice(args.coinId);
+          
+          logger.addEntry({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            name: toolCall.function.name,
+            content: priceResult,
+          });
+        } else if (toolCall.function.name === 'swap_token') {
+          const args = JSON.parse(toolCall.function.arguments);
+          const swapResult = await swapToken(args.chainName, args.fromToken, args.toToken, args.amount);
+          
+          logger.addEntry({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            name: toolCall.function.name,
+            content: swapResult,
+          });
+        }
+      }
+
+      // Second call to get the final answer after tool execution
+      const secondMessages = [
+        { role: 'system', content: getSystemPrompt() },
+        ...logger.getHistory().map(m => {
+          const msg: any = { role: m.role, content: m.content || "" };
+          if (m.name) msg.name = m.name;
+          if (m.tool_call_id) msg.tool_call_id = m.tool_call_id;
+          if (m.tool_calls) msg.tool_calls = m.tool_calls;
+          return msg;
+        })
+      ];
+
+      const openai = getOpenAI();
+      const secondResponse = await openai.chat.completions.create({
+        model: config.llm.model,
+        messages: secondMessages,
+      });
+
+      if (secondResponse.usage?.total_tokens) {
+        Tracker.addTokens(secondResponse.usage.total_tokens, config.llm.provider);
+      }
+      Tracker.addEvent('llm.final_response', { provider: config.llm.provider });
+
+      const finalContent = secondResponse.choices[0].message.content || "";
+      logger.addEntry({ role: 'assistant', content: finalContent });
+      return finalContent;
+    }
+
+    return responseMessage.content || "No response generated.";
+  } catch (error: any) {
+    console.error("LLM Error:", error);
+    return `Error connecting to AI Provider: ${error.message}`;
+  }
+}

package/src/config/parser.d.ts

@@ -0,0 +1,17 @@
+export interface OpenWebConfig {
+    agent: {
+        name: string;
+        default_chain: string;
+    };
+    llm: {
+        provider: 'openai' | 'anthropic' | 'ollama';
+        model: string;
+        temperature: number;
+    };
+    memory: {
+        type: string;
+        path: string;
+    };
+}
+export declare function loadConfig(): OpenWebConfig;
+//# sourceMappingURL=parser.d.ts.map

package/src/config/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["parser.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,GAAG,EAAE;QACH,QAAQ,EAAE,QAAQ,GAAG,WAAW,GAAG,QAAQ,CAAC;QAC5C,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAED,wBAAgB,UAAU,IAAI,aAAa,CAc1C"}

package/src/config/parser.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const fs_1 = __importDefault(require("fs"));
+const yaml_1 = __importDefault(require("yaml"));
+const path_1 = __importDefault(require("path"));
+function loadConfig() {
+    const configPath = path_1.default.resolve(process.cwd(), 'config.yaml');
+    try {
+        const file = fs_1.default.readFileSync(configPath, 'utf8');
+        const parsed = yaml_1.default.parse(file);
+        return parsed;
+    }
+    catch (error) {
+        console.error('Failed to load config.yaml. Using default configuration.', error);
+        return {
+            agent: { name: 'OpenWeb-Default', default_chain: 'base' },
+            llm: { provider: 'openai', model: 'gpt-4o-mini', temperature: 0.2 },
+            memory: { type: 'file', path: './memory.json' }
+        };
+    }
+}
+//# sourceMappingURL=parser.js.map

package/src/config/parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.js","sourceRoot":"","sources":["parser.ts"],"names":[],"mappings":";;;;;AAoBA,gCAcC;AAlCD,4CAAoB;AACpB,gDAAwB;AACxB,gDAAwB;AAkBxB,SAAgB,UAAU;IACxB,MAAM,UAAU,GAAG,cAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,aAAa,CAAC,CAAC;IAC9D,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,YAAE,CAAC,YAAY,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;QACjD,MAAM,MAAM,GAAG,cAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAChC,OAAO,MAAuB,CAAC;IACjC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,0DAA0D,EAAE,KAAK,CAAC,CAAC;QACjF,OAAO;YACL,KAAK,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,EAAE;YACzD,GAAG,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,GAAG,EAAE;YACnE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE;SAChD,CAAC;IACJ,CAAC;AACH,CAAC"}

package/src/config/parser.ts

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import yaml from 'yaml';
+import path from 'path';
+import { getPath } from './paths';
+
+export interface NyxoraConfig {
+  agent: {
+    name: string;
+    default_chain: string;
+  };
+  llm: {
+    provider: 'openai' | 'anthropic' | 'ollama' | 'gemini';
+    model: string;
+    temperature: number;
+    api_keys?: string[];
+  };
+  memory: {
+    type: string;
+    path: string;
+  };
+}
+
+export function loadConfig(): NyxoraConfig {
+  const configPath = getPath('config.yaml');
+  try {
+    const file = fs.readFileSync(configPath, 'utf8');
+    const parsed = yaml.parse(file);
+    return parsed as NyxoraConfig;
+  } catch (error) {
+    console.error('Failed to load config.yaml. Using default configuration.', error);
+    return {
+      agent: { name: 'Nyxora-Default', default_chain: 'base' },
+      llm: { provider: 'openai', model: 'gpt-4o-mini', temperature: 0.2, api_keys: [] },
+      memory: { type: 'file', path: './memory.json' }
+    };
+  }
+}
+
+export function saveConfig(newConfig: NyxoraConfig): void {
+  const configPath = getPath('config.yaml');
+  try {
+    const yamlStr = yaml.stringify(newConfig);
+    fs.writeFileSync(configPath, yamlStr, 'utf8');
+  } catch (error) {
+    console.error('Failed to save config.yaml', error);
+  }
+}

package/src/config/paths.ts

@@ -0,0 +1,33 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+let isGlobalModeCache: boolean | null = null;
+
+export function getAppDir(): string {
+  // Check if .env or config.yaml exists in current working directory
+  if (isGlobalModeCache === null) {
+    const localEnv = path.join(process.cwd(), '.env');
+    const localConfig = path.join(process.cwd(), 'config.yaml');
+    
+    if (fs.existsSync(localEnv) || fs.existsSync(localConfig)) {
+      isGlobalModeCache = false; // Local manual mode
+    } else {
+      isGlobalModeCache = true; // Global CLI mode
+    }
+  }
+
+  if (isGlobalModeCache) {
+    const globalDir = path.join(os.homedir(), '.nyxora');
+    if (!fs.existsSync(globalDir)) {
+      fs.mkdirSync(globalDir, { recursive: true });
+    }
+    return globalDir;
+  }
+
+  return process.cwd();
+}
+
+export function getPath(filename: string): string {
+  return path.join(getAppDir(), filename);
+}

package/src/gateway/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/src/gateway/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["cli.ts"],"names":[],"mappings":""}

package/src/gateway/cli.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline_1 = __importDefault(require("readline"));
+const reasoning_1 = require("../agent/reasoning");
+const dotenv = __importStar(require("dotenv"));
+const parser_1 = require("../config/parser");
+dotenv.config();
+const rl = readline_1.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+const config = (0, parser_1.loadConfig)();
+console.log(`================================`);
+console.log(`🤖 OpenWeb CLI Agent Started`);
+console.log(`📋 Agent Name: ${config.agent.name}`);
+console.log(`🔗 Default Chain: ${config.agent.default_chain}`);
+console.log(`🧠 AI Provider: ${config.llm.provider} (${config.llm.model})`);
+console.log(`================================`);
+console.log(`Type 'exit' or 'quit' to stop.\n`);
+function ask() {
+    rl.question('👤 You: ', async (input) => {
+        if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
+            console.log('Goodbye!');
+            rl.close();
+            return;
+        }
+        if (input.trim() === '') {
+            ask();
+            return;
+        }
+        console.log('🤖 Agent thinking...');
+        try {
+            const response = await (0, reasoning_1.processUserInput)(input);
+            console.log(`\n🤖 OpenWeb: ${response}\n`);
+        }
+        catch (error) {
+            console.log(`\n❌ Error: ${error.message}\n`);
+        }
+        ask();
+    });
+}
+ask();
+//# sourceMappingURL=cli.js.map

package/src/gateway/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["cli.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,wDAAgC;AAChC,kDAAsD;AACtD,+CAAiC;AACjC,6CAA8C;AAE9C,MAAM,CAAC,MAAM,EAAE,CAAC;AAEhB,MAAM,EAAE,GAAG,kBAAQ,CAAC,eAAe,CAAC;IAClC,KAAK,EAAE,OAAO,CAAC,KAAK;IACpB,MAAM,EAAE,OAAO,CAAC,MAAM;CACvB,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAA,mBAAU,GAAE,CAAC;AAE5B,OAAO,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAC;AAChD,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAC;AAC5C,OAAO,CAAC,GAAG,CAAC,kBAAkB,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;AACnD,OAAO,CAAC,GAAG,CAAC,qBAAqB,MAAM,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC;AAC/D,OAAO,CAAC,GAAG,CAAC,mBAAmB,MAAM,CAAC,GAAG,CAAC,QAAQ,KAAK,MAAM,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC;AAC5E,OAAO,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAC;AAChD,OAAO,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAC;AAEhD,SAAS,GAAG;IACV,EAAE,CAAC,QAAQ,CAAC,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;QACtC,IAAI,KAAK,CAAC,WAAW,EAAE,KAAK,MAAM,IAAI,KAAK,CAAC,WAAW,EAAE,KAAK,MAAM,EAAE,CAAC;YACrE,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YACxB,EAAE,CAAC,KAAK,EAAE,CAAC;YACX,OAAO;QACT,CAAC;QAED,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YACxB,GAAG,EAAE,CAAC;YACN,OAAO;QACT,CAAC;QAED,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAC;QACpC,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,IAAA,4BAAgB,EAAC,KAAK,CAAC,CAAC;YAC/C,OAAO,CAAC,GAAG,CAAC,iBAAiB,QAAQ,IAAI,CAAC,CAAC;QAC7C,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,OAAO,CAAC,GAAG,CAAC,cAAc,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;QAC/C,CAAC;QAED,GAAG,EAAE,CAAC;IACR,CAAC,CAAC,CAAC;AACL,CAAC;AAED,GAAG,EAAE,CAAC"}

package/src/gateway/cli.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import * as dotenv from 'dotenv';
+import open from 'open';
+import { getAppDir } from '../config/paths';
+import { startServer } from './server';
+
+// 1. Determine configuration directory
+const appDir = getAppDir();
+const isGlobalMode = appDir !== process.cwd();
+
+console.log(`================================`);
+console.log(`🤖 Nyxora CLI Agent Booting Up...`);
+console.log(`📂 Config Directory: ${appDir}`);
+console.log(`================================`);
+
+// 2. Setup boilerplate files if in global mode and they don't exist
+if (isGlobalMode) {
+  const globalEnvPath = path.join(appDir, '.env');
+  const globalUserMdPath = path.join(appDir, 'user.md');
+  const globalIdentityMdPath = path.join(appDir, 'IDENTITY.md');
+
+  // Copy .env.example to ~/.nyxora/.env if it doesn't exist
+  if (!fs.existsSync(globalEnvPath)) {
+    const exampleEnvPath = path.resolve(__dirname, '../../../.env.example');
+    if (fs.existsSync(exampleEnvPath)) {
+      fs.copyFileSync(exampleEnvPath, globalEnvPath);
+      console.log(`[Setup] Created default .env at ${globalEnvPath}`);
+    } else {
+      fs.writeFileSync(globalEnvPath, '# Nyxora Environment Variables\nOPENAI_API_KEY=\nGEMINI_API_KEY=\nTELEGRAM_BOT_TOKEN=\n');
+    }
+  }
+
+  if (!fs.existsSync(globalUserMdPath)) {
+    fs.writeFileSync(globalUserMdPath, 'Tuliskan instruksi kustom, aturan khusus, profil pengguna, atau persona yang Anda inginkan untuk Nyxora AI di file ini.\n');
+  }
+
+  if (!fs.existsSync(globalIdentityMdPath)) {
+    fs.writeFileSync(globalIdentityMdPath, 'Kamu adalah Nyxora, asisten Web3 pintar.\n');
+  }
+}
+
+// 3. Load Environment Variables from the determined directory
+dotenv.config({ path: path.join(appDir, '.env') });
+
+// 4. Start the Express API Server (which also serves the static dashboard and Telegram bot)
+startServer();
+
+// 5. Open the Dashboard in the default browser
+const PORT = process.env.PORT || 3000;
+setTimeout(() => {
+  const url = `http://localhost:${PORT}`;
+  console.log(`🌐 Opening Dashboard at ${url}`);
+  open(url);
+}, 1500);

package/src/gateway/server.ts

@@ -0,0 +1,131 @@
+import express from 'express';
+import cors from 'cors';
+import path from 'path';
+import * as dotenv from 'dotenv';
+import { getPath } from '../config/paths';
+
+dotenv.config({ path: getPath('.env') });
+
+import { processUserInput, logger } from '../agent/reasoning';
+import { loadConfig, saveConfig } from '../config/parser';
+import { Tracker } from './tracker';
+import { getBalanceToolDefinition } from '../web3/skills/getBalance';
+import { transferToolDefinition } from '../web3/skills/transfer';
+import { getPriceToolDefinition } from '../web3/skills/getPrice';
+import { swapTokenToolDefinition } from '../web3/skills/swapToken';
+import { startTelegramBot } from './telegram';
+
+// Intercept console.log and console.error
+const originalLog = console.log;
+const originalError = console.error;
+
+console.log = function (...args) {
+  Tracker.addGatewayLog(args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' '));
+  originalLog.apply(console, args);
+};
+
+console.error = function (...args) {
+  Tracker.addGatewayLog(args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' '), { level: 'error' });
+  originalError.apply(console, args);
+};
+
+const app = express();
+app.use(cors());
+app.use(express.json());
+
+// Serve static frontend from dashboard/dist
+app.use(express.static(path.join(__dirname, '../../../dashboard/dist')));
+
+app.get('/api/history', (req, res) => {
+  try {
+    const history = logger.getHistory();
+    // Filter out internal system prompt for the frontend
+    const cleanHistory = history.filter((msg: any) => msg.role !== 'system');
+    res.json(cleanHistory);
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.delete('/api/history', (req, res) => {
+  try {
+    logger.clear();
+    Tracker.addEvent('memory.cleared');
+    res.json({ success: true });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.get('/api/config', (req, res) => {
+  try {
+    const config = loadConfig();
+    res.json(config);
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.post('/api/config', (req, res) => {
+  try {
+    // Save new configuration to file
+    saveConfig(req.body);
+    Tracker.addEvent('config.updated', { provider: req.body.llm?.provider });
+    res.json({ success: true });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.get('/api/stats', (req, res) => {
+  res.json(Tracker.getStats());
+});
+
+app.get('/api/logs', (req, res) => {
+  res.json(Tracker.getLogs());
+});
+
+app.get('/api/skills', (req, res) => {
+  res.json([
+    getBalanceToolDefinition,
+    transferToolDefinition,
+    getPriceToolDefinition,
+    swapTokenToolDefinition
+  ]);
+});
+
+app.post('/api/chat', async (req, res) => {
+  try {
+    const { message } = req.body;
+    if (!message) {
+      return res.status(400).json({ error: 'Message is required' });
+    }
+    
+    // Process input (this will automatically add to memory)
+    const response = await processUserInput(message);
+    
+    res.json({ response });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Fallback for React Router (Single Page Application)
+app.get('*', (req, res) => {
+  res.sendFile(path.join(__dirname, '../../../dashboard/dist/index.html'));
+});
+
+export function startServer() {
+  const PORT = process.env.PORT || 3000;
+  app.listen(PORT, () => {
+    console.log(`🤖 Nyxora API Server running on port ${PORT}`);
+    
+    // Start the Telegram bot listener
+    startTelegramBot();
+  });
+}
+
+// Start server if this file is run directly
+if (require.main === module) {
+  startServer();
+}