@intranefr/superbackend 1.5.1 → 1.5.3

package/src/controllers/adminScripts.controller.js

@@ -1,5 +1,6 @@
 const ScriptDefinition = require('../models/ScriptDefinition');
 const ScriptRun = require('../models/ScriptRun');
+const { basicAuth } = require('../middleware/auth');
 const { startRun, getRunBus } = require('../services/scriptsRunner.service');
 const { logAuditSync } = require('../services/auditLogger');
 
@@ -12,19 +13,6 @@ function toSafeJsonError(error) {
   return { status: 500, body: { error: msg } };
 }
 
-function audit(req, event) {
-  logAuditSync({
-    req,
-    action: event.action,
-    outcome: event.outcome,
-    entityType: 'ScriptDefinition',
-    entityId: event.entityId ? String(event.entityId) : null,
-    before: event.before || null,
-    after: event.after || null,
-    details: event.details || undefined,
-  });
-}
-
 function normalizeEnv(env) {
   const items = Array.isArray(env) ? env : [];
   const out = [];
@@ -37,6 +25,35 @@ function normalizeEnv(env) {
   return out;
 }
 
+// Helper functions for base64 handling
+function isBase64(str) {
+  try {
+    return Buffer.from(str, 'base64').toString('base64') === str;
+  } catch (err) {
+    return false;
+  }
+}
+
+function isValidBase64(str) {
+  try {
+    Buffer.from(str, 'base64');
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+function decodeScriptContent(script, format) {
+  if (format === 'base64') {
+    try {
+      return Buffer.from(script, 'base64').toString('utf8');
+    } catch (err) {
+      throw new Error('Failed to decode base64 script content');
+    }
+  }
+  return script;
+}
+
 exports.listScripts = async (req, res) => {
   try {
     const items = await ScriptDefinition.find().sort({ updatedAt: -1 }).lean();
@@ -61,41 +78,74 @@ exports.getScript = async (req, res) => {
 exports.createScript = async (req, res) => {
   let created = null;
   try {
+    console.log('[createScript] Starting script creation...');
+    console.log('[createScript] Request body keys:', Object.keys(req.body || {}));
+    
     const payload = req.body || {};
+    console.log('[createScript] Payload name:', payload.name);
+    console.log('[createScript] Payload type:', payload.type);
+    console.log('[createScript] Payload runner:', payload.runner);
+    console.log('[createScript] Script length:', (payload.script || '').length);
+    console.log('[createScript] Script format:', payload.scriptFormat);
+
+    // Handle script content encoding
+    let scriptContent = String(payload.script || '');
+    let scriptFormat = payload.scriptFormat || 'string';
+
+    // Auto-detect base64 if not specified and content looks like base64
+    if (scriptFormat === 'string' && isBase64(scriptContent)) {
+      scriptFormat = 'base64';
+      console.log('[createScript] Auto-detected base64 format');
+    }
 
+    // Validate base64 content if format is base64
+    if (scriptFormat === 'base64' && !isValidBase64(scriptContent)) {
+      console.log('[createScript] Invalid base64 content detected');
+      throw new Error('Invalid base64 script content');
+    }
+
+    console.log('[createScript] About to create ScriptDefinition...');
     const doc = await ScriptDefinition.create({
       name: String(payload.name || '').trim(),
       codeIdentifier: String(payload.codeIdentifier || '').trim(),
       description: String(payload.description || ''),
       type: String(payload.type || '').trim(),
       runner: String(payload.runner || '').trim(),
-      script: String(payload.script || ''),
+      script: scriptContent,
+      scriptFormat: scriptFormat,
       defaultWorkingDirectory: String(payload.defaultWorkingDirectory || ''),
       env: normalizeEnv(payload.env),
       timeoutMs: payload.timeoutMs === undefined ? undefined : Number(payload.timeoutMs),
       enabled: payload.enabled === undefined ? true : Boolean(payload.enabled),
     });
+    
+    console.log('[createScript] ScriptDefinition created successfully');
 
     created = doc.toObject();
-    audit(req, {
+    console.log('[createScript] About to create audit entry...');
+    console.log('[createScript] Script created successfully:', { name: created.name, id: created._id });
+    
+    logAuditSync({
+      req,
       action: 'scripts.create',
       outcome: 'success',
-      entityId: doc._id,
-      before: null,
-      after: created,
+      entityType: 'ScriptDefinition',
+      entityId: created._id,
+      data: { name: created.name },
     });
-
+    
+    console.log('[createScript] About to send response...');
     res.status(201).json({ item: doc.toObject() });
+    console.log('[createScript] Response sent successfully');
   } catch (err) {
-    audit(req, {
-      action: 'scripts.create',
-      outcome: 'failure',
-      entityId: created?._id,
-      before: null,
-      after: created,
-      details: { error: err?.message || 'Operation failed' },
-    });
+    console.log('[createScript] ERROR occurred:', err);
+    console.log('[createScript] ERROR stack:', err.stack);
+    console.log('[createScript] ERROR message:', err.message);
+    console.log('[createScript] ERROR code:', err.code);
+    
+    console.log('[createScript] Script creation failed:', { error: err?.message || 'Operation failed' });
     const safe = toSafeJsonError(err);
+    console.log('[createScript] Safe error:', safe);
     res.status(safe.status).json(safe.body);
   }
 };
@@ -111,12 +161,30 @@ exports.updateScript = async (req, res) => {
 
     before = doc.toObject();
 
+    // Handle script content encoding
+    if (payload.script !== undefined) {
+      let scriptContent = String(payload.script || '');
+      let scriptFormat = payload.scriptFormat || doc.scriptFormat || 'string';
+
+      // Auto-detect base64 if not specified and content looks like base64
+      if (scriptFormat === 'string' && isBase64(scriptContent)) {
+        scriptFormat = 'base64';
+      }
+
+      // Validate base64 content if format is base64
+      if (scriptFormat === 'base64' && !isValidBase64(scriptContent)) {
+        throw new Error('Invalid base64 script content');
+      }
+
+      doc.script = scriptContent;
+      doc.scriptFormat = scriptFormat;
+    }
+
     if (payload.name !== undefined) doc.name = String(payload.name || '').trim();
     if (payload.codeIdentifier !== undefined) doc.codeIdentifier = String(payload.codeIdentifier || '').trim();
     if (payload.description !== undefined) doc.description = String(payload.description || '');
     if (payload.type !== undefined) doc.type = String(payload.type || '').trim();
     if (payload.runner !== undefined) doc.runner = String(payload.runner || '').trim();
-    if (payload.script !== undefined) doc.script = String(payload.script || '');
     if (payload.defaultWorkingDirectory !== undefined) {
       doc.defaultWorkingDirectory = String(payload.defaultWorkingDirectory || '');
     }
@@ -126,23 +194,11 @@ exports.updateScript = async (req, res) => {
 
     await doc.save();
     after = doc.toObject();
-    audit(req, {
-      action: 'scripts.update',
-      outcome: 'success',
-      entityId: doc._id,
-      before,
-      after,
-    });
+    console.log('[updateScript] Script updated successfully:', { name: after.name, id: after._id });
     res.json({ item: doc.toObject() });
   } catch (err) {
-    audit(req, {
-      action: 'scripts.update',
-      outcome: 'failure',
-      entityId: req.params?.id,
-      before,
-      after,
-      details: { error: err?.message || 'Operation failed' },
-    });
+    console.log('[updateScript] ERROR occurred:', err);
+    console.log('[updateScript] ERROR message:', err.message);
     const safe = toSafeJsonError(err);
     res.status(safe.status).json(safe.body);
   }
@@ -156,23 +212,11 @@ exports.deleteScript = async (req, res) => {
     before = doc.toObject();
     await doc.deleteOne();
 
-    audit(req, {
-      action: 'scripts.delete',
-      outcome: 'success',
-      entityId: doc._id,
-      before,
-      after: null,
-    });
+    console.log('[deleteScript] Script deleted successfully:', { name: before.name, id: before._id });
     res.json({ ok: true });
   } catch (err) {
-    audit(req, {
-      action: 'scripts.delete',
-      outcome: 'failure',
-      entityId: req.params?.id,
-      before,
-      after: null,
-      details: { error: err?.message || 'Operation failed' },
-    });
+    console.log('[deleteScript] ERROR occurred:', err);
+    console.log('[deleteScript] ERROR message:', err.message);
     const safe = toSafeJsonError(err);
     res.status(safe.status).json(safe.body);
   }
@@ -189,25 +233,12 @@ exports.runScript = async (req, res) => {
 
     const runDoc = await startRun(doc, { trigger: 'manual', meta: { actorType: 'basicAuth' } });
 
-    audit(req, {
-      action: 'scripts.run',
-      outcome: 'success',
-      entityId: doc._id,
-      before: null,
-      after: null,
-      details: { runId: String(runDoc._id) },
-    });
+    console.log('[runScript] Script executed successfully:', { name: script.name, runId: runDoc._id });
 
     res.json({ runId: String(runDoc._id) });
   } catch (err) {
-    audit(req, {
-      action: 'scripts.run',
-      outcome: 'failure',
-      entityId: req.params?.id,
-      before: script,
-      after: null,
-      details: { error: err?.message || 'Operation failed' },
-    });
+    console.log('[runScript] ERROR occurred:', err);
+    console.log('[runScript] ERROR message:', err.message);
     const safe = toSafeJsonError(err);
     res.status(safe.status).json(safe.body);
   }
@@ -318,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/experiments.controller.js

@@ -0,0 +1,85 @@
+const experimentsService = require('../services/experiments.service');
+
+function toSafeJsonError(error) {
+  const msg = error?.message || 'Operation failed';
+  const code = error?.code;
+  if (code === 'VALIDATION') return { status: 400, body: { error: msg } };
+  if (code === 'NOT_FOUND') return { status: 404, body: { error: msg } };
+  if (code === 'CONFLICT') return { status: 409, body: { error: msg } };
+  return { status: 500, body: { error: msg } };
+}
+
+exports.getAssignment = async (req, res) => {
+  try {
+    const orgId = req.headers['x-org-id'] || req.query.orgId || req.body?.orgId;
+    const subjectId = req.query.subjectId || req.body?.subjectId;
+
+    const context = req.body?.context && typeof req.body.context === 'object' ? req.body.context : {};
+
+    const { experiment, assignment } = await experimentsService.getOrCreateAssignment({
+      orgId,
+      experimentCode: req.params.code,
+      subjectId,
+      context,
+    });
+
+    const variant = (experiment.variants || []).find((v) => String(v?.key || '') === String(assignment.variantKey));
+    const config = await experimentsService.resolveVariantConfig(variant);
+
+    const { snapshot } = await experimentsService.getWinnerSnapshot({ orgId, experimentCode: req.params.code });
+
+    return res.json({
+      experimentCode: experiment.code,
+      variantKey: assignment.variantKey,
+      assignedAt: assignment.assignedAt,
+      config,
+      winner: {
+        winnerVariantKey: snapshot.winnerVariantKey,
+        decidedAt: snapshot.winnerDecidedAt,
+        reason: snapshot.winnerReason,
+        status: snapshot.status,
+      },
+    });
+  } catch (err) {
+    const safe = toSafeJsonError(err);
+    return res.status(safe.status).json(safe.body);
+  }
+};
+
+exports.postEvents = async (req, res) => {
+  try {
+    const orgId = req.headers['x-org-id'] || req.query.orgId || req.body?.orgId;
+    const subjectId = req.query.subjectId || req.body?.subjectId;
+
+    const payload = req.body || {};
+    const events = Array.isArray(payload.events) ? payload.events : [payload];
+
+    const result = await experimentsService.ingestEvents({
+      orgId,
+      experimentCode: req.params.code,
+      subjectId,
+      events,
+    });
+
+    return res.status(201).json(result);
+  } catch (err) {
+    const safe = toSafeJsonError(err);
+    return res.status(safe.status).json(safe.body);
+  }
+};
+
+exports.getWinner = async (req, res) => {
+  try {
+    const orgId = req.headers['x-org-id'] || req.query.orgId || req.body?.orgId;
+    const { snapshot } = await experimentsService.getWinnerSnapshot({ orgId, experimentCode: req.params.code });
+    return res.json({
+      status: snapshot.status,
+      winnerVariantKey: snapshot.winnerVariantKey,
+      decidedAt: snapshot.winnerDecidedAt,
+      reason: snapshot.winnerReason,
+    });
+  } catch (err) {
+    const safe = toSafeJsonError(err);
+    return res.status(safe.status).json(safe.body);
+  }
+};

package/src/controllers/internalExperiments.controller.js

@@ -0,0 +1,17 @@
+const experimentsAggregation = require('../services/experimentsAggregation.service');
+const experimentsRetention = require('../services/experimentsRetention.service');
+
+exports.runAggregation = async (req, res) => {
+  const body = req.body || {};
+  const bucketMs = body.bucketMs;
+  const start = body.start;
+  const end = body.end;
+
+  const data = await experimentsAggregation.runAggregationAndWinner({ bucketMs, start, end });
+  return res.json(data);
+};
+
+exports.runRetention = async (_req, res) => {
+  const data = await experimentsRetention.runRetentionCleanup();
+  return res.json(data);
+};

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' });
+  }
+};