nyxora 1.2.0 → 1.4.0

package/dist/agent/limitOrderManager.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelLimitOrderToolDefinition = exports.listLimitOrdersToolDefinition = exports.createLimitOrderToolDefinition = exports.limitOrderManager = exports.LimitOrderManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const parser_1 = require("../config/parser");
+const paths_1 = require("../config/paths");
+const tokens_1 = require("../web3/utils/tokens");
+const swapToken_1 = require("../web3/skills/swapToken");
+const transactionManager_1 = require("./transactionManager");
+const reasoning_1 = require("./reasoning");
+class LimitOrderManager {
+    filePath;
+    orders = [];
+    monitorInterval = null;
+    constructor() {
+        const config = (0, parser_1.loadConfig)();
+        this.filePath = (0, paths_1.getPath)(config.memory?.path ? config.memory.path.replace('memory.json', 'orders.json') : 'orders.json');
+        this.loadOrders();
+    }
+    loadOrders() {
+        if (fs_1.default.existsSync(this.filePath)) {
+            try {
+                const data = fs_1.default.readFileSync(this.filePath, 'utf-8');
+                this.orders = JSON.parse(data);
+            }
+            catch (error) {
+                this.orders = [];
+            }
+        }
+    }
+    saveOrders() {
+        try {
+            fs_1.default.writeFileSync(this.filePath, JSON.stringify(this.orders, null, 2));
+        }
+        catch (error) { }
+    }
+    createOrder(chainName, fromToken, toToken, amountStr, targetPriceUsd, condition) {
+        const id = `order_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`;
+        const order = {
+            id, chainName, fromToken, toToken, amountStr, targetPriceUsd, condition, status: 'pending', createdAt: Date.now()
+        };
+        this.orders.push(order);
+        this.saveOrders();
+        return `Limit order created successfully. ID: ${id}. The system will monitor ${fromToken} price on ${chainName} and execute the swap to ${toToken} when price is ${condition} $${targetPriceUsd}.`;
+    }
+    listOrders() {
+        const pending = this.orders.filter(o => o.status === 'pending');
+        if (pending.length === 0)
+            return "No active limit orders.";
+        let report = "Active Limit Orders:\n";
+        pending.forEach(o => {
+            report += `- [${o.id}] Swap ${o.amountStr} ${o.fromToken} -> ${o.toToken} on ${o.chainName} when ${o.fromToken} is ${o.condition} $${o.targetPriceUsd}\n`;
+        });
+        return report;
+    }
+    cancelOrder(id) {
+        const order = this.orders.find(o => o.id === id);
+        if (!order)
+            return `Order ${id} not found.`;
+        if (order.status !== 'pending')
+            return `Order ${id} cannot be cancelled because it is ${order.status}.`;
+        order.status = 'cancelled';
+        this.saveOrders();
+        return `Order ${id} cancelled successfully.`;
+    }
+    startMonitor() {
+        if (this.monitorInterval)
+            clearInterval(this.monitorInterval);
+        // Monitor every 60 seconds
+        this.monitorInterval = setInterval(() => this.checkOrders(), 60000);
+        console.log('[LimitOrderManager] Order monitoring started (interval: 60s)');
+    }
+    async checkOrders() {
+        const pending = this.orders.filter(o => o.status === 'pending');
+        if (pending.length === 0)
+            return;
+        for (const order of pending) {
+            try {
+                let tokenAddress = (0, tokens_1.resolveToken)(order.fromToken, order.chainName);
+                if (tokenAddress === "0x0000000000000000000000000000000000000000") {
+                    tokenAddress = (0, tokens_1.resolveToken)("W" + order.fromToken, order.chainName);
+                }
+                const res = await fetch(`https://api.dexscreener.com/latest/dex/tokens/${tokenAddress}`);
+                if (!res.ok)
+                    continue;
+                const data = await res.json();
+                if (!data.pairs || data.pairs.length === 0)
+                    continue;
+                let pair = data.pairs.find((p) => p.chainId === order.chainName) || data.pairs[0];
+                const currentPrice = parseFloat(pair.priceUsd);
+                let shouldExecute = false;
+                if (order.condition === 'above' && currentPrice >= order.targetPriceUsd)
+                    shouldExecute = true;
+                if (order.condition === 'below' && currentPrice <= order.targetPriceUsd)
+                    shouldExecute = true;
+                if (shouldExecute) {
+                    console.log(`[LimitOrderManager] Condition met for order ${order.id}. Current price $${currentPrice} is ${order.condition} $${order.targetPriceUsd}. Executing...`);
+                    // 1. Prepare Swap
+                    const prepareResult = await (0, swapToken_1.prepareSwapToken)(order.chainName, order.fromToken, order.toToken, order.amountStr, 'auto');
+                    // 2. Extract Tx ID
+                    const txMatch = prepareResult.match(/Transaction ID: ([\w-]+)\./);
+                    if (!txMatch) {
+                        order.status = 'failed';
+                        this.saveOrders();
+                        (0, reasoning_1.processUserInput)(`Limit order ${order.id} execution failed during preparation. Output: ${prepareResult}`, 'system').catch(() => { });
+                        continue;
+                    }
+                    const txId = txMatch[1];
+                    const tx = transactionManager_1.txManager.getTransaction(txId);
+                    if (!tx)
+                        throw new Error("Transaction not found in manager");
+                    // 3. Execute Swap automatically
+                    const executeResult = await (0, swapToken_1.executeSwap)(order.chainName, tx.details);
+                    if (executeResult.includes('successful')) {
+                        transactionManager_1.txManager.updateStatus(txId, 'executed', executeResult);
+                        order.status = 'executed';
+                        this.saveOrders();
+                        (0, reasoning_1.processUserInput)(`Limit order ${order.id} just EXECUTED automatically! Price hit $${currentPrice}. Swap result: ${executeResult}. Please notify the user immediately!`, 'system').catch(() => { });
+                    }
+                    else {
+                        transactionManager_1.txManager.updateStatus(txId, 'failed', executeResult);
+                        order.status = 'failed';
+                        this.saveOrders();
+                        (0, reasoning_1.processUserInput)(`Limit order ${order.id} FAILED to execute. Price hit $${currentPrice} but execution failed: ${executeResult}. Please notify the user.`, 'system').catch(() => { });
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`[LimitOrderManager] Error checking order ${order.id}:`, error.message);
+            }
+        }
+    }
+}
+exports.LimitOrderManager = LimitOrderManager;
+exports.limitOrderManager = new LimitOrderManager();
+exports.createLimitOrderToolDefinition = {
+    type: "function",
+    function: {
+        name: "create_limit_order",
+        description: "Creates an automatic cut-loss or take-profit limit order. The system will automatically execute the swap when the price condition is met.",
+        parameters: {
+            type: "object",
+            properties: {
+                chainName: { type: "string", enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"] },
+                fromToken: { type: "string", description: "Token to sell" },
+                toToken: { type: "string", description: "Token to buy" },
+                amountStr: { type: "string", description: "Amount to sell" },
+                targetPriceUsd: { type: "number", description: "Target price in USD for the fromToken" },
+                condition: { type: "string", enum: ["above", "below"], description: "Trigger when price goes above (take-profit) or below (cut-loss) target" }
+            },
+            required: ["chainName", "fromToken", "toToken", "amountStr", "targetPriceUsd", "condition"],
+        },
+    },
+};
+exports.listLimitOrdersToolDefinition = {
+    type: "function",
+    function: {
+        name: "list_limit_orders",
+        description: "Lists all active automated limit orders.",
+        parameters: { type: "object", properties: {}, required: [] },
+    },
+};
+exports.cancelLimitOrderToolDefinition = {
+    type: "function",
+    function: {
+        name: "cancel_limit_order",
+        description: "Cancels an active limit order by ID.",
+        parameters: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"],
+        },
+    },
+};

package/dist/agent/reasoning.js

@@ -17,6 +17,19 @@ const swapToken_1 = require("../web3/skills/swapToken");
 const bridgeToken_1 = require("../web3/skills/bridgeToken");
 const mintNft_1 = require("../web3/skills/mintNft");
 const customTx_1 = require("../web3/skills/customTx");
+const createWallet_1 = require("../web3/skills/createWallet");
+const checkSecurity_1 = require("../web3/skills/checkSecurity");
+const marketAnalysis_1 = require("../web3/skills/marketAnalysis");
+const checkPortfolio_1 = require("../web3/skills/checkPortfolio");
+const limitOrderManager_1 = require("./limitOrderManager");
+const updateProfile_1 = require("./updateProfile");
+const updateSecurityPolicy_1 = require("../system/skills/updateSecurityPolicy");
+const readFile_1 = require("../system/skills/readFile");
+const writeFile_1 = require("../system/skills/writeFile");
+const executeShell_1 = require("../system/skills/executeShell");
+const browseWeb_1 = require("../system/skills/browseWeb");
+const installSkill_1 = require("../system/skills/installSkill");
+const pluginManager_1 = require("../system/pluginManager");
 const paths_1 = require("../config/paths");
 exports.logger = new logger_1.Logger();
 let currentKeyIndex = 0;
@@ -108,6 +121,17 @@ If the user doesn't specify a chain, default to: ${config.agent.default_chain}.`
     catch (error) {
         console.error('Failed to read user.md:', error);
     }
+    // Read security_policy.md for NLP security constraints
+    try {
+        const policyPath = (0, paths_1.getPath)('security_policy.md');
+        if (fs_1.default.existsSync(policyPath)) {
+            const securityInstructions = fs_1.default.readFileSync(policyPath, 'utf8');
+            basePrompt += `\n\n--- SECURITY POLICY (MANDATORY RULES) ---\n${securityInstructions}\n\nCRITICAL: If the user asks you to perform an action that violates the Security Policy above, YOU MUST NOT EXECUTE IT DIRECTLY. Instead, ask for their explicit permission first.`;
+        }
+    }
+    catch (error) {
+        console.error('Failed to read security_policy.md:', error);
+    }
     return basePrompt;
 }
 async function processUserInput(input, role = 'user') {
@@ -150,7 +174,22 @@ async function processUserInput(input, role = 'user') {
                 swapToken_1.swapTokenToolDefinition,
                 bridgeToken_1.bridgeTokenToolDefinition,
                 mintNft_1.mintNftToolDefinition,
-                customTx_1.customTxToolDefinition
+                customTx_1.customTxToolDefinition,
+                createWallet_1.createWalletToolDefinition,
+                checkSecurity_1.checkSecurityToolDefinition,
+                marketAnalysis_1.marketAnalysisToolDefinition,
+                checkPortfolio_1.checkPortfolioToolDefinition,
+                limitOrderManager_1.createLimitOrderToolDefinition,
+                limitOrderManager_1.listLimitOrdersToolDefinition,
+                limitOrderManager_1.cancelLimitOrderToolDefinition,
+                updateProfile_1.updateProfileToolDefinition,
+                updateSecurityPolicy_1.updateSecurityPolicyToolDefinition,
+                readFile_1.readLocalFileToolDefinition,
+                writeFile_1.writeLocalFileToolDefinition,
+                executeShell_1.runTerminalCommandToolDefinition,
+                browseWeb_1.browseWebsiteToolDefinition,
+                installSkill_1.installExternalSkillToolDefinition,
+                ...pluginManager_1.pluginManager.getToolDefinitions()
             ],
             tool_choice: "auto",
         });
