nyxora 26.6.21 → 26.6.23

package/packages/core/src/config/paths.ts

@@ -2,30 +2,12 @@ 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;
+  const globalDir = path.join(os.homedir(), '.nyxora');
+  if (!fs.existsSync(globalDir)) {
+    fs.mkdirSync(globalDir, { recursive: true });
   }
-
-  return process.cwd();
+  return globalDir;
 }
 
 function ensureDir(dir: string) {
@@ -47,7 +29,7 @@ export function getPath(filename: string): string {
     subDir = 'config';
   } else if (lowerFile.endsWith('.token') || lowerFile.includes('vault') || lowerFile.includes('credentials')) {
     subDir = 'auth';
-  } else if (lowerFile.endsWith('.log') || lowerFile.includes('pid')) {
+  } else if (lowerFile.endsWith('.log') || lowerFile.includes('pid') || lowerFile.includes('tracker')) {
     subDir = 'run';
   }
 

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

@@ -0,0 +1,114 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import http from 'http';
+import { validateToken } from '../utils/state';
+import { IncomingMessage } from 'http';
+
+interface BufferedLog {
+  timestamp: number;
+  message: string;
+  level: string;
+}
+
+export class WebSocketManager {
+  private wss: WebSocketServer;
+  private clients: Map<string, WebSocket> = new Map();
+  private ringBuffer: Map<string, { logs: BufferedLog[]; timeout: NodeJS.Timeout }> = new Map();
+
+  constructor(server: http.Server) {
+    this.wss = new WebSocketServer({ noServer: true });
+
+    server.on('upgrade', async (request: IncomingMessage, socket, head) => {
+      try {
+        const url = new URL(request.url || '', `http://${request.headers.host}`);
+        if (url.pathname !== '/ws/stream') {
+          socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+          socket.destroy();
+          return;
+        }
+
+        const traceId = url.searchParams.get('traceId');
+        const token = url.searchParams.get('token');
+
+        if (!traceId || !token) {
+          socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+          socket.destroy();
+          return;
+        }
+
+        // Validate Auth Token during Upgrade Handshake
+        if (!validateToken(token)) {
+          socket.write('HTTP/1.1 403 Forbidden\r\n\r\n');
+          socket.destroy();
+          return;
+        }
+
+        this.wss.handleUpgrade(request, socket, head, (ws) => {
+          this.wss.emit('connection', ws, request, traceId);
+        });
+      } catch (e) {
+        socket.write('HTTP/1.1 500 Internal Server Error\r\n\r\n');
+        socket.destroy();
+      }
+    });
+
+    this.wss.on('connection', (ws: WebSocket, request: IncomingMessage, traceId: string) => {
+      this.clients.set(traceId, ws);
+
+      ws.on('close', () => {
+        this.clients.delete(traceId);
+      });
+
+      // Flush Ring Buffer if it exists
+      const buffer = this.ringBuffer.get(traceId);
+      if (buffer) {
+        clearTimeout(buffer.timeout);
+        for (const log of buffer.logs) {
+          ws.send(JSON.stringify(log));
+        }
+        this.ringBuffer.delete(traceId);
+      }
+    });
+  }
+
+  public broadcast(traceId: string, message: string, level: string = 'info') {
+    const payload = { timestamp: Date.now(), message, level };
+    const ws = this.clients.get(traceId);
+    
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      // Client is connected, send directly
+      ws.send(JSON.stringify(payload));
+    } else {
+      // Client not connected yet, buffer the log (Anti-Race Condition)
+      let buffer = this.ringBuffer.get(traceId);
+      if (!buffer) {
+        buffer = {
+          logs: [],
+          timeout: setTimeout(() => {
+            // Drop buffer after 5 seconds if client never connects
+            this.ringBuffer.delete(traceId);
+          }, 5000)
+        };
+        this.ringBuffer.set(traceId, buffer);
+      }
+      buffer.logs.push(payload);
+    }
+  }
+
+  public broadcastAll(message: string, level: string = 'info') {
+    const payload = { timestamp: Date.now(), message, level };
+    const payloadStr = JSON.stringify(payload);
+    for (const [_, ws] of this.clients) {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(payloadStr);
+      }
+    }
+  }
+}
+
+// Global instance to be initialized in server.ts
+export let wsManager: WebSocketManager | null = null;
+
+export function initWebSocket(server: http.Server) {
+  wsManager = new WebSocketManager(server);
+  return wsManager;
+}

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

