@intranefr/superbackend 1.5.2 → 1.6.3

package/src/services/scriptsRunner.service.js

@@ -28,22 +28,51 @@ const MAX_TAIL_BYTES = 64 * 1024;
  }
 
  function wrapInAsyncIife(code) {
-   const body = String(code || '');
-   return [
-     '(async () => {',
-     body,
-     '})().catch((err) => {',
-     '  try { console.error(err && err.stack ? err.stack : err); } catch {}',
-     '});',
-     '',
-   ].join('\n');
+  const body = String(code || '');
+  return [
+    '(async () => {',
+    body,
+    '})().then((result) => {',
+    '  // Store result globally for VM2 to capture',
+    '  global.__scriptResult = result;',
+    '}).catch((err) => {',
+    '  try { console.error(err && err.stack ? err.stack : err); } catch {}',
+    '  global.__scriptResult = { error: err.message || String(err) };',
+    '});',
+    '',
+  ].join('\n');
+ }
+
+ function wrapExistingAsyncIife(code) {
+  const body = String(code || '');
+  // Remove the final closing parenthesis and semicolon, then add our result capture
+  const codeWithoutEnding = body.replace(/\)\s*;?\s*$/, '');
+  return [
+    '// Wrapped to capture return value',
+    codeWithoutEnding,
+    ').then((result) => {',
+    '  // Store result globally for VM2 to capture',
+    '  global.__scriptResult = result;',
+    '}).catch((err) => {',
+    '  try { console.error(err && err.stack ? err.stack : err); } catch {}',
+    '  global.__scriptResult = { error: err.message || String(err) };',
+    '});',
+    '',
+  ].join('\n');
  }
 
  function prepareVmCodeForExecution(code) {
-   const raw = String(code || '');
-   if (!shouldAutoWrapAsyncScripts()) return { code: raw, wrapped: false };
-   if (!detectTopLevelAwait(raw)) return { code: raw, wrapped: false };
-   return { code: wrapInAsyncIife(raw), wrapped: true };
+  const raw = String(code || '');
+  if (!shouldAutoWrapAsyncScripts()) return { code: raw, wrapped: false };
+  if (!detectTopLevelAwait(raw)) return { code: raw, wrapped: false };
+  
+  // Check if it's already an async IIFE that doesn't expose its result
+  if (/^\s*\(\s*async\s+function\s*\(/.test(raw) && !/global\.__scriptResult\s*=/.test(raw)) {
+    // Wrap the existing async IIFE to capture its result
+    return { code: wrapExistingAsyncIife(raw), wrapped: true };
+  }
+  
+  return { code: wrapInAsyncIife(raw), wrapped: true };
  }
 
  function buildAwaitSyntaxHelpMessage() {
@@ -71,15 +100,88 @@ function decodeScriptContent(script, format) {
   return script;
 }
 
-function nowIso() {
-  return new Date().toISOString();
+const nowIso = () => new Date().toISOString();
+
+const appendTail = (tail, more) => {
+  const max = 20000; // keep last 20k chars
+  tail = (tail + more).slice(-max);
+  return tail;
+};
+
+// Infrastructure log patterns to filter out
+const infrastructurePatterns = [
+  'Using existing app database connection',
+  'No existing connection found',
+  'Auto-wrapping script in async function',
+  '=== SCRIPT START ===',
+  '=== SCRIPT END ===',
+  'Executing script',
+  'Script preview',
+  'Database connection established',
+  'chars)',
+  'Infrastructure logs'
+];
+
+// Utility functions for output processing
+function isInfrastructureLog(line) {
+  return infrastructurePatterns.some(pattern => line.includes(pattern));
 }
 
-function appendTail(prev, chunk) {
-  const next = String(prev || '') + String(chunk || '');
-  const buf = Buffer.from(next, 'utf8');
-  if (buf.length <= MAX_TAIL_BYTES) return next;
-  return buf.slice(buf.length - MAX_TAIL_BYTES).toString('utf8');
+function isMeaningfulConsoleLog(line) {
+  return !isInfrastructureLog(line) && 
+         line.trim().length > 0 &&
+         !line.startsWith('[') &&
+         !line.includes('===');
+}
+
+function formatOutput(value) {
+  if (typeof value === 'object') {
+    return JSON.stringify(value, null, 2);
+  }
+  return String(value);
+}
+
+function tryParseJson(str) {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return null;
+  }
+}
+
+function isJsonString(str) {
+  return tryParseJson(str) !== null;
+}
+
+function determineProgrammaticOutput(returnValue, lastConsoleLog) {
+  // Priority 1: Return value
+  if (returnValue !== undefined && returnValue !== null) {
+    const formatted = formatOutput(returnValue);
+    return {
+      programmaticOutput: formatted,
+      outputType: 'return',
+      isJson: isJsonString(formatted),
+      parsedResult: tryParseJson(formatted)
+    };
+  }
+  
+  // Priority 2: Last meaningful console.log
+  if (lastConsoleLog && !isInfrastructureLog(lastConsoleLog)) {
+    return {
+      programmaticOutput: lastConsoleLog,
+      outputType: 'console',
+      isJson: isJsonString(lastConsoleLog),
+      parsedResult: tryParseJson(lastConsoleLog)
+    };
+  }
+  
+  // Priority 3: No output
+  return {
+    programmaticOutput: 'No output',
+    outputType: 'none',
+    isJson: false,
+    parsedResult: null
+  };
 }
 
 function safeJsonParse(str) {
@@ -272,12 +374,31 @@ async function runSpawned({ runId, bus, command, args, env, cwd, timeoutMs }) {
 
 async function runHostWithDatabase({ runId, bus, code, env, cwd, timeoutMs }) {
   let tail = '';
+  let scriptResult = null;
+  let lastConsoleLog = null;
 
   function pushLog(stream, line) {
     const s = String(line || '');
     tail = appendTail(tail, s);
     bus.push({ type: 'log', ts: nowIso(), stream, line: s });
-    return ScriptRun.updateOne({ _id: runId }, { $set: { outputTail: tail } });
+    
+    // Track last console.log for programmatic output
+    if (stream === 'stdout' && isMeaningfulConsoleLog(s)) {
+      lastConsoleLog = s.trim();
+    }
+    
+    // Update both outputTail and fullOutput using string concatenation
+    return ScriptRun.findById(runId).then(run => {
+      if (run) {
+        run.outputTail = tail;
+        run.fullOutput = (run.fullOutput || '') + s;
+        run.lastConsoleLog = lastConsoleLog;
+        run.lastOutputUpdate = new Date();
+        run.outputSize = (run.outputSize || 0) + s.length;
+        run.lineCount = (run.lineCount || 0) + (s.split('\n').length - 1);
+        return run.save();
+      }
+    });
   }
 
   try {
@@ -299,7 +420,7 @@ async function runHostWithDatabase({ runId, bus, code, env, cwd, timeoutMs }) {
     
     const prepared = prepareVmCodeForExecution(code);
     if (prepared.wrapped) {
-      await pushLog('stdout', 'Auto-wrapping script in async function (detected top-level await)\n');
+      await pushLog('stdout', 'Auto-wrapping script to capture return value\n');
     }
 
     // Create a VM with database context
@@ -366,11 +487,21 @@ async function runHostWithDatabase({ runId, bus, code, env, cwd, timeoutMs }) {
         // Process environment
         process: {
           env: { ...process.env, ...env }
-        }
+        },
+        
+        // Debug: Log available models
+        debugModels: () => {
+          console.log('Available models:', Object.keys(mongoose.models || {}));
+          return mongoose.models || {};
+        },
+        
+        // Global variables for async result capture
+        global: {},
+        __scriptResult: undefined
       },
       require: {
         external: false,
-        builtin: ['util', 'path', 'os'], // Allow some basic built-ins
+        builtin: ['util', 'path', 'os', 'mongoose'], // Allow mongoose for parent app model access
       },
       timeout: timeoutMs,
       eval: false,
@@ -379,30 +510,138 @@ async function runHostWithDatabase({ runId, bus, code, env, cwd, timeoutMs }) {
 
     // Set up console redirection
     vm.on('console.log', (...args) => {
-      pushLog('stdout', args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ') + '\n');
+      const message = args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ') + '\n';
+      
+      // Send to UI output
+      pushLog('stdout', message);
+      
+      // Also send to parent process (backend logs)
+      console.log('[Script]', message.trim());
     });
     vm.on('console.error', (...args) => {
-      pushLog('stderr', args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ') + '\n');
+      const message = args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ') + '\n';
+      
+      // Send to UI output
+      pushLog('stderr', message);
+      
+      // Also send to parent process (backend logs)
+      console.error('[Script]', message.trim());
+    });
+
+    // Handle unhandled promise rejections within the VM
+    vm.on('unhandledRejection', (reason, promise) => {
+      let errorMsg = 'Unhandled Promise Rejection: ';
+      
+      if (reason instanceof Error) {
+        errorMsg += reason.message;
+        if (reason.stack) {
+          errorMsg += '\n' + reason.stack;
+        }
+      } else {
+        errorMsg += JSON.stringify(reason);
+      }
+      
+      // Send to UI output
+      pushLog('stderr', errorMsg + '\n');
+      
+      // Also send to parent process (backend logs)
+      console.error('[Script]', errorMsg);
+    });
+
+    // Handle uncaught exceptions within the VM
+    vm.on('error', (error) => {
+      let errorMsg = 'VM Error: ';
+      
+      if (error instanceof Error) {
+        errorMsg += error.message;
+        if (error.stack) {
+          errorMsg += '\n' + error.stack;
+        }
+      } else {
+        errorMsg += JSON.stringify(error);
+      }
+      
+      // Send to UI output
+      pushLog('stderr', errorMsg + '\n');
+      
+      // Also send to parent process (backend logs)
+      console.error('[Script]', errorMsg);
     });
 
     // Run the script code with better error handling
     try {
+      await pushLog('stdout', `=== SCRIPT START ===\n`);
+      await pushLog('stdout', `Executing script (${prepared.code.length} chars)...\n`);
+      
+      // Show first few lines of script for debugging
+      const scriptPreview = prepared.code.split('\n').slice(0, 5).join('\n');
+      await pushLog('stdout', `Script preview:\n${scriptPreview}\n...\n`);
+      
+      // Run the script
       vm.run(prepared.code, 'script.host.js');
+      
+      // Capture result based on whether the script was wrapped
+      if (prepared.wrapped) {
+        // For wrapped scripts, wait and capture from global variable
+        await new Promise(resolve => setTimeout(resolve, 100)); // Wait for async completion
+        scriptResult = vm.sandbox.__scriptResult;
+      } else {
+        // For non-wrapped scripts, try to capture direct return or use global variable
+        scriptResult = vm.sandbox.__scriptResult;
+        // Also try to get the last meaningful console.log as fallback
+        if (!scriptResult && lastConsoleLog) {
+          scriptResult = lastConsoleLog;
+        }
+      }
+      
+      await pushLog('stdout', `=== SCRIPT END ===\n`);
+      
+      // Determine and save programmatic output
+      const programmaticOutput = determineProgrammaticOutput(scriptResult, lastConsoleLog);
+      await ScriptRun.updateOne(
+        { _id: runId },
+        { 
+          $set: {
+            programmaticOutput: programmaticOutput.programmaticOutput,
+            returnResult: scriptResult !== undefined && scriptResult !== null ? formatOutput(scriptResult) : '',
+            outputType: programmaticOutput.outputType
+          }
+        }
+      );
     } catch (vmError) {
-      const baseMsg = vmError?.message || 'Unknown VM error';
-      const help = baseMsg.includes('await is only valid in async functions') ? `\n\n${buildAwaitSyntaxHelpMessage()}` : '';
-      const errorMsg = `VM execution error: ${baseMsg}${help}`;
-      await pushLog('stderr', errorMsg + '\n');
+      let errorMsg = 'VM execution error: ';
+      
+      if (vmError instanceof Error) {
+        errorMsg += vmError.message;
+        if (vmError.stack) {
+          errorMsg += '\n' + vmError.stack;
+        }
+      } else {
+        errorMsg += JSON.stringify(vmError);
+      }
+      
+      const help = vmError?.message?.includes('await is only valid in async functions') ? `\n\n${buildAwaitSyntaxHelpMessage()}` : '';
+      await pushLog('stderr', errorMsg + help + '\n');
       return 1;
     }
     
     return 0;
     
   } catch (err) {
-    const msg = err?.message || 'Host script error';
-    await pushLog('stderr', msg + '\n');
-    return 1;
-  } finally {
+      let errorMsg = 'Host script error: ';
+      
+      if (err instanceof Error) {
+        errorMsg += err.message;
+        if (err.stack) {
+          errorMsg += '\n' + err.stack;
+        }
+      } else {
+        errorMsg += JSON.stringify(err);
+      }
+      
+      await pushLog('stderr', errorMsg + '\n');
+      return 1;
+    } finally {
     // Don't disconnect here - let mongooseHelper manage connection pooling
     // The connection will be cleaned up when the helper decides
   }
@@ -410,17 +649,39 @@ async function runHostWithDatabase({ runId, bus, code, env, cwd, timeoutMs }) {
 
 async function runVm2({ runId, bus, code, timeoutMs }) {
   let tail = '';
+  let scriptResult = null;
+  let lastConsoleLog = null;
 
   function pushLog(stream, line) {
     const s = String(line || '');
     tail = appendTail(tail, s);
     bus.push({ type: 'log', ts: nowIso(), stream, line: s });
-    return ScriptRun.updateOne({ _id: runId }, { $set: { outputTail: tail } });
+    
+    // Track last console.log for programmatic output
+    if (stream === 'stdout' && isMeaningfulConsoleLog(s)) {
+      lastConsoleLog = s.trim();
+    }
+    
+    // Update both outputTail and fullOutput using string concatenation
+    return ScriptRun.findById(runId).then(run => {
+      if (run) {
+        run.outputTail = tail;
+        run.fullOutput = (run.fullOutput || '') + s;
+        run.lastConsoleLog = lastConsoleLog;
+        run.lastOutputUpdate = new Date();
+        run.outputSize = (run.outputSize || 0) + s.length;
+        run.lineCount = (run.lineCount || 0) + (s.split('\n').length - 1);
+        return run.save();
+      }
+    });
   }
 
   const vm = new NodeVM({
     console: 'redirect',
-    sandbox: {},
+    sandbox: {
+      global: {},
+      __scriptResult: undefined
+    },
     require: {
       external: false,
       builtin: [],
@@ -440,9 +701,39 @@ async function runVm2({ runId, bus, code, timeoutMs }) {
   try {
     const prepared = prepareVmCodeForExecution(code);
     if (prepared.wrapped) {
-      await pushLog('stdout', 'Auto-wrapping script in async function (detected top-level await)\n');
+      await pushLog('stdout', 'Auto-wrapping script to capture return value\n');
     }
+    
+    // Run the script
     vm.run(prepared.code, 'script.vm2.js');
+    
+    // Capture result based on whether the script was wrapped
+    if (prepared.wrapped) {
+      // For wrapped scripts, wait and capture from global variable
+      await new Promise(resolve => setTimeout(resolve, 100)); // Wait for async completion
+      scriptResult = vm.sandbox.__scriptResult;
+    } else {
+      // For non-wrapped scripts, try to capture direct return or use global variable
+      scriptResult = vm.sandbox.__scriptResult;
+      // Also try to get the last meaningful console.log as fallback
+      if (!scriptResult && lastConsoleLog) {
+        scriptResult = lastConsoleLog;
+      }
+    }
+    
+    // Determine and save programmatic output
+    const programmaticOutput = determineProgrammaticOutput(scriptResult, lastConsoleLog);
+    await ScriptRun.updateOne(
+      { _id: runId },
+      { 
+        $set: {
+          programmaticOutput: programmaticOutput.programmaticOutput,
+          returnResult: scriptResult !== undefined && scriptResult !== null ? formatOutput(scriptResult) : '',
+          outputType: programmaticOutput.outputType
+        }
+      }
+    );
+    
     return 0;
   } catch (err) {
     const baseMsg = err?.message || 'vm2 error';

package/src/services/telegram.service.js

@@ -0,0 +1,130 @@
+const TelegramBot = require('node-telegram-bot-api');
+const TelegramBotModel = require('../models/TelegramBot');
+const Agent = require('../models/Agent');
+const agentService = require('./agent.service');
+
+const activeBots = new Map();
+
+/**
+ * Start a telegram bot by its ID
+ */
+async function startBot(botId) {
+  try {
+    const botDoc = await TelegramBotModel.findById(botId);
+    if (!botDoc) throw new Error('Bot not found');
+
+    if (activeBots.has(botId.toString())) {
+      await stopBot(botId);
+    }
+
+    const bot = new TelegramBot(botDoc.token, { polling: true });
+
+    bot.on('message', async (msg) => {
+      if (!msg.text) return;
+
+      // Security: check if user is allowed
+      if (botDoc.allowedUserIds && botDoc.allowedUserIds.length > 0) {
+        if (!botDoc.allowedUserIds.includes(msg.from.id.toString())) {
+          console.warn(`Unauthorized access attempt from ${msg.from.id} to bot ${botDoc.name}`);
+          return;
+        }
+      }
+
+      console.log(`[TelegramBot: ${botDoc.name}] Received: ${msg.text} from ${msg.from.id}`);
+
+      // Delegate to agent service
+      try {
+        if (msg.text.toLowerCase() === '/start') {
+          await bot.sendMessage(msg.chat.id, 'Hi there! I am your SuperBackend Agent. How can I help you today?');
+          return;
+        }
+
+        if (!botDoc.defaultAgentId) {
+            console.log(`[TelegramBot: ${botDoc.name}] No agent configured, ignoring message from ${msg.from.id}`);
+            return;
+        }
+
+        const response = await agentService.processMessage(botDoc.defaultAgentId, {
+            content: msg.text,
+            senderId: msg.from.id.toString(),
+            chatId: msg.chat.id.toString(),
+            metadata: {
+                firstName: msg.from.first_name,
+                lastName: msg.from.last_name,
+                username: msg.from.username
+            }
+        });
+        
+        await bot.sendMessage(msg.chat.id, response.text || response);
+      } catch (err) {
+        console.error('Error processing message:', err);
+        await bot.sendMessage(msg.chat.id, 'Sorry, I encountered an error processing your request.');
+      }
+    });
+
+    bot.on('polling_error', (err) => {
+      console.error(`Telegram polling error [${botDoc.name}]:`, err);
+    });
+
+    activeBots.set(botId.toString(), bot);
+    
+    botDoc.status = 'running';
+    botDoc.lastError = null;
+    await botDoc.save();
+
+    console.log(`Telegram bot [${botDoc.name}] started`);
+    return true;
+  } catch (err) {
+    console.error(`Failed to start Telegram bot [${botId}]:`, err);
+    const botDoc = await TelegramBotModel.findById(botId);
+    if (botDoc) {
+      botDoc.status = 'error';
+      botDoc.lastError = err.message;
+      await botDoc.save();
+    }
+    throw err;
+  }
+}
+
+/**
+ * Stop a telegram bot
+ */
+async function stopBot(botId) {
+  const bot = activeBots.get(botId.toString());
+  if (bot) {
+    await bot.stopPolling();
+    activeBots.delete(botId.toString());
+  }
+
+  const botDoc = await TelegramBotModel.findById(botId);
+  if (botDoc) {
+    botDoc.status = 'stopped';
+    await botDoc.save();
+  }
+
+  console.log(`Telegram bot [${botId}] stopped`);
+}
+
+/**
+ * Initialize all active bots on startup
+ */
+async function init() {
+  try {
+    const activeBotsDocs = await TelegramBotModel.find({ isActive: true });
+    for (const botDoc of activeBotsDocs) {
+      try {
+        await startBot(botDoc._id);
+      } catch (err) {
+        // Continue with other bots
+      }
+    }
+  } catch (err) {
+    console.error('Failed to initialize Telegram bots:', err);
+  }
+}
+
+module.exports = {
+  startBot,
+  stopBot,
+  init
+};