@@ -171,76 +210,112 @@ async function processUserInput(input, role = 'user') {
         if (responseMessage.tool_calls && responseMessage.tool_calls.length > 0) {
             for (const _toolCall of responseMessage.tool_calls) {
                 const toolCall = _toolCall;
-                if (toolCall.function.name === 'get_balance') {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    const balanceResult = await (0, getBalance_1.getBalance)(args.chainName, args.address, args.token);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: balanceResult,
-                    });
-                }
-                else if (toolCall.function.name === 'transfer_token' || toolCall.function.name === 'transfer_native') {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    const transferResult = await (0, transfer_1.prepareTransfer)(args.chainName, args.toAddress, args.amountStr || args.amountEth, args.token);
-                    exports.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 (0, getPrice_1.getPrice)(args.coinId);
-                    exports.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 (0, swapToken_1.prepareSwapToken)(args.chainName, args.fromToken, args.toToken, args.amountStr || args.amount, args.mode, args.providerName);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: swapResult,
-                    });
-                }
-                else if (toolCall.function.name === 'bridge_token') {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    const bridgeResult = await (0, bridgeToken_1.prepareBridgeToken)(args.fromChainName, args.toChainName, args.fromToken, args.toToken, args.amountStr, args.mode, args.providerName);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: bridgeResult,
-                    });
-                }
-                else if (toolCall.function.name === 'mint_nft') {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    const mintResult = await (0, mintNft_1.prepareMintNft)(args.chainName, args.contractAddress, args.functionSignature, args.argsStr, args.valueEth);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: mintResult,
-                    });
-                }
-                else if (toolCall.function.name === 'custom_tx') {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    const customResult = await (0, customTx_1.prepareCustomTx)(args.chainName, args.toAddress, args.dataHex, args.valueEth, args.gasLimitStr);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: customResult,
-                    });
+                let result = "";
+                const args = JSON.parse(toolCall.function.arguments);
+                const toolName = toolCall.function.name;
+                switch (toolName) {
+                    case 'get_balance': {
+                        result = await (0, getBalance_1.getBalance)(args.chainName, args.address, args.token);
+                        break;
+                    }
+                    case 'transfer_token':
+                    case 'transfer_native': {
+                        result = await (0, transfer_1.prepareTransfer)(args.chainName, args.toAddress, args.amountStr || args.amountEth, args.token);
+                        break;
+                    }
+                    case 'get_price': {
+                        result = await (0, getPrice_1.getPrice)(args.coinId);
+                        break;
+                    }
+                    case 'swap_token': {
+                        result = await (0, swapToken_1.prepareSwapToken)(args.chainName, args.fromToken, args.toToken, args.amountStr || args.amount, args.mode, args.providerName);
+                        break;
+                    }
+                    case 'bridge_token': {
+                        result = await (0, bridgeToken_1.prepareBridgeToken)(args.fromChainName, args.toChainName, args.fromToken, args.toToken, args.amountStr, args.mode, args.providerName);
+                        break;
+                    }
+                    case 'mint_nft': {
+                        result = await (0, mintNft_1.prepareMintNft)(args.chainName, args.contractAddress, args.functionSignature, args.argsStr, args.valueEth);
+                        break;
+                    }
+                    case 'custom_tx': {
+                        result = await (0, customTx_1.prepareCustomTx)(args.chainName, args.toAddress, args.dataHex, args.valueEth, args.gasLimitStr);
+                        break;
+                    }
+                    case 'create_wallet': {
+                        result = await (0, createWallet_1.createWallet)();
+                        break;
+                    }
+                    case 'check_token_security': {
+                        result = await (0, checkSecurity_1.checkTokenSecurity)(args.chainName, args.contractAddress);
+                        break;
+                    }
+                    case 'analyze_market': {
+                        result = await (0, marketAnalysis_1.analyzeMarket)(args.chainName, args.tokenAddressOrSymbol);
+                        break;
+                    }
+                    case 'check_portfolio': {
+                        result = await (0, checkPortfolio_1.checkPortfolio)(args.chainName, args.address);
+                        break;
+                    }
+                    case 'create_limit_order': {
+                        result = limitOrderManager_1.limitOrderManager.createOrder(args.chainName, args.fromToken, args.toToken, args.amountStr, args.targetPriceUsd, args.condition);
+                        break;
+                    }
+                    case 'list_limit_orders': {
+                        result = limitOrderManager_1.limitOrderManager.listOrders();
+                        break;
+                    }
+                    case 'cancel_limit_order': {
+                        result = limitOrderManager_1.limitOrderManager.cancelOrder(args.id);
+                        break;
+                    }
+                    case 'update_profile': {
+                        result = (0, updateProfile_1.updateProfile)(args.content, args.mode);
+                        break;
+                    }
+                    case 'update_security_policy': {
+                        result = (0, updateSecurityPolicy_1.updateSecurityPolicy)(args.rule, args.action);
+                        break;
+                    }
+                    case 'read_local_file': {
+                        result = (0, readFile_1.readLocalFile)(args.filePath);
+                        break;
+                    }
+                    case 'write_local_file': {
+                        result = (0, writeFile_1.writeLocalFile)(args.filePath, args.content);
+                        break;
+                    }
+                    case 'run_terminal_command': {
+                        result = await (0, executeShell_1.runTerminalCommand)(args.command);
+                        break;
+                    }
+                    case 'browse_website': {
+                        result = await (0, browseWeb_1.browseWebsite)(args.url);
+                        break;
+                    }
+                    case 'install_external_skill': {
+                        result = await (0, installSkill_1.installExternalSkill)(args.url);
+                        break;
+                    }
+                    default: {
+                        const externalResult = await pluginManager_1.pluginManager.executeTool(toolName, args);
+                        if (externalResult !== null) {
+                            result = externalResult;
+                        }
+                        else {
+                            result = `Error: Tool ${toolName} is not implemented.`;
+                        }
+                        break;
+                    }
                 }
