@intranefr/superbackend 1.5.2 → 1.5.3

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@intranefr/superbackend",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "description": "Node.js middleware that gives your project backend superpowers",
   "main": "index.js",
   "scripts": {
     "start": "node server.js",
-    "dev": "nodemon --verbose --ignore uploads --ignore '*.log' server.js",
+    "dev": "nodemon --verbose --ignore uploads --ignore stdout.log --ignore '*.log' server.js",
     "start:minio": "docker compose -f compose.standalone.yml --profile minio-only up -d minio",
     "minio:envs": "node -e \"console.log(['S3_ENDPOINT=http://localhost:9000','S3_REGION=us-east-1','S3_ACCESS_KEY_ID=minioadmin','S3_SECRET_ACCESS_KEY=minioadmin','S3_BUCKET=saasbackend','S3_FORCE_PATH_STYLE=true'].join('\\n'))\"",
     "build:sdk:error-tracking:browser": "esbuild sdk/error-tracking/browser/src/embed.js --bundle --format=iife --global-name=saasbackendErrorTrackingEmbed --outfile=sdk/error-tracking/browser/dist/embed.iife.js",
@@ -47,11 +47,13 @@
     "mysql2": "^3.16.1",
     "node-cron": "^4.2.1",
     "node-pty": "^1.1.0",
+    "node-telegram-bot-api": "^0.67.0",
     "openai": "^4.0.0",
     "redis": "^4.7.1",
     "resend": "^6.4.0",
     "ssh2-sftp-client": "^12.0.1",
     "stripe": "^14.0.0",
+    "terminal-kit": "^3.1.2",
     "vm2": "^3.10.0",
     "ws": "^8.18.0"
   },

package/src/controllers/admin.controller.js

