@intranefr/superbackend 1.4.4 → 1.5.1

package/src/controllers/adminScripts.controller.js

@@ -0,0 +1,320 @@
+const ScriptDefinition = require('../models/ScriptDefinition');
+const ScriptRun = require('../models/ScriptRun');
+const { startRun, getRunBus } = require('../services/scriptsRunner.service');
+const { logAuditSync } = require('../services/auditLogger');
+
+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 } };
+}
+
+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 = [];
+  for (const it of items) {
+    if (!it || typeof it !== 'object') continue;
+    const key = String(it.key || '').trim();
+    if (!key) continue;
+    out.push({ key, value: String(it.value || '') });
+  }
+  return out;
+}
+
+exports.listScripts = async (req, res) => {
+  try {
+    const items = await ScriptDefinition.find().sort({ updatedAt: -1 }).lean();
+    res.json({ items });
+  } catch (err) {
+    const safe = toSafeJsonError(err);
+    res.status(safe.status).json(safe.body);
+  }
+};
+
+exports.getScript = async (req, res) => {
+  try {
+    const doc = await ScriptDefinition.findById(req.params.id).lean();
+    if (!doc) return res.status(404).json({ error: 'Not found' });
+    res.json({ item: doc });
+  } catch (err) {
+    const safe = toSafeJsonError(err);
+    res.status(safe.status).json(safe.body);
+  }
+};
+
+exports.createScript = async (req, res) => {
+  let created = null;
+  try {
+    const payload = req.body || {};
+
+    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 || ''),
+      defaultWorkingDirectory: String(payload.defaultWorkingDirectory || ''),
+      env: normalizeEnv(payload.env),
+      timeoutMs: payload.timeoutMs === undefined ? undefined : Number(payload.timeoutMs),
+      enabled: payload.enabled === undefined ? true : Boolean(payload.enabled),
+    });
+
+    created = doc.toObject();
+    audit(req, {
+      action: 'scripts.create',
+      outcome: 'success',
+      entityId: doc._id,
+      before: null,
+      after: created,
+    });
+
+    res.status(201).json({ item: doc.toObject() });
+  } catch (err) {
+    audit(req, {
+      action: 'scripts.create',
+      outcome: 'failure',
+      entityId: created?._id,
+      before: null,
+      after: created,
+      details: { error: err?.message || 'Operation failed' },
+    });
+    const safe = toSafeJsonError(err);
+    res.status(safe.status).json(safe.body);
+  }
+};
+
+exports.updateScript = async (req, res) => {
+  let before = null;
+  let after = null;
+  try {
+    const payload = req.body || {};
+
+    const doc = await ScriptDefinition.findById(req.params.id);
+    if (!doc) return res.status(404).json({ error: 'Not found' });
+
+    before = doc.toObject();
+
+    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 || '');
+    }
+    if (payload.env !== undefined) doc.env = normalizeEnv(payload.env);
+    if (payload.timeoutMs !== undefined) doc.timeoutMs = Number(payload.timeoutMs || 0);
+    if (payload.enabled !== undefined) doc.enabled = Boolean(payload.enabled);
+
+    await doc.save();
+    after = doc.toObject();
+    audit(req, {
+      action: 'scripts.update',
+      outcome: 'success',
+      entityId: doc._id,
+      before,
+      after,
+    });
+    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' },
+    });
+    const safe = toSafeJsonError(err);
+    res.status(safe.status).json(safe.body);
+  }
+};
+
+exports.deleteScript = async (req, res) => {
+  let before = null;
+  try {
+    const doc = await ScriptDefinition.findById(req.params.id);
+    if (!doc) return res.status(404).json({ error: 'Not found' });
+    before = doc.toObject();
+    await doc.deleteOne();
+
+    audit(req, {
+      action: 'scripts.delete',
+      outcome: 'success',
+      entityId: doc._id,
+      before,
+      after: null,
+    });
+    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' },
+    });
+    const safe = toSafeJsonError(err);
+    res.status(safe.status).json(safe.body);
+  }
+};
+
+exports.runScript = async (req, res) => {
+  let script = null;
+  try {
+    const doc = await ScriptDefinition.findById(req.params.id);
+    if (!doc) return res.status(404).json({ error: 'Not found' });
+    if (!doc.enabled) return res.status(400).json({ error: 'Script is disabled' });
+
+    script = doc.toObject();
+
+    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) },
+    });
+
+    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' },
+    });
+    const safe = toSafeJsonError(err);
+    res.status(safe.status).json(safe.body);
+  }
+};
+
+exports.getRun = async (req, res) => {
+  try {
+    const run = await ScriptRun.findById(req.params.runId).lean();
+    if (!run) return res.status(404).json({ error: 'Not found' });
+    res.json({ item: run });
+  } catch (err) {
+    const safe = toSafeJsonError(err);
+    res.status(safe.status).json(safe.body);
+  }
+};
+
+exports.listRuns = async (req, res) => {
+  try {
+    const filter = {};
+    if (req.query.scriptId) filter.scriptId = req.query.scriptId;
+
+    const items = await ScriptRun.find(filter)
+      .sort({ createdAt: -1 })
+      .limit(50)
+      .lean();
+
+    res.json({ items });
+  } catch (err) {
+    const safe = toSafeJsonError(err);
+    res.status(safe.status).json(safe.body);
+  }
+};
+
+exports.streamRun = async (req, res) => {
+  try {
+    const runId = String(req.params.runId);
+
+    res.status(200);
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+
+    const bus = getRunBus(runId);
+
+    const since = Number(req.query.since || 0);
+    if (bus) {
+      const existing = bus.snapshot(since);
+      for (const e of existing) {
+        res.write(`event: ${e.type}\n`);
+        res.write(`data: ${JSON.stringify(e)}\n\n`);
+      }
+
+      const onEvent = (e) => {
+        res.write(`event: ${e.type}\n`);
+        res.write(`data: ${JSON.stringify(e)}\n\n`);
+      };
+      const cleanup = () => {
+        clearInterval(heartbeat);
+        bus.emitter.off('event', onEvent);
+        bus.emitter.off('close', onClose);
+      };
+
+      const onClose = () => {
+        cleanup();
+        res.end();
+      };
+
+      const heartbeat = setInterval(() => {
+        res.write(`: ping\n\n`);
+      }, 15000);
+      heartbeat.unref();
+
+      bus.emitter.on('event', onEvent);
+      bus.emitter.once('close', onClose);
+
+      req.on('close', () => {
+        cleanup();
+      });
+
+      return;
+    }
+
+    const run = await ScriptRun.findById(runId).lean();
+    if (!run) {
+      res.write(`event: error\n`);
+      res.write(`data: ${JSON.stringify({ error: 'Not found' })}\n\n`);
+      return res.end();
+    }
+
+    if (run.outputTail) {
+      res.write(`event: log\n`);
+      res.write(
+        `data: ${JSON.stringify({ seq: 1, type: 'log', ts: new Date().toISOString(), stream: 'stdout', line: run.outputTail })}\n\n`,
+      );
+    }
+    res.write(`event: status\n`);
+    res.write(
+      `data: ${JSON.stringify({ seq: 2, type: 'status', ts: new Date().toISOString(), status: run.status, exitCode: run.exitCode })}\n\n`,
+    );
+    res.write(`event: done\n`);
+    res.write(
+      `data: ${JSON.stringify({ seq: 3, type: 'done', ts: new Date().toISOString(), status: run.status, exitCode: run.exitCode })}\n\n`,
+    );
+    return res.end();
+  } catch (err) {
+    res.write(`event: error\n`);
+    res.write(`data: ${JSON.stringify({ error: err?.message || 'Stream error' })}\n\n`);
+    return res.end();
+  }
+};