+                exports.logger.addEntry({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    name: toolName,
+                    content: result,
+                });
             }
             // Second call to get the final answer after tool execution
             const secondMessages = [

package/dist/agent/updateProfile.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateProfileToolDefinition = void 0;
+exports.updateProfile = updateProfile;
+const fs_1 = __importDefault(require("fs"));
+const paths_1 = require("../config/paths");
+function updateProfile(content, mode) {
+    try {
+        const userMdPath = (0, paths_1.getPath)('user.md');
+        if (mode === 'replace') {
+            fs_1.default.writeFileSync(userMdPath, content, 'utf8');
+            return "Profile replaced successfully. New user.md has been saved.";
+        }
+        else {
+            let existingContent = "";
+            if (fs_1.default.existsSync(userMdPath)) {
+                existingContent = fs_1.default.readFileSync(userMdPath, 'utf8');
+            }
+            const newContent = existingContent + "\n" + content;
+            fs_1.default.writeFileSync(userMdPath, newContent, 'utf8');
+            return "Profile appended successfully. New instructions added to user.md.";
+        }
+    }
+    catch (error) {
+        return `Failed to update profile: ${error.message}`;
+    }
+}
+exports.updateProfileToolDefinition = {
+    type: "function",
+    function: {
+        name: "update_profile",
+        description: "Updates or rewrites the user.md file. Use this when the user asks you to remember something about them, change their persona, or update your instructions.",
+        parameters: {
+            type: "object",
+            properties: {
+                content: {
+                    type: "string",
+                    description: "The content to write or append to user.md",
+                },
+                mode: {
+                    type: "string",
+                    enum: ["append", "replace"],
+                    description: "Whether to append the content to the existing file or replace the entire file.",
+                }
+            },
+            required: ["content", "mode"],
+        },
+    },
+};

package/dist/gateway/server.js

@@ -12,6 +12,8 @@ const reasoning_1 = require("../agent/reasoning");
 const parser_1 = require("../config/parser");
 const tracker_1 = require("./tracker");
 const transactionManager_1 = require("../agent/transactionManager");
+const limitOrderManager_1 = require("../agent/limitOrderManager");
+const pluginManager_1 = require("../system/pluginManager");
 const transfer_1 = require("../web3/skills/transfer");
 const swapToken_1 = require("../web3/skills/swapToken");
 const getBalance_1 = require("../web3/skills/getBalance");
@@ -180,6 +182,10 @@ app.use((req, res, next) => {
     }
 });
 function startServer() {
+    pluginManager_1.pluginManager.loadPlugins().then(() => {
+        console.log(`[PluginManager] Finished loading external skills.`);
+    });
+    limitOrderManager_1.limitOrderManager.startMonitor();
     const PORT = process.env.PORT || 3000;
     app.listen(PORT, () => {
         console.log(`🤖 Nyxora API Server running on port ${PORT}`);

package/dist/gateway/telegram.js

@@ -28,6 +28,11 @@ function startTelegramBot() {
             const text = msg.text;
             if (!text)
                 return;
+            if (text === '/clear') {
+                reasoning_1.logger.clear();
+                bot.sendMessage(chatId, '✅ Memori AI telah dihapus. Mari kita mulai obrolan baru!');
+                return;
+            }
             // Log incoming message
             console.log(`[Telegram] Received from ${msg.from?.first_name}: ${text}`);
             // Send typing action to Telegram

package/dist/system/pluginManager.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginManager = exports.PluginManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class PluginManager {
+    skills = new Map();
+    async loadPlugins() {
+        const pluginsDir = path_1.default.join(process.cwd(), 'src', 'external_skills');
+        if (!fs_1.default.existsSync(pluginsDir)) {
+            fs_1.default.mkdirSync(pluginsDir, { recursive: true });
+            return;
+        }
+        const files = fs_1.default.readdirSync(pluginsDir);
+        for (const file of files) {
+            if (file.endsWith('.js') || file.endsWith('.ts')) {
+                try {
+                    // Dynamic import requires relative path from this file or absolute path
+                    // For TS compiled to JS, absolute path is safer
+                    const absolutePath = path_1.default.resolve(pluginsDir, file);
+                    // Note: In development with ts-node, requiring .ts works. 
+                    // In production, we need compiled .js files.
+                    const module = require(absolutePath);
+                    if (module.toolDefinition && module.execute) {
+                        const toolName = module.toolDefinition.function.name;
+                        this.skills.set(toolName, module);
+                        console.log(`[PluginManager] Loaded external skill: ${toolName}`);
+                    }
+                }
+                catch (error) {
+                    console.error(`[PluginManager] Failed to load plugin ${file}:`, error);
+                }
+            }
+        }
+    }
+    getToolDefinitions() {
+        return Array.from(this.skills.values()).map(skill => skill.toolDefinition);
+    }
+    async executeTool(toolName, args) {
+        const skill = this.skills.get(toolName);
+        if (skill) {
+            try {
+                return await skill.execute(args);
+            }
+            catch (error) {
+                return `External skill ${toolName} failed: ${error.message}`;
+            }
+        }
+        return null; // Tool not found in external skills
+    }
+}
+exports.PluginManager = PluginManager;
+exports.pluginManager = new PluginManager();

package/dist/system/skills/browseWeb.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browseWebsiteToolDefinition = void 0;
+exports.browseWebsite = browseWebsite;
+async function browseWebsite(url) {
+    try {
+        const response = await fetch(url, {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Nyxora/1.0',
+            }
+        });
+        if (!response.ok) {
+            return `Error: Failed to fetch URL, Status: ${response.status} ${response.statusText}`;
+        }
+        const html = await response.text();
+        // A very basic HTML to text stripping to avoid exceeding context limits
+        // In a production app, we would use cheerio or puppeteer.
+        const text = html
+            .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+            .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')
+            .replace(/<[^>]+>/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+        // Limit to first 20000 characters to prevent context overflow
+        if (text.length > 20000) {
+            return text.substring(0, 20000) + "... [Content Truncated]";
+        }
+        return text;
+    }
+    catch (error) {
+        return `Failed to browse website: ${error.message}`;
+    }
+}
+exports.browseWebsiteToolDefinition = {
+    type: "function",
+    function: {
+        name: "browse_website",
+        description: "Fetches and reads the textual content of a webpage.",
+        parameters: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "The URL of the webpage to read.",
+                }
+            },
+            required: ["url"],
+        },
+    },
+};

package/dist/system/skills/executeShell.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTerminalCommandToolDefinition = void 0;
+exports.runTerminalCommand = runTerminalCommand;
+const child_process_1 = require("child_process");
+function runTerminalCommand(command) {
+    return new Promise((resolve) => {
+        (0, child_process_1.exec)(command, { maxBuffer: 1024 * 1024 * 10 }, (error, stdout, stderr) => {
+            let output = "";
+            if (stdout)
+                output += `STDOUT:\n${stdout}\n`;
+            if (stderr)
+                output += `STDERR:\n${stderr}\n`;
+            if (error)
+                output += `ERROR:\n${error.message}\n`;
+            if (!output)
+                output = "Command executed successfully with no output.";
+            resolve(output);
+        });
+    });
+}
+exports.runTerminalCommandToolDefinition = {
+    type: "function",
+    function: {
+        name: "run_terminal_command",
+        description: "Executes a shell/terminal command on the user's host machine. Use this to install packages, run scripts, manage processes, etc.",
+        parameters: {
+            type: "object",
+            properties: {
+                command: {
+                    type: "string",
+                    description: "The terminal command to execute.",
+                }
+            },
+            required: ["command"],
+        },
+    },
+};