@@ -352,7 +352,7 @@ const getWebhookStats = asyncHandler(async (req, res) => {
 const provisionCoolifyDeploy = asyncHandler(async (req, res) => {
   try {
     const { overwrite } = req.body;
-    const managePath = path.join(process.cwd(), "manage.sh");
+    const managePath = path.join(process.cwd(), "manage.js");
     const exists = fs.existsSync(managePath);
 
     if (exists && !overwrite) {
@@ -363,13 +363,19 @@ const provisionCoolifyDeploy = asyncHandler(async (req, res) => {
       });
     }
 
-    // In ref-superbackend, manage.sh already exists in the root of the repository
-    // If it didn't, we would write it here. For this case, we'll just success.
+    // Copy the improved manage.js from polybot
+    const sourceManageJs = path.join(__dirname, "../../../manage.js");
+    if (fs.existsSync(sourceManageJs)) {
+      fs.copyFileSync(sourceManageJs, managePath);
+      // Make it executable
+      fs.chmodSync(managePath, '755');
+    }
+
     res.json({
       success: true,
       message: exists
-        ? "Coolify Headless Deploy script (manage.sh) was already there."
-        : "Coolify Headless Deploy script (manage.sh) is ready in the root directory.",
+        ? "Coolify Headless Deploy script (manage.js) was updated."
+        : "Coolify Headless Deploy script (manage.js) is ready in the root directory.",
       path: managePath,
     });
   } catch (error) {

package/src/controllers/adminAgents.controller.js

@@ -0,0 +1,37 @@
+const Agent = require('../models/Agent');
+
+exports.listAgents = async (req, res) => {
+  try {
+    const agents = await Agent.find().lean();
+    return res.json({ items: agents });
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.createAgent = async (req, res) => {
+  try {
+    const agent = await Agent.create(req.body);
+    return res.json(agent);
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.updateAgent = async (req, res) => {
+  try {
+    const agent = await Agent.findByIdAndUpdate(req.params.id, req.body, { new: true });
+    return res.json(agent);
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.deleteAgent = async (req, res) => {
+  try {
+    await Agent.findByIdAndDelete(req.params.id);
+    return res.json({ success: true });
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};

package/src/controllers/adminLlm.controller.js

@@ -387,6 +387,24 @@ async function listCosts(req, res) {
   }
 }
 
+async function listProviders(req, res) {
+  try {
+    const providers = await getJsonSetting(PROVIDERS_KEY, {});
+    const safeProviders = {};
+    if (providers && typeof providers === "object") {
+      for (const [key, value] of Object.entries(providers)) {
+        if (!value || typeof value !== "object") continue;
+        const { apiKey, ...rest } = value;
+        safeProviders[key] = rest;
+      }
+    }
+    res.json({ providers: safeProviders });
+  } catch (error) {
+    console.error("[adminLlm] listProviders error", error);
+    res.status(500).json({ error: "Failed to load providers" });
+  }
+}
+
 module.exports = {
   getConfig,
   saveConfig,
@@ -394,4 +412,5 @@ module.exports = {
   listAudit,
   listCosts,
   listOpenRouterModels,
+  listProviders,
 };

package/src/controllers/adminMarkdowns.controller.js

@@ -0,0 +1,157 @@
+const {
+  ERROR_CODES,
+  listMarkdowns,
+  getMarkdownById,
+  createMarkdown,
+  updateMarkdown,
+  deleteMarkdown,
+  getFolderContents,
+  getUniqueGroupCodes,
+  validatePathUniqueness,
+} = require('../services/markdowns.service');
+
+function handleServiceError(res, error) {
+  const msg = error?.message || 'Operation failed';
+  const code = error?.code;
+
+  if (code === 'VALIDATION' || code === 'INVALID_MARKDOWN' || code === 'INVALID_GROUP_CODE') {
+    return res.status(400).json({ error: msg });
+  }
+  if (code === 'NOT_FOUND') {
+    return res.status(404).json({ error: msg });
+  }
+  if (code === 'PATH_NOT_UNIQUE') {
+    return res.status(409).json({ error: msg });
+  }
+
+  return res.status(500).json({ error: msg });
+}
+
+function parseJsonMaybe(value) {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== 'string') return value;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch (_) {
+    return null;
+  }
+}
+
+exports.list = async (req, res) => {
+  try {
+    const filters = {
+      category: req.query.category,
+      group_code: req.query.group_code,
+      status: req.query.status,
+      ownerUserId: req.query.ownerUserId,
+      orgId: req.query.orgId,
+      search: req.query.search,
+    };
+    
+    const pagination = {
+      page: Number(req.query.page) || 1,
+      limit: Number(req.query.limit) || 50,
+      sort: parseJsonMaybe(req.query.sort) || { updatedAt: -1 },
+    };
+    
+    const result = await listMarkdowns(filters, pagination, { isAdmin: true });
+    return res.json(result);
+  } catch (error) {
+    console.error('Error listing markdowns:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.get = async (req, res) => {
+  try {
+    const item = await getMarkdownById(req.params.id);
+    if (!item) return res.status(404).json({ error: 'Markdown not found' });
+    return res.json({ item });
+  } catch (error) {
+    console.error('Error fetching markdown:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.create = async (req, res) => {
+  try {
+    const item = await createMarkdown(req.body || {});
+    return res.status(201).json({ item });
+  } catch (error) {
+    console.error('Error creating markdown:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.update = async (req, res) => {
+  try {
+    const item = await updateMarkdown(req.params.id, req.body || {});
+    return res.json({ item });
+  } catch (error) {
+    console.error('Error updating markdown:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.remove = async (req, res) => {
+  try {
+    const result = await deleteMarkdown(req.params.id);
+    return res.json(result);
+  } catch (error) {
+    console.error('Error deleting markdown:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.getFolderContents = async (req, res) => {
+  try {
+    const { category } = req.params;
+    const { group_code } = req.params;
+    
+    const pagination = {
+      page: Number(req.query.page) || 1,
+      limit: Number(req.query.limit) || 100,
+      sort: parseJsonMaybe(req.query.sort) || { title: 1 },
+    };
+    
+    const result = await getFolderContents(category, group_code, pagination, { isAdmin: true });
+    return res.json(result);
+  } catch (error) {
+    console.error('Error getting folder contents:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.validatePath = async (req, res) => {
+  try {
+    const { category, group_code, slug, excludeId } = req.body;
+    
+    if (!category || !slug) {
+      return res.status(400).json({ error: 'category and slug are required' });
+    }
+    
+    const isUnique = await validatePathUniqueness(category, group_code, slug, excludeId);
+    return res.json({ unique: isUnique });
+  } catch (error) {
+    console.error('Error validating path:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.getGroupCodes = async (req, res) => {
+  try {
+    const { category } = req.params;
+    
+    if (!category) {
+      return res.status(400).json({ error: 'category is required' });
+    }
+    
+    const groupCodes = await getUniqueGroupCodes(category, { isAdmin: true });
+    return res.json(groupCodes);
+  } catch (error) {
+    console.error('Error getting group codes:', error);
+    return handleServiceError(res, error);
+  }
+};

package/src/controllers/adminScripts.controller.js

@@ -349,3 +349,141 @@ exports.streamRun = async (req, res) => {
     return res.end();
   }
 };
+
+// Get programmatic output (clean result for API consumption)
+async function getProgrammaticOutput(req, res) {
+  try {
+    const { runId } = req.params;
+    if (!runId) {
+      return res.status(400).json({ error: 'runId is required' });
+    }
+
+    const run = await ScriptRun.findById(runId).lean();
+    if (!run) {
+      return res.status(404).json({ error: 'Script run not found' });
+    }
+
+    // Parse programmatic output if it's JSON
+    let parsedResult = null;
+    let isJson = false;
+    
+    if (run.programmaticOutput) {
+      try {
+        parsedResult = JSON.parse(run.programmaticOutput);
+        isJson = true;
+      } catch {
+        // Not JSON, keep as string
+        parsedResult = null;
+        isJson = false;
+      }
+    }
+
+    res.json({
+      runId: run._id,
+      status: run.status,
+      exitCode: run.exitCode,
+      programmaticOutput: run.programmaticOutput || 'No output',
+      outputType: run.outputType || 'none',
+      isJson: isJson,
+      parsedResult: parsedResult,
+      returnResult: run.returnResult,
+      lastConsoleLog: run.lastConsoleLog,
+      createdAt: run.createdAt,
+      updatedAt: run.updatedAt,
+      startedAt: run.startedAt,
+      finishedAt: run.finishedAt
+    });
+  } catch (err) {
+    console.error('Error getting programmatic output:', err);
+    res.status(500).json({ error: err?.message || 'Internal server error' });
+  }
+}
+
+// Get full script output
+async function getFullOutput(req, res) {
+  try {
+    const { runId } = req.params;
+    if (!runId) {
+      return res.status(400).json({ error: 'runId is required' });
+    }
+
+    const run = await ScriptRun.findById(runId).lean();
+    if (!run) {
+      return res.status(404).json({ error: 'Script run not found' });
+    }
+
+    res.json({
+      runId: run._id,
+      status: run.status,
+      exitCode: run.exitCode,
+      fullOutput: run.fullOutput || '',
+      outputSize: run.outputSize || 0,
+      lineCount: run.lineCount || 0,
+      lastOutputUpdate: run.lastOutputUpdate,
+      createdAt: run.createdAt,
+      updatedAt: run.updatedAt,
+      startedAt: run.startedAt,
+      finishedAt: run.finishedAt
+    });
+  } catch (err) {
+    console.error('Error getting full output:', err);
+    res.status(500).json({ error: err?.message || 'Internal server error' });
+  }
+}
+
+// Download script output as file
+async function downloadOutput(req, res) {
+  try {
+    const { runId } = req.params;
+    if (!runId) {
+      return res.status(400).json({ error: 'runId is required' });
+    }
+
+    const run = await ScriptRun.findById(runId).lean();
+    if (!run) {
+      return res.status(404).json({ error: 'Script run not found' });
+    }
+
+    const filename = `script-output-${runId}-${run.createdAt.toISOString().slice(0, 19).replace(/:/g, '-')}.txt`;
+    
+    res.setHeader('Content-Type', 'text/plain');
+    res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+    
+    // Include metadata at the top
+    const metadata = [
+      `Script Run ID: ${runId}`,
+      `Status: ${run.status}`,
+      `Exit Code: ${run.exitCode || 'N/A'}`,
+      `Started: ${run.startedAt || 'N/A'}`,
+      `Finished: ${run.finishedAt || 'N/A'}`,
+      `Output Size: ${run.outputSize || 0} characters`,
+      `Line Count: ${run.lineCount || 0}`,
+      `Created: ${run.createdAt}`,
+      '=' .repeat(50),
+      ''
+    ].join('\n');
+
+    res.send(metadata + (run.fullOutput || run.outputTail || 'No output available'));
+  } catch (err) {
+    console.error('Error downloading output:', err);
+    res.status(500).json({ error: err?.message || 'Internal server error' });
+  }
+}
+
+exports.getFullOutput = getFullOutput;
+exports.downloadOutput = downloadOutput;
+
+module.exports = {
+  listScripts: exports.listScripts,
+  getScript: exports.getScript,
+  createScript: exports.createScript,
+  updateScript: exports.updateScript,
+  deleteScript: exports.deleteScript,
+  runScript: exports.runScript,
+  listRuns: exports.listRuns,
+  getRun: exports.getRun,
+  streamRunLogs: exports.streamRun,
+  getProgrammaticOutput: getProgrammaticOutput,
+  getFullOutput: exports.getFullOutput,
+  downloadOutput: exports.downloadOutput,
+};

package/src/controllers/adminTelegram.controller.js

@@ -0,0 +1,72 @@
+const TelegramBot = require('../models/TelegramBot');
+const Agent = require('../models/Agent');
+const telegramService = require('../services/telegram.service');
+
+exports.listBots = async (req, res) => {
+  try {
+    const bots = await TelegramBot.find().populate('defaultAgentId', 'name').lean();
+    return res.json({ items: bots });
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.createBot = async (req, res) => {
+  try {
+    const data = { ...req.body };
+    if (data.defaultAgentId === '') delete data.defaultAgentId;
+    
+    const bot = await TelegramBot.create(data);
+    if (bot.isActive) {
+      await telegramService.startBot(bot._id);
+    }
+    return res.json(bot);
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.updateBot = async (req, res) => {
+  try {
+    const data = { ...req.body };
+    if (data.defaultAgentId === '') data.defaultAgentId = null;
+
+    const bot = await TelegramBot.findByIdAndUpdate(req.params.id, data, { new: true });
+    if (bot.isActive) {
+      await telegramService.startBot(bot._id);
+    } else {
+      await telegramService.stopBot(bot._id);
+    }
+    return res.json(bot);
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.deleteBot = async (req, res) => {
+  try {
+    await telegramService.stopBot(req.params.id);
+    await TelegramBot.findByIdAndDelete(req.params.id);
+    return res.json({ success: true });
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.toggleBot = async (req, res) => {
+  try {
+    const bot = await TelegramBot.findById(req.params.id);
+    bot.isActive = !bot.isActive;
+    await bot.save();
+    
+    if (bot.isActive) {
+      await telegramService.startBot(bot._id);
+    } else {
+      await telegramService.stopBot(bot._id);
+    }
+    
+    return res.json(bot);
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};

package/src/controllers/markdowns.controller.js

@@ -0,0 +1,42 @@
+const { getMarkdownByPath, searchMarkdowns } = require('../services/markdowns.service');
+
+exports.getByPath = async (req, res) => {
+  try {
+    const { category, group_code, slug } = req.params;
+    // Check if JSON is requested via query or if we are on a .json route
+    const isJson = req.query?.json === 'true' || req.query?.json === '1' || req.path.endsWith('/json');
+
+    const doc = await getMarkdownByPath(category, group_code, slug);
+    
+    if (isJson) {
+      return res.json({ item: doc });
+    }
+    
+    // Serve raw markdown with correct MIME type
+    return res.type('text/markdown').send(doc.markdownRaw);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'NOT_FOUND') {
+      return res.status(404).json({ error: 'Markdown not found' });
+    }
+
+    console.error('Error fetching markdown:', error);
+    return res.status(500).json({ error: error?.message || 'Failed to fetch markdown' });
+  }
+};
+
+exports.search = async (req, res) => {
+  try {
+    const { q: query, category, group_code, limit = 50 } = req.query;
+    
+    if (!query) {
+      return res.status(400).json({ error: 'Search query (q) is required' });
+    }
+
+    const results = await searchMarkdowns(query, { category, group_code, limit: Number(limit) });
+    return res.json({ results });
+  } catch (error) {
+    console.error('Error searching markdowns:', error);
+    return res.status(500).json({ error: error?.message || 'Failed to search markdowns' });
+  }
+};

package/src/helpers/mongooseHelper.js

@@ -83,7 +83,7 @@ class MongooseHelper {
       const uri = this.getMongoUri();
       const options = this.getConnectionOptions();
       
-      console.log(`[MongooseHelper] Connecting to MongoDB...`);
+      if (!process.env.TUI_MODE) console.log(`[MongooseHelper] Connecting to MongoDB...`);
       
       // Clear any existing connection
       if (mongoose.connection.readyState !== 0) {
@@ -94,7 +94,7 @@ class MongooseHelper {
       
       this.isConnected = true;
       
-      console.log(`[MongooseHelper] ✅ Connected to MongoDB`);
+      if (!process.env.TUI_MODE) console.log(`[MongooseHelper] ✅ Connected to MongoDB`);
       
       // Setup connection error handling
       mongoose.connection.on('error', (error) => {
@@ -104,13 +104,13 @@ class MongooseHelper {
       });
 
       mongoose.connection.on('disconnected', () => {
-        console.log('[MongooseHelper] Disconnected from MongoDB');
+        if (!process.env.TUI_MODE) console.log('[MongooseHelper] Disconnected from MongoDB');
         this.isConnected = false;
         this.connectionPromise = null;
       });
 
       mongoose.connection.on('reconnected', () => {
-        console.log('[MongooseHelper] Reconnected to MongoDB');
+        if (!process.env.TUI_MODE) console.log('[MongooseHelper] Reconnected to MongoDB');
         this.isConnected = true;
       });
 
@@ -136,7 +136,7 @@ class MongooseHelper {
     if (this.connectionCount <= 0) {
       try {
         await mongoose.disconnect();
-        console.log('[MongooseHelper] ✅ Disconnected from MongoDB');
+        if (!process.env.TUI_MODE) console.log('[MongooseHelper] ✅ Disconnected from MongoDB');
       } catch (error) {
         console.error('[MongooseHelper] Disconnect error:', error);
       } finally {
@@ -155,7 +155,7 @@ class MongooseHelper {
     try {
       if (mongoose.connection.readyState !== 0) {
         await mongoose.disconnect();
-        console.log('[MongooseHelper] ✅ Force disconnected from MongoDB');
+        if (!process.env.TUI_MODE) console.log('[MongooseHelper] ✅ Force disconnected from MongoDB');
       }
     } catch (error) {
       console.error('[MongooseHelper] Force disconnect error:', error);

package/src/helpers/scriptBase.js

@@ -55,13 +55,13 @@ class ScriptBase {
     });
 
     try {
-      console.log(`[${this.name}] Starting script execution...`);
+      if (!process.env.TUI_MODE) console.log(`[${this.name}] Starting script execution...`);
       
       const executionPromise = this._executeWithConnection();
       const result = await Promise.race([executionPromise, timeoutPromise]);
 
       const duration = Date.now() - this.startTime;
-      console.log(`[${this.name}] ✅ Completed in ${duration}ms`);
+      if (!process.env.TUI_MODE) console.log(`[${this.name}] ✅ Completed in ${duration}ms`);
       
       return result;
     } catch (error) {