@@ -1,4 +1,4 @@
-import { intro, text, spinner, isCancel, cancel } from '@clack/prompts';
+import { intro, text, spinner, isCancel, cancel, confirm } from '@clack/prompts';
 import pc from 'picocolors';
 import fs from 'fs';
 import { getPath } from '../config/paths';
@@ -77,6 +77,45 @@ export async function chatInteractive() {
       finalReply = finalReply.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
       
       console.log(finalReply + '\n');
+
+      // Check for pending transactions
+      try {
+        const txRes = await fetch('http://localhost:3000/api/transactions', {
+          headers: { 'x-nyxora-token': token }
+        });
+        if (txRes.ok) {
+          const txs = await txRes.json();
+          for (const tx of txs) {
+            const isApproved = await confirm({
+              message: pc.yellow(`Approve Transaction [${tx.type.toUpperCase()}] on ${tx.chainName.toUpperCase()}?`),
+            });
+            
+            if (isCancel(isApproved) || !isApproved) {
+               await fetch(`http://localhost:3000/api/transactions/${tx.id}/reject`, {
+                 method: 'POST',
+                 headers: { 'Content-Type': 'application/json', 'x-nyxora-token': token },
+                 body: JSON.stringify({ nonce: tx.nonce, sessionId: 'cli-chat' })
+               });
+               console.log(pc.red(`Transaction rejected.\n`));
+               continue;
+            }
+
+            const appRes = await fetch(`http://localhost:3000/api/transactions/${tx.id}/approve`, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json', 'x-nyxora-token': token },
+              body: JSON.stringify({ nonce: tx.nonce, sessionId: 'cli-chat' })
+            });
+            const appData = await appRes.json();
+            if (appData.success) {
+              console.log(pc.green(`Transaction approved! Processing in background...\n`));
+            } else {
+              console.log(pc.red(`Failed to approve: ${appData.error}\n`));
+            }
+          }
+        }
+      } catch (e) {
+        // silently ignore fetch errors for tx polling
+      }
     } 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

@@ -18,7 +18,6 @@ import { saveApiKeys } from '../config/parser';
 async function main() {
   // 1. Determine configuration directory
   const appDir = getAppDir();
-  const isGlobalMode = appDir !== process.cwd();
 
 console.log(`================================`);
 console.log(`🤖 Nyxora CLI Agent Booting Up...`);
@@ -191,9 +190,8 @@ console.log(`================================`);
     process.exit(0);
   }
 
-  // 2. Setup boilerplate files if in global mode and they don't exist
+  // 2. Setup boilerplate files since we enforce global mode
   let isFirstBoot = false;
