@intranefr/superbackend 1.4.4 → 1.5.0

package/src/controllers/orgAdmin.controller.js

@@ -3,6 +3,9 @@ const mongoose = require('mongoose');
 const Organization = require('../models/Organization');
 const OrganizationMember = require('../models/OrganizationMember');
 const Invite = require('../models/Invite');
+const User = require('../models/User');
+const Asset = require('../models/Asset');
+const Notification = require('../models/Notification');
 const emailService = require('../services/email.service');
 const { isValidOrgRole, getAllowedOrgRoles, getDefaultOrgRole } = require('../utils/orgRoles');
 
@@ -489,3 +492,286 @@ exports.resendInvite = async (req, res) => {
     return res.status(500).json({ error: 'Failed to resend invite' });
   }
 };
+
+// Create organization (admin only)
+exports.createOrganization = async (req, res) => {
+  try {
+    const { name, description, ownerUserId } = req.body;
+    
+    // Validation
+    if (!name || typeof name !== 'string' || name.trim().length < 2) {
+      return res.status(400).json({ error: 'Name must be at least 2 characters long' });
+    }
+    
+    if (name.trim().length > 100) {
+      return res.status(400).json({ error: 'Name must be less than 100 characters' });
+    }
+    
+    if (description && description.trim().length > 500) {
+      return res.status(400).json({ error: 'Description must be less than 500 characters' });
+    }
+    
+    // Validate owner if specified
+    let ownerId = null;
+    if (ownerUserId) {
+      if (!mongoose.Types.ObjectId.isValid(String(ownerUserId))) {
+        return res.status(400).json({ error: 'Invalid owner user ID' });
+      }
+      
+      const owner = await User.findById(ownerUserId);
+      if (!owner) {
+        return res.status(400).json({ error: 'Owner user not found' });
+      }
+      ownerId = owner._id;
+    } else {
+      // Default to first admin user if no owner specified
+      const defaultOwner = await User.findOne({ role: 'admin' });
+      if (!defaultOwner) {
+        return res.status(400).json({ error: 'No admin user available to assign as owner' });
+      }
+      ownerId = defaultOwner._id;
+    }
+    
+    // Generate unique slug
+    let baseSlug = name.trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, '')
+      .replace(/\s+/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '');
+    
+    if (!baseSlug || baseSlug.length < 2) {
+      return res.status(400).json({ error: 'Name must contain valid characters for slug generation' });
+    }
+    
+    let slug = baseSlug;
+    let counter = 1;
+    
+    while (await Organization.findOne({ slug })) {
+      slug = `${baseSlug}-${counter}`;
+      counter++;
+      if (counter > 1000) {
+        return res.status(500).json({ error: 'Unable to generate unique slug' });
+      }
+    }
+    
+    // Create organization
+    const org = await Organization.create({
+      name: name.trim(),
+      slug,
+      description: description ? description.trim() : '',
+      ownerUserId: ownerId,
+      status: 'active',
+      settings: {}
+    });
+    
+    console.log(`Admin created organization: ${org.name} (${org._id}) with owner: ${ownerId}`);
+    
+    res.status(201).json({ 
+      message: 'Organization created successfully',
+      org: org.toObject() 
+    });
+  } catch (error) {
+    console.error('Create organization error:', error);
+    if (error.code === 11000) {
+      // Duplicate key error
+      return res.status(400).json({ error: 'Organization with this name or slug already exists' });
+    }
+    return res.status(500).json({ error: 'Failed to create organization' });
+  }
+};
+
+// Update organization (admin only)
+exports.updateOrganization = async (req, res) => {
+  try {
+    const { orgId } = req.params;
+    const { name, description, ownerUserId, status } = req.body;
+    
+    if (!orgId || !mongoose.Types.ObjectId.isValid(String(orgId))) {
+      return res.status(400).json({ error: 'Invalid organization ID' });
+    }
+    
+    const org = await Organization.findById(orgId);
+    if (!org) {
+      return res.status(404).json({ error: 'Organization not found' });
+    }
+    
+    // Update name (but not slug - per requirements)
+    if (name !== undefined) {
+      if (!name || typeof name !== 'string' || name.trim().length < 2) {
+        return res.status(400).json({ error: 'Name must be at least 2 characters long' });
+      }
+      if (name.trim().length > 100) {
+        return res.status(400).json({ error: 'Name must be less than 100 characters' });
+      }
+      org.name = name.trim();
+    }
+    
+    // Update description
+    if (description !== undefined) {
+      if (description && description.trim().length > 500) {
+        return res.status(400).json({ error: 'Description must be less than 500 characters' });
+      }
+      org.description = description ? description.trim() : '';
+    }
+    
+    // Update owner
+    if (ownerUserId !== undefined) {
+      if (ownerUserId) {
+        if (!mongoose.Types.ObjectId.isValid(String(ownerUserId))) {
+          return res.status(400).json({ error: 'Invalid owner user ID' });
+        }
+        const owner = await User.findById(ownerUserId);
+        if (!owner) {
+          return res.status(400).json({ error: 'Owner user not found' });
+        }
+        org.ownerUserId = owner._id;
+      } else {
+        return res.status(400).json({ error: 'Owner cannot be empty' });
+      }
+    }
+    
+    // Update status
+    if (status !== undefined) {
+      if (!['active', 'disabled'].includes(status)) {
+        return res.status(400).json({ error: 'Status must be either "active" or "disabled"' });
+      }
+      org.status = status;
+    }
+    
+    await org.save();
+    
+    console.log(`Admin updated organization: ${org.name} (${org._id})`);
+    
+    res.json({ 
+      message: 'Organization updated successfully',
+      org: org.toObject() 
+    });
+  } catch (error) {
+    console.error('Update organization error:', error);
+    return res.status(500).json({ error: 'Failed to update organization' });
+  }
+};
+
+// Disable organization (admin only)
+exports.disableOrganization = async (req, res) => {
+  try {
+    const { orgId } = req.params;
+    
+    if (!orgId || !mongoose.Types.ObjectId.isValid(String(orgId))) {
+      return res.status(400).json({ error: 'Invalid organization ID' });
+    }
+    
+    const org = await Organization.findById(orgId);
+    if (!org) {
+      return res.status(404).json({ error: 'Organization not found' });
+    }
+    
+    if (org.status === 'disabled') {
+      return res.status(400).json({ error: 'Organization is already disabled' });
+    }
+    
+    org.status = 'disabled';
+    await org.save();
+    
+    console.log(`Admin disabled organization: ${org.name} (${org._id})`);
+    
+    res.json({ 
+      message: 'Organization disabled successfully',
+      org: org.toObject() 
+    });
+  } catch (error) {
+    console.error('Disable organization error:', error);
+    return res.status(500).json({ error: 'Failed to disable organization' });
+  }
+};
+
+// Enable organization (admin only)
+exports.enableOrganization = async (req, res) => {
+  try {
+    const { orgId } = req.params;
+    
+    if (!orgId || !mongoose.Types.ObjectId.isValid(String(orgId))) {
+      return res.status(400).json({ error: 'Invalid organization ID' });
+    }
+    
+    const org = await Organization.findById(orgId);
+    if (!org) {
+      return res.status(404).json({ error: 'Organization not found' });
+    }
+    
+    if (org.status === 'active') {
+      return res.status(400).json({ error: 'Organization is already active' });
+    }
+    
+    org.status = 'active';
+    await org.save();
+    
+    console.log(`Admin enabled organization: ${org.name} (${org._id})`);
+    
+    res.json({ 
+      message: 'Organization enabled successfully',
+      org: org.toObject() 
+    });
+  } catch (error) {
+    console.error('Enable organization error:', error);
+    return res.status(500).json({ error: 'Failed to enable organization' });
+  }
+};
+
+// Delete organization (admin only)
+exports.deleteOrganization = async (req, res) => {
+  try {
+    const { orgId } = req.params;
+    
+    if (!orgId || !mongoose.Types.ObjectId.isValid(String(orgId))) {
+      return res.status(400).json({ error: 'Invalid organization ID' });
+    }
+    
+    const org = await Organization.findById(orgId);
+    if (!org) {
+      return res.status(404).json({ error: 'Organization not found' });
+    }
+    
+    // Cascade cleanup
+    await cleanupOrganizationData(orgId);
+    
+    // Delete organization
+    await Organization.findByIdAndDelete(orgId);
+    
+    console.log(`Admin deleted organization: ${org.name} (${org._id})`);
+    
+    res.json({ message: 'Organization deleted successfully' });
+  } catch (error) {
+    console.error('Delete organization error:', error);
+    return res.status(500).json({ error: 'Failed to delete organization' });
+  }
+};
+
+// Helper function to clean up organization data
+async function cleanupOrganizationData(orgId) {
+  try {
+    // Delete organization members
+    await OrganizationMember.deleteMany({ orgId });
+    
+    // Delete organization invites
+    await Invite.deleteMany({ orgId });
+    
+    // Delete organization assets
+    await Asset.deleteMany({ ownerUserId: { $in: await getOrganizationUserIds(orgId) } });
+    
+    // Delete organization notifications
+    await Notification.deleteMany({ userId: { $in: await getOrganizationUserIds(orgId) } });
+    
+    console.log(`Completed cleanup for organization ${orgId}`);
+  } catch (error) {
+    console.error('Error during organization cleanup:', error);
+    throw error;
+  }
+}
+
+// Helper function to get all user IDs in an organization
+async function getOrganizationUserIds(orgId) {
+  const members = await OrganizationMember.find({ orgId }).distinct('userId');
+  return members;
+}