package/src/controllers/adminSeoConfig.controller.js

@@ -1,4 +1,3 @@
-const OpenAI = require('openai');
 const fs = require('fs');
 const path = require('path');
 
@@ -15,6 +14,9 @@ const {
   DEFAULT_OG_PNG_OUTPUT_PATH,
 } = require('../services/seoConfig.service');
 
+const llmService = require('../services/llm.service');
+const { resolveLlmProviderModel } = require('../services/llmDefaults.service');
+
 function handleServiceError(res, error) {
   const msg = error?.message || 'Operation failed';
   const code = error?.code;
@@ -231,6 +233,7 @@ exports.seoConfigAiGenerateEntry = async (req, res) => {
     const viewPath = String(req.body?.viewPath || '').trim();
     const routePath = validateRoutePathOrThrow(req.body?.routePath);
     const modelOverride = req.body?.model;
+    const providerKeyOverride = req.body?.providerKey;
 
     if (!viewPath || !viewPath.endsWith('.ejs')) {
       return res.status(400).json({ error: 'viewPath is required and must end with .ejs' });
@@ -250,12 +253,18 @@ exports.seoConfigAiGenerateEntry = async (req, res) => {
       return res.status(400).json({ error: 'view file is too large' });
     }
 
-    const apiKey = await getSeoconfigOpenRouterApiKey();
-    if (!apiKey) {
-      return res.status(400).json({ error: 'AI is disabled (missing OpenRouter API key)' });
-    }
+    const resolved = await resolveLlmProviderModel({
+      systemKey: 'seoConfig.entry.generate',
+      providerKey: providerKeyOverride,
+      model: modelOverride,
+    });
 
-    const model = modelOverride || (await getSeoconfigOpenRouterModel());
+    const legacyApiKey = await getSeoconfigOpenRouterApiKey();
+    const runtimeOptions = (resolved.providerKey === 'openrouter' && legacyApiKey)
+      ? { apiKey: legacyApiKey, baseUrl: 'https://openrouter.ai/api/v1' }
+      : {};
+
+    const model = resolved.model || (await getSeoconfigOpenRouterModel());
 
     const { data } = await getSeoConfigData();
     const siteName = data?.siteName || '';
@@ -263,11 +272,6 @@ exports.seoConfigAiGenerateEntry = async (req, res) => {
 
     const ejsSource = await fs.promises.readFile(abs, 'utf8');
 
-    const client = new OpenAI({
-      apiKey,
-      baseURL: 'https://openrouter.ai/api/v1',
-    });
-
     const prompt = buildSeoEntryPromptFromEjs({
       routePath,
       viewRelPath: viewPath,
@@ -276,15 +280,20 @@ exports.seoConfigAiGenerateEntry = async (req, res) => {
       baseUrl,
     });
 
-    const resp = await client.chat.completions.create({
-      model,
-      messages: [{ role: 'user', content: prompt }],
-    });
+    const resp = await llmService.callAdhoc(
+      {
+        providerKey: resolved.providerKey,
+        model,
+        messages: [{ role: 'user', content: prompt }],
+        promptKeyForAudit: 'seoConfig.entry.generate',
+      },
+      runtimeOptions,
+    );
 
-    const out = resp.choices?.[0]?.message?.content || '';
+    const out = resp.content || '';
     const entry = parseAiJsonObjectOrThrow(out);
 
-    return res.json({ routePath, entry, model });
+    return res.json({ routePath, entry, model, providerKey: resolved.providerKey });
   } catch (error) {
     const code = error?.code;
     if (code === 'VALIDATION') {
@@ -323,6 +332,7 @@ exports.seoConfigAiImproveEntry = async (req, res) => {
     const routePath = validateRoutePathOrThrow(req.body?.routePath);
     const instruction = String(req.body?.instruction || '').trim();
     const modelOverride = req.body?.model;
+    const providerKeyOverride = req.body?.providerKey;
 
     if (!instruction) {
       return res.status(400).json({ error: 'instruction is required' });
@@ -331,12 +341,18 @@ exports.seoConfigAiImproveEntry = async (req, res) => {
       return res.status(400).json({ error: 'instruction is too large' });
     }
 
-    const apiKey = await getSeoconfigOpenRouterApiKey();
-    if (!apiKey) {
-      return res.status(400).json({ error: 'AI is disabled (missing OpenRouter API key)' });
-    }
+    const resolved = await resolveLlmProviderModel({
+      systemKey: 'seoConfig.entry.improve',
+      providerKey: providerKeyOverride,
+      model: modelOverride,
+    });
 
-    const model = modelOverride || (await getSeoconfigOpenRouterModel());
+    const legacyApiKey = await getSeoconfigOpenRouterApiKey();
+    const runtimeOptions = (resolved.providerKey === 'openrouter' && legacyApiKey)
+      ? { apiKey: legacyApiKey, baseUrl: 'https://openrouter.ai/api/v1' }
+      : {};
+
+    const model = resolved.model || (await getSeoconfigOpenRouterModel());
 
     const { data } = await getSeoConfigData();
     const siteName = data?.siteName || '';
@@ -346,11 +362,6 @@ exports.seoConfigAiImproveEntry = async (req, res) => {
       return res.status(404).json({ error: `No existing entry for ${routePath}` });
     }
 
-    const client = new OpenAI({
-      apiKey,
-      baseURL: 'https://openrouter.ai/api/v1',
-    });
-
     const prompt = buildSeoEntryPromptImprove({
       routePath,
       existingEntry,
@@ -359,15 +370,20 @@ exports.seoConfigAiImproveEntry = async (req, res) => {
       baseUrl,
     });
 
-    const resp = await client.chat.completions.create({
-      model,
-      messages: [{ role: 'user', content: prompt }],
-    });
+    const resp = await llmService.callAdhoc(
+      {
+        providerKey: resolved.providerKey,
+        model,
+        messages: [{ role: 'user', content: prompt }],
+        promptKeyForAudit: 'seoConfig.entry.improve',
+      },
+      runtimeOptions,
+    );
 
-    const out = resp.choices?.[0]?.message?.content || '';
+    const out = resp.content || '';
     const entry = parseAiJsonObjectOrThrow(out);
 
-    return res.json({ routePath, entry, model });
+    return res.json({ routePath, entry, model, providerKey: resolved.providerKey });
   } catch (error) {
     const code = error?.code;
     if (code === 'VALIDATION') {
@@ -469,6 +485,7 @@ exports.aiEditSvg = async (req, res) => {
     const svgRaw = req.body?.svgRaw;
     const instruction = req.body?.instruction;
     const modelOverride = req.body?.model;
+    const providerKeyOverride = req.body?.providerKey;
 
     if (typeof svgRaw !== 'string' || svgRaw.trim() === '') {
       return res.status(400).json({ error: 'svgRaw is required' });
@@ -484,30 +501,36 @@ exports.aiEditSvg = async (req, res) => {
       return res.status(400).json({ error: 'instruction is too large' });
     }
 
-    const apiKey = await getSeoconfigOpenRouterApiKey();
-    if (!apiKey) {
-      return res.status(400).json({ error: 'AI is disabled (missing OpenRouter API key)' });
-    }
+    const resolved = await resolveLlmProviderModel({
+      systemKey: 'seoConfig.ogSvg.edit',
+      providerKey: providerKeyOverride,
+      model: modelOverride,
+    });
 
-    const model = modelOverride || (await getSeoconfigOpenRouterModel());
+    const legacyApiKey = await getSeoconfigOpenRouterApiKey();
+    const runtimeOptions = (resolved.providerKey === 'openrouter' && legacyApiKey)
+      ? { apiKey: legacyApiKey, baseUrl: 'https://openrouter.ai/api/v1' }
+      : {};
 
-    const client = new OpenAI({
-      apiKey,
-      baseURL: 'https://openrouter.ai/api/v1',
-    });
+    const model = resolved.model || (await getSeoconfigOpenRouterModel());
 
     const prompt = buildSvgAiPrompt({ svg: svgRaw, instruction });
-    const resp = await client.chat.completions.create({
-      model,
-      messages: [{ role: 'user', content: prompt }],
-    });
+    const resp = await llmService.callAdhoc(
+      {
+        providerKey: resolved.providerKey,
+        model,
+        messages: [{ role: 'user', content: prompt }],
+        promptKeyForAudit: 'seoConfig.ogSvg.edit',
+      },
+      runtimeOptions,
+    );
 
-    const out = resp.choices?.[0]?.message?.content?.trim() || '';
+    const out = String(resp.content || '').trim();
     if (!out.startsWith('<svg') || !out.includes('</svg>')) {
       return res.status(500).json({ error: 'AI returned invalid SVG' });
     }
 
-    return res.json({ svgRaw: out, model });
+    return res.json({ svgRaw: out, model, providerKey: resolved.providerKey });
   } catch (error) {
     console.error('Error editing SVG with AI:', error);
     return res.status(500).json({ error: error?.message || 'Failed to edit SVG' });

package/src/controllers/adminTerminals.controller.js

@@ -0,0 +1,39 @@
+const {
+  createSession,
+  listSessions,
+  killSession,
+} = require('../services/terminals.service');
+
+function handleError(res, err) {
+  const msg = err?.message || 'Operation failed';
+  const code = err?.code;
+  if (code === 'NOT_FOUND') return res.status(404).json({ error: msg });
+  if (code === 'LIMIT') return res.status(429).json({ error: msg });
+  return res.status(500).json({ error: msg });
+}
+
+exports.createSession = async (req, res) => {
+  try {
+    const { cols, rows } = req.body || {};
+    const result = createSession({ cols, rows });
+    res.json(result);
+  } catch (err) {
+    handleError(res, err);
+  }
+};
+
+exports.listSessions = async (req, res) => {
+  try {
+    res.json({ items: listSessions() });
+  } catch (err) {
+    handleError(res, err);
+  }
+};
+
+exports.killSession = async (req, res) => {
+  try {
+    res.json(killSession(req.params.sessionId));
+  } catch (err) {
+    handleError(res, err);
+  }
+};