-  if (isGlobalMode) {
     const globalConfigPath = getPath('config.yaml');
     const globalUserMdPath = getPath('user.md');
     const globalIdentityMdPath = getPath('IDENTITY.md');
@@ -201,7 +199,10 @@ console.log(`================================`);
     // Copy default config.yaml
     if (!fs.existsSync(globalConfigPath)) {
       isFirstBoot = true;
-      const exampleConfigPath = path.resolve(__dirname, '../../../config.yaml');
+      let exampleConfigPath = path.resolve(__dirname, '../../../config.yaml'); // Dev
+    if (!fs.existsSync(exampleConfigPath)) {
+      exampleConfigPath = path.resolve(__dirname, '../../../../../config.yaml'); // Compiled
+    }
       if (fs.existsSync(exampleConfigPath)) {
         fs.copyFileSync(exampleConfigPath, globalConfigPath);
       } else {
@@ -209,13 +210,12 @@ console.log(`================================`);
       }
     }
 
-    if (!fs.existsSync(globalUserMdPath)) {
-      fs.writeFileSync(globalUserMdPath, 'Write custom instructions, special rules, user profiles, or the persona you want for Nyxora AI in this file.\n');
-    }
+  if (!fs.existsSync(globalUserMdPath)) {
+    fs.writeFileSync(globalUserMdPath, 'Write custom instructions, special rules, user profiles, or the persona you want for Nyxora AI in this file.\n');
+  }
 
-    if (!fs.existsSync(globalIdentityMdPath)) {
-      fs.writeFileSync(globalIdentityMdPath, 'You are a Web3 AI assistant named Nyxora.\n');
-    }
+  if (!fs.existsSync(globalIdentityMdPath)) {
+    fs.writeFileSync(globalIdentityMdPath, 'You are a Web3 AI assistant named Nyxora.\n');
   }
 
   if (isFirstBoot) {

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

@@ -17,9 +17,11 @@ import rateLimit from 'express-rate-limit';
 import http from 'http';
 import jwt from 'jsonwebtoken';
 import crypto from 'crypto';
+import os from 'os';
 import { getPath } from '../config/paths';
 import { validateToken, getSessionToken } from '../utils/state';
 
+import { initWebSocket } from './WebSocketManager';
 import fs from 'fs';
 import yaml from 'yaml';
 import { processUserInput, logger } from '../agent/reasoning';
@@ -29,6 +31,7 @@ import { getPublicClient, SUPPORTED_CHAIN_NAMES, getAddress } from '../web3/conf
 import { TOKEN_MAP, ERC20_ABI } from '../web3/utils/tokens';
 import { Tracker } from './tracker';
 import { txManager } from '../agent/transactionManager';
+import multer from 'multer';
 
 import { executeTransfer, transferToolDefinition } from '../web3/skills/transfer';
 import { executeSwap, swapTokenToolDefinition } from '../web3/skills/swapToken';
@@ -68,6 +71,9 @@ import { xManagerToolDefinition } from '../system/skills/xManager';
 import { notionWorkspaceToolDefinition } from '../system/skills/notionWorkspace';
 import { audioTranscribeToolDefinition } from '../system/skills/audioTranscribe';
 import { summarizeTextToolDefinition } from '../system/skills/summarizeText';
+import { scheduleTaskDefinition } from '../system/skills/scheduleTask';
+import { cancelTaskDefinition } from '../system/skills/cancelTask';
+import { cronManager } from '../agent/cronManager';
 import { updateSecurityPolicyToolDefinition } from '../system/skills/updateSecurityPolicy';
 import { writeLocalFileToolDefinition } from '../system/skills/writeFile';
 import { generateExcelToolDefinition } from '../system/skills/generateExcel';
@@ -160,13 +166,11 @@ app.use('/api', (req, res, next) => {
 });
 
 // Serve Static Dashboard
-let rootDir = __dirname;
-while (!fs.existsSync(path.join(rootDir, 'packages', 'dashboard'))) {
-  const nextDir = path.dirname(rootDir);
-  if (nextDir === rootDir || rootDir === '/' || rootDir === 'C:\\') break;
-  rootDir = nextDir;
+// __dirname is packages/core/dist/gateway (compiled) OR packages/core/src/gateway (dev)
+let dashboardPath = path.join(__dirname, '..', '..', '..', 'dashboard', 'dist'); // Dev
+if (!fs.existsSync(dashboardPath)) {
+  dashboardPath = path.join(__dirname, '..', '..', '..', '..', '..', 'packages', 'dashboard', 'dist'); // Compiled
 }
-const dashboardPath = path.join(rootDir, 'packages', 'dashboard', 'dist');
 app.use(express.static(dashboardPath));
 
 app.get('/', (req, res) => {
@@ -181,6 +185,31 @@ app.get('/tos', (req, res) => {
   res.send(generateTosHtml());
 });
 
+const storage = multer.diskStorage({
+  destination: function (req, file, cb) {
+    const docsDir = path.join(os.homedir(), '.nyxora', 'docs');
+    if (!fs.existsSync(docsDir)) fs.mkdirSync(docsDir, { recursive: true });
+    cb(null, docsDir);
+  },
+  filename: function (req, file, cb) {
+    const safeName = file.originalname.replace(/[^a-zA-Z0-9.\-_]/g, '_');
+    cb(null, `${Date.now()}-${safeName}`);
+  }
+});
+const upload = multer({ storage });
+
+app.post('/api/upload', upload.single('file'), (req, res) => {
+  try {
+    if (!req.file) {
+      return res.status(400).json({ error: 'No file uploaded' });
+    }
+    return res.json({ filePath: req.file.path });
+  } catch (err) {
+    console.error('[Upload] Error:', err);
+    return res.status(500).json({ error: 'Failed to save file' });
+  }
+});
+
 app.post('/api/upload-google-credentials', (req, res) => {
   try {
     const credentials = req.body.credentials;
@@ -380,7 +409,9 @@ const systemSkills = [
   xManagerToolDefinition,
   notionWorkspaceToolDefinition,
   audioTranscribeToolDefinition,
-  summarizeTextToolDefinition
+  summarizeTextToolDefinition,
+  scheduleTaskDefinition,
+  cancelTaskDefinition
 ];
 
 app.get('/api/stats', (req, res) => {
@@ -400,6 +431,13 @@ app.get('/api/logs', (req, res) => {
   res.json(Tracker.getLogs());
 });
 
+app.get('/api/cron', (req, res) => {
+  res.json({
+    activeJobs: cronManager.getActiveJobsCount(),
+    jobs: cronManager.getJobs()
+  });
+});
+
 app.get('/api/skills', (req, res) => {
   const skillsWithStatus = allSkills.map(skill => ({
     ...skill,
@@ -873,6 +911,24 @@ function resetIdleTimer() {
   }, 3 * 60 * 1000); // 3 minutes idle
 }
 
+app.post('/api/v1/trade', async (req, res) => {
+  try {
+    const { message, session_id } = req.body;
+    if (!message) return res.status(400).json({ error: 'Message is required' });
+    
+    const traceId = crypto.randomBytes(8).toString('hex');
+    
+    // Asynchronous background execution
+    processUserInput(message, session_id || traceId).catch(err => {
+      console.error(`[TradeAPI] Error:`, err);
+    });
+
+    res.status(200).json({ status: 'processing', traceId });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
 app.post('/api/chat', async (req, res) => {
   try {
     const { message, session_id } = req.body;
@@ -1032,6 +1088,9 @@ export function startServer() {
   const server = app.listen(PORT, '127.0.0.1', () => {
     console.log(`🤖 Nyxora API Server running on port ${PORT}`);
     
+    // Initialize WebSocket Manager
+    initWebSocket(server);
+    
     // Start the Telegram bot listener
     startTelegramBot();
     

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

@@ -288,7 +288,7 @@ Provider: ${config.llm.provider}`;
       { value: 'gitManager', label: 'Git Operations (Commit/Push/Pull)' },
       { value: 'updateSecurityPolicy', label: 'Update policy.yaml rules', hint: 'safeguard' },
       { value: 'browseWeb', label: 'Browse & Scrape Webpages' },
-      { value: 'searchWeb', label: 'Smart Web Search (Tavily/Brave)', hint: 'Requires API Key' },
+      { value: 'searchWeb', label: 'Smart Web Search (Tavily/Brave/DuckDuckGo)', hint: 'Optional API Key' },
       { value: 'googleWorkspace', label: 'Google Workspace (Gmail, Docs, Sheets, Forms)', hint: 'Requires OAuth' },
       { value: 'notionWorkspace', label: 'Notion Integration' },
       { value: 'xManager', label: 'X/Twitter Management' },
@@ -320,14 +320,17 @@ Provider: ${config.llm.provider}`;
       options: [
         { value: 'tavily', label: 'Tavily Search (Built for AI - 1000 free/mo)' },
         { value: 'brave', label: 'Brave Search (Privacy focused - 2000 free/mo)' },
+        { value: 'duckduckgo', label: 'DuckDuckGo (Free & Built-in)' },
       ],
     });
     if (isCancel(searchProvider)) return process.exit(0);
 
-    searchApiKey = (await password({
-      message: `Enter API Key for ${searchProvider} (Get it free at ${searchProvider === 'tavily' ? 'tavily.com' : 'search.brave.com'}):`,
-    })) as string;
-    if (isCancel(searchApiKey)) return process.exit(0);
+    if (searchProvider !== 'duckduckgo') {
+      searchApiKey = (await password({
+        message: `Enter API Key for ${searchProvider} (Get it free at ${searchProvider === 'tavily' ? 'tavily.com' : 'search.brave.com'}):`,
+      })) as string;
+      if (isCancel(searchApiKey)) return process.exit(0);
+    }
   }
 
   const setupTelegram = activeChannels.includes('telegram');

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

@@ -12,6 +12,9 @@ import { executeApprove, executeAaveSupply, executeVaultDeposit, executeUniv3Min
 import { executeRevokeApproval } from '../web3/skills/revokeApprovals';
 import { formatTransactionSuccess, formatTransactionError } from '../utils/formatter';
 import pc from 'picocolors';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
 
 let globalBotInstance: Telegraf | null = null;
 
@@ -178,6 +181,52 @@ export function startTelegramBot() {
       }
     });
 
+    bot.on('document', async (ctx) => {
+      const doc = ctx.message.document;
+      const caption = ctx.message.caption || '';
+      console.log(`[Telegram] Received document from ${ctx.from?.first_name || 'User'}: ${doc.file_name}`);
+      
+      await ctx.sendChatAction('typing');
+      
+      try {
+        const fileLink = await ctx.telegram.getFileLink(doc.file_id);
+        const docsDir = path.join(os.homedir(), '.nyxora', 'docs');
+        if (!fs.existsSync(docsDir)) fs.mkdirSync(docsDir, { recursive: true });
+        
+        const safeName = (doc.file_name || 'telegram_doc').replace(/[^a-zA-Z0-9.\-_]/g, '_');
+        const localFilePath = path.join(docsDir, `${Date.now()}-${safeName}`);
+        
+        const res = await fetch(fileLink.toString());
+        const buffer = await res.arrayBuffer();
+        fs.writeFileSync(localFilePath, Buffer.from(buffer));
+        
+        const prompt = `Tolong analisis dokumen ini: ${localFilePath}\n\n${caption}`;
+        
+        let progressMsgId: number | null = null;
+        const onProgress = async (progressText: string) => {
+          try {
+            if (!progressMsgId) {
+              const sent = await ctx.reply(`<i>${progressText.replace(/_/g, '')}</i>`, { parse_mode: 'HTML' });
+              progressMsgId = sent.message_id;
+            } else {
+              await ctx.telegram.editMessageText(ctx.chat.id, progressMsgId, undefined, `<i>${progressText.replace(/_/g, '')}</i>`, { parse_mode: 'HTML' });
+            }
+          } catch (e) {}
+        };
+
+        const response = await processUserInput(prompt, 'user', onProgress, ctx.chat?.id.toString());
+
+        if (progressMsgId) {
+          await ctx.telegram.deleteMessage(ctx.chat.id, progressMsgId).catch(() => {});
+        }
+
+        await ctx.reply(formatToTelegramHTML(response), { parse_mode: 'HTML' });
+      } catch (error: any) {
+        console.error('[Telegram] Error processing document:', error);
+        await ctx.reply('❌ Sorry, I failed to download or analyze the document.');
+      }
+    });
+
     // Handle callbacks
     bot.action(/^approve_(.+)$/, async (ctx) => {
       const txId = ctx.match[1];

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

@@ -1,3 +1,8 @@
+import fs from 'fs';
+import path from 'path';
+import { wsManager } from './WebSocketManager';
+import { getPath } from '../config/paths';
+
 interface Stats {
   cost: number;
   tokens: number;
@@ -26,6 +31,53 @@ const eventLogs: EventLog[] = [];
 const gatewayLogs: GatewayLog[] = [];
 const MAX_LOGS = 100;
 
+let trackerFile = '';
+try {
+  trackerFile = getPath('tracker.json');
+} catch (e) {
+  // Fallback
+}
+
+function loadState() {
+  if (!trackerFile) return;
+  try {
+    if (fs.existsSync(trackerFile)) {
+      const data = JSON.parse(fs.readFileSync(trackerFile, 'utf8'));
+      if (data.stats) Object.assign(stats, data.stats);
+      if (data.eventLogs && Array.isArray(data.eventLogs)) {
+        eventLogs.splice(0, eventLogs.length, ...data.eventLogs);
+      }
+      if (data.gatewayLogs && Array.isArray(data.gatewayLogs)) {
+        gatewayLogs.splice(0, gatewayLogs.length, ...data.gatewayLogs);
+      }
+    }
+  } catch (e) {}
+}
+
+let savePending = false;
+function saveState() {
+  if (!trackerFile) return;
+  if (savePending) return;
+  savePending = true;
+  setTimeout(() => {
+    flushState();
+    savePending = false;
+  }, 1000);
+}
+
+function flushState() {
+  if (!trackerFile) return;
+  try {
+    fs.writeFileSync(trackerFile, JSON.stringify({ stats, eventLogs, gatewayLogs }));
+  } catch (e) {}
+}
+
+process.on('exit', flushState);
+process.on('SIGTERM', () => { flushState(); process.exit(0); });
+process.on('SIGINT', () => { flushState(); process.exit(0); });
+
+loadState();
+
 function formatTime(): string {
   const now = new Date();
   return now.toTimeString().split(' ')[0]; // Returns HH:MM:SS
@@ -41,10 +93,12 @@ export const Tracker = {
     else if (provider === 'gemini') rate = 0.00001;
     
     stats.cost += (amount * rate);
+    saveState();
   },
   
   addMessage: () => {
     stats.messages += 1;
+    saveState();
   },
 
   getStats: () => {
@@ -54,11 +108,18 @@ export const Tracker = {
   addEvent: (event: string, meta: any = {}) => {
     eventLogs.unshift({ timestamp: formatTime(), event, meta });
     if (eventLogs.length > MAX_LOGS) eventLogs.pop();
+    saveState();
   },
 
   addGatewayLog: (message: string, meta?: any) => {
     gatewayLogs.unshift({ timestamp: formatTime(), message, meta });
     if (gatewayLogs.length > MAX_LOGS) gatewayLogs.pop();
+    saveState();
+    
+    // Broadcast terminal logs to Dashboard via WebSocket
+    if (wsManager) {
+      wsManager.broadcastAll(`[${formatTime()}] ${message}`, meta?.level || 'info');
+    }
   },
 
   getLogs: () => {

package/packages/core/src/memory/logger.ts

@@ -204,7 +204,7 @@ export class Logger {
         SELECT * FROM (
           SELECT role, content, name, tool_call_id, tool_calls, session_id, id 
           FROM messages 
-          WHERE session_id IS NULL 
+          WHERE session_id IS NULL
           ORDER BY id DESC LIMIT 40
         ) ORDER BY id ASC
       `).all();

package/packages/core/src/system/skills/cancelTask.ts

@@ -0,0 +1,38 @@
+import { cronManager } from '../../agent/cronManager';
+
+export const cancelTaskDefinition = {
+  type: "function",
+  function: {
+    name: "cancel_task",
+    description: "Cancel a scheduled background task (cron job). Use this when the user asks you to stop monitoring or cancel a previously scheduled task.",
+    parameters: {
+      type: "object",
+      properties: {
+        jobId: {
+          type: "string",
+          description: "The unique Job ID of the scheduled task to cancel."
+        }
+      },
+      required: ["jobId"]
+    }
+  }
+};
+
+export async function executeCancelTask(args: any): Promise<string> {
+  const { jobId } = args;
+  
+  if (!jobId) {
+    return "Error: Missing required parameter jobId.";
+  }
+
+  try {
+    const success = cronManager.removeJob(jobId);
+    if (success) {
+      return `Success! I have cancelled the scheduled background task with Job ID: ${jobId}.`;
+    } else {
+      return `Failed to cancel task. No active task found with Job ID: ${jobId}. You can check active jobs by asking me what tasks are currently running.`;
+    }
+  } catch (error: any) {
+    return `Failed to cancel task: ${error.message}`;
+  }
+}

package/packages/core/src/system/skills/editFile.ts

@@ -4,6 +4,13 @@ import path from 'path';
 export function editLocalFile(filePath: string, searchString: string, replacementString: string): string {
   try {
     const absolutePath = path.resolve(filePath);
+    
+    // Security Firewall: Block modification of core configuration files
+    const basename = path.basename(absolutePath);
+    if (['config.yaml', 'rpc_key.yaml', 'policy.yaml'].includes(basename)) {
+      return `Error: Access Denied. You are strictly forbidden from modifying core configuration files directly. If you need to update your agent name, use the update_identity tool instead.`;
+    }
+
     if (!fs.existsSync(absolutePath)) {
       return `Error: File not found at ${absolutePath}`;
     }