package/src/controllers/uiComponentsPublic.controller.js

@@ -0,0 +1,118 @@
+const UiComponent = require('../models/UiComponent');
+const UiComponentProject = require('../models/UiComponentProject');
+const UiComponentProjectComponent = require('../models/UiComponentProjectComponent');
+
+const { verifyKey } = require('../services/uiComponentsCrypto.service');
+
+function extractProjectKey(req) {
+  const headerToken = req.headers['x-project-key'] || req.headers['x-api-key'];
+  if (headerToken) return String(headerToken).trim();
+  return null;
+}
+
+async function loadAndAuthorizeProject(req, res, projectId) {
+  const project = await UiComponentProject.findOne({ projectId: String(projectId), isActive: true }).lean();
+  if (!project) {
+    res.status(404).json({ error: 'Project not found' });
+    return null;
+  }
+
+  if (!project.isPublic) {
+    const key = extractProjectKey(req);
+    const ok = project.apiKeyHash && verifyKey(key, project.apiKeyHash);
+    if (!ok) {
+      res.status(401).json({ error: 'Invalid project key' });
+      return null;
+    }
+  }
+
+  return project;
+}
+
+exports.getManifest = async (req, res) => {
+  try {
+    const { projectId } = req.params;
+    const project = await loadAndAuthorizeProject(req, res, projectId);
+    if (!project) return;
+
+    const assignments = await UiComponentProjectComponent.find({ projectId: project.projectId, enabled: true }).lean();
+    const codes = assignments.map((a) => a.componentCode);
+
+    const components = await UiComponent.find({
+      code: { $in: codes },
+      isActive: true,
+    })
+      .sort({ code: 1 })
+      .lean();
+
+    const docsOnly = String(req.query.docs || '').toLowerCase() === 'true';
+
+    const out = components.map((c) => {
+      const base = {
+        code: c.code,
+        name: c.name,
+        version: c.version,
+      };
+      if (docsOnly) {
+        base.usageMarkdown = c.usageMarkdown;
+      } else {
+        base.html = c.html;
+        base.js = c.js;
+        base.css = c.css;
+      }
+      return base;
+    });
+
+    return res.json({
+      project: {
+        projectId: project.projectId,
+        name: project.name,
+        isPublic: project.isPublic,
+        allowedOrigins: project.allowedOrigins || [],
+      },
+      components: out,
+    });
+  } catch (error) {
+    console.error('UI Components getManifest error:', error);
+    return res.status(500).json({ error: 'Failed to load manifest' });
+  }
+};
+
+exports.getComponent = async (req, res) => {
+  try {
+    const { projectId, code } = req.params;
+    const project = await loadAndAuthorizeProject(req, res, projectId);
+    if (!project) return;
+
+    const componentCode = String(code || '').trim().toLowerCase();
+
+    const assignment = await UiComponentProjectComponent.findOne({
+      projectId: project.projectId,
+      componentCode,
+      enabled: true,
+    }).lean();
+
+    if (!assignment) return res.status(404).json({ error: 'Component not enabled for this project' });
+
+    const component = await UiComponent.findOne({ code: componentCode, isActive: true }).lean();
+    if (!component) return res.status(404).json({ error: 'Component not found' });
+
+    return res.json({
+      project: {
+        projectId: project.projectId,
+        isPublic: project.isPublic,
+      },
+      component: {
+        code: component.code,
+        name: component.name,
+        version: component.version,
+        html: component.html,
+        js: component.js,
+        css: component.css,
+      },
+    });
+  } catch (error) {
+    console.error('UI Components getComponent error:', error);
+    return res.status(500).json({ error: 'Failed to load component' });
+  }
+};

package/src/middleware/auth.js

@@ -19,6 +19,7 @@ const authenticate = async (req, res, next) => {
     req.user = user;
     next();
   } catch (error) {
+    console.error("api authenticate error:", error);
     return res
       .status(401)
       .json({ error: error.message || "Authentication failed" });
@@ -45,6 +46,12 @@ const basicAuth = (req, res, next) => {
   if (username === adminUsername && password === adminPassword) {
     next();
   } else {
+    console.error("api basicAuth error:", {
+      username,
+      password,
+      adminUsername,
+      adminPassword,
+    });
     res.setHeader("WWW-Authenticate", 'Basic realm="Admin Area"');
     return res.status(401).json({ error: "Invalid credentials" });
   }

package/src/middleware.js

@@ -31,6 +31,13 @@ function createMiddleware(options = {}) {
   const router = express.Router();
   const adminPath = options.adminPath || "/admin";
 
+  // Expose adminPath and WS attachment helper
+  router.adminPath = adminPath;
+  router.attachWs = (server) => {
+    const { attachTerminalWebsocketServer } = require('./services/terminalsWs.service');
+    attachTerminalWebsocketServer(server, { basePathPrefix: adminPath });
+  };
+
   // Initialize console override service early to capture all logs
   consoleOverride.init();
 
@@ -142,6 +149,12 @@ function createMiddleware(options = {}) {
   // Serve public static files (e.g. /og/og-default.png)
   router.use(express.static(path.join(__dirname, "..", "public")));
 
+  // Serve browser SDK bundles
+  router.use(
+    "/public/sdk",
+    express.static(path.join(__dirname, "..", "public", "sdk")),
+  );
+
   // Serve static files for admin views
   router.use(
     `${adminPath}/assets`,
@@ -188,6 +201,70 @@ function createMiddleware(options = {}) {
     });
   });
 
+  router.get(`${adminPath}/terminals`, basicAuth, (req, res) => {
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-terminals.ejs",
+    );
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          {
+            baseUrl: req.baseUrl,
+            adminPath,
+            endpointRegistry,
+          },
+          {
+            filename: templatePath,
+          },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
+  router.get(`${adminPath}/scripts`, basicAuth, (req, res) => {
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-scripts.ejs",
+    );
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          {
+            baseUrl: req.baseUrl,
+            adminPath,
+            endpointRegistry,
+          },
+          {
+            filename: templatePath,
+          },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
   router.use("/api/admin", require("./routes/admin.routes"));
   router.use("/api/admin/settings", require("./routes/globalSettings.routes"));
   router.use(
@@ -204,11 +281,14 @@ function createMiddleware(options = {}) {
   );
   router.use("/api/admin/i18n", require("./routes/adminI18n.routes"));
   router.use("/api/admin/headless", require("./routes/adminHeadless.routes"));
+  router.use("/api/admin/scripts", require("./routes/adminScripts.routes"));
+  router.use("/api/admin/terminals", require("./routes/adminTerminals.routes"));
   router.use("/api/admin/assets", require("./routes/adminAssets.routes"));
   router.use(
     "/api/admin/upload-namespaces",
     require("./routes/adminUploadNamespaces.routes"),
   );
+  router.use("/api/admin/ui-components", require("./routes/adminUiComponents.routes"));
   router.use("/api/admin/migration", require("./routes/adminMigration.routes"));
   router.use("/api/admin/errors", basicAuth, require("./routes/adminErrors.routes"));
   router.use("/api/admin/audit", basicAuth, require("./routes/adminAudit.routes"));
@@ -229,6 +309,8 @@ function createMiddleware(options = {}) {
   router.use("/api/invites", require("./routes/invite.routes"));
   router.use("/api/log", require("./routes/log.routes"));
   router.use("/api/error-tracking", require("./routes/errorTracking.routes"));
+  router.use("/api/ui-components", require("./routes/uiComponentsPublic.routes"));
+  router.use("/api/llm/ui", require("./routes/llmUi.routes"));
 
   // Public assets proxy
   router.use("/public/assets", require("./routes/publicAssets.routes"));
@@ -541,6 +623,39 @@ function createMiddleware(options = {}) {
     });
   });
 
+  // Admin UI Components page (protected by basic auth)
+  router.get(`${adminPath}/ui-components`, basicAuth, (req, res) => {
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-ui-components.ejs",
+    );
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          {
+            baseUrl: req.baseUrl,
+            adminPath,
+            endpointRegistry,
+          },
+          {
+            filename: templatePath,
+          },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
   // Admin JSON configs page (protected by basic auth)
   router.get(`${adminPath}/json-configs`, basicAuth, (req, res) => {
     const templatePath = path.join(

package/src/models/HeadlessModelDefinition.js

@@ -28,6 +28,16 @@ const headlessModelDefinitionSchema = new mongoose.Schema(
     description: { type: String, default: '' },
     fields: { type: [headlessFieldSchema], default: [] },
     indexes: { type: [headlessIndexSchema], default: [] },
+    sourceType: { type: String, enum: ['internal', 'external'], default: 'internal', index: true },
+    sourceCollectionName: { type: String, default: null, index: true },
+    isExternal: { type: Boolean, default: false, index: true },
+    inference: {
+      enabled: { type: Boolean, default: false },
+      lastInferredAt: { type: Date, default: null },
+      sampleSize: { type: Number, default: null },
+      warnings: { type: [String], default: [] },
+      stats: { type: mongoose.Schema.Types.Mixed, default: null },
+    },
     isActive: { type: Boolean, default: true, index: true },
     version: { type: Number, default: 1 },
     fieldsHash: { type: String, default: null },

package/src/models/ScriptDefinition.js

@@ -0,0 +1,42 @@
+const mongoose = require('mongoose');
+
+const envVarSchema = new mongoose.Schema(
+  {
+    key: { type: String, required: true },
+    value: { type: String, required: true },
+  },
+  { _id: false },
+);
+
+const scriptDefinitionSchema = new mongoose.Schema(
+  {
+    name: { type: String, required: true },
+    codeIdentifier: { type: String, required: true, unique: true, index: true },
+    description: { type: String, default: '' },
+    type: { type: String, enum: ['bash', 'node', 'browser'], required: true },
+    runner: { type: String, enum: ['host', 'vm2', 'browser'], required: true },
+    script: { type: String, required: true },
+    defaultWorkingDirectory: { type: String, default: '' },
+    env: { type: [envVarSchema], default: [] },
+    timeoutMs: { type: Number, default: 5 * 60 * 1000 },
+    enabled: { type: Boolean, default: true, index: true },
+  },
+  { timestamps: true, collection: 'script_definitions' },
+);
+
+function normalizeCodeIdentifier(codeIdentifier) {
+  return String(codeIdentifier || '')
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, '-')
+    .replace(/[^a-z0-9_-]/g, '');
+}
+
+scriptDefinitionSchema.pre('validate', function preValidate(next) {
+  this.codeIdentifier = normalizeCodeIdentifier(this.codeIdentifier);
+  next();
+});
+
+module.exports =
+  mongoose.models.ScriptDefinition ||
+  mongoose.model('ScriptDefinition', scriptDefinitionSchema);

package/src/models/ScriptRun.js

@@ -0,0 +1,22 @@
+const mongoose = require('mongoose');
+
+const scriptRunSchema = new mongoose.Schema(
+  {
+    scriptId: { type: mongoose.Schema.Types.ObjectId, ref: 'ScriptDefinition', required: true, index: true },
+    status: {
+      type: String,
+      enum: ['queued', 'running', 'succeeded', 'failed', 'canceled', 'timed_out'],
+      default: 'queued',
+      index: true,
+    },
+    trigger: { type: String, enum: ['manual', 'schedule', 'api'], default: 'manual', index: true },
+    startedAt: { type: Date, default: null },
+    finishedAt: { type: Date, default: null },
+    exitCode: { type: Number, default: null },
+    outputTail: { type: String, default: '' },
+    meta: { type: mongoose.Schema.Types.Mixed, default: null },
+  },
+  { timestamps: true, collection: 'script_runs' },
+);
+
+module.exports = mongoose.models.ScriptRun || mongoose.model('ScriptRun', scriptRunSchema);