@intranefr/superbackend 1.4.4 → 1.5.0

package/index.js

@@ -11,6 +11,7 @@ const express = require("express");
  * @returns {express.Router} Configured Express router
  */
 const middleware = require("./src/middleware");
+const { attachTerminalWebsocketServer } = require('./src/services/terminalsWs.service');
 
 /**
  * Creates and starts a standalone SuperBackend server
@@ -24,13 +25,26 @@ function startServer(options = {}) {
   const app = express();
   const PORT = options.port || process.env.PORT || 3000;
 
-  app.use(module.exports.middleware(options));
+  const router = module.exports.middleware(options);
+  app.use(router);
 
   // Start server
   const server = app.listen(PORT, () => {
     console.log(`🚀 SuperBackend standalone server running on http://localhost:${PORT}`);
   });
 
+  // Attach WebSocket server via middleware helper or directly
+  console.log('[Index] Attaching WebSocket server...');
+  if (typeof router.attachWs === 'function') {
+    console.log('[Index] Using router.attachWs');
+    router.attachWs(server);
+  } else {
+    // Fallback: attach directly with admin path
+    const adminPath = router.adminPath || '/admin';
+    console.log('[Index] Using fallback attach with adminPath:', adminPath);
+    attachTerminalWebsocketServer(server, { basePathPrefix: adminPath });
+  }
+
   return { app, server };
 }
 
@@ -91,6 +105,7 @@ const saasbackend = {
     org: require("./src/middleware/org"),
     i18n: require("./src/services/i18n.service"),
     jsonConfigs: require("./src/services/jsonConfigs.service"),
+    terminals: require("./src/services/terminalsWs.service"),
   },
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intranefr/superbackend",
-  "version": "1.4.4",
+  "version": "1.5.0",
   "description": "Node.js middleware that gives your project backend superpowers",
   "main": "index.js",
   "scripts": {
@@ -9,6 +9,7 @@
     "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",
+    "build:sdk:ui-components:browser": "esbuild sdk/ui-components/browser/src/index.js --bundle --format=iife --outfile=public/sdk/ui-components.iife.js",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage"
@@ -41,11 +42,13 @@
     "jsonwebtoken": "^9.0.2",
     "mongoose": "^8.0.0",
     "multer": "^1.4.5-lts.1",
+    "node-pty": "^1.1.0",
     "openai": "^4.0.0",
     "resend": "^6.4.0",
     "ssh2-sftp-client": "^12.0.1",
     "stripe": "^14.0.0",
-    "vm2": "^3.10.0"
+    "vm2": "^3.10.0",
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "esbuild": "^0.25.0",

package/public/sdk/ui-components.iife.js

@@ -0,0 +1,191 @@
+(() => {
+  // sdk/ui-components/browser/src/index.js
+  (function() {
+    function toStr(v) {
+      return v === void 0 || v === null ? "" : String(v);
+    }
+    function normalizeApiUrl(apiUrl) {
+      const u = toStr(apiUrl).trim();
+      if (!u) return "";
+      return u.replace(/\/$/, "");
+    }
+    function buildHeaders(apiKey) {
+      const headers = {};
+      const key = toStr(apiKey).trim();
+      if (key) headers["x-project-key"] = key;
+      return headers;
+    }
+    async function fetchJson(url, headers) {
+      const res = await fetch(url, { headers: headers || {} });
+      const text = await res.text();
+      let data = null;
+      try {
+        data = text ? JSON.parse(text) : null;
+      } catch {
+        data = null;
+      }
+      if (!res.ok) {
+        const msg = data && data.error ? data.error : "Request failed";
+        const err = new Error(msg);
+        err.status = res.status;
+        throw err;
+      }
+      return data;
+    }
+    function ensureTemplate(code, html) {
+      const id = "ui-cmp-" + code;
+      let tpl = document.getElementById(id);
+      if (!tpl) {
+        tpl = document.createElement("template");
+        tpl.id = id;
+        document.body.appendChild(tpl);
+      }
+      tpl.innerHTML = toStr(html);
+      return tpl;
+    }
+    function injectCssScoped(code, cssText) {
+      const id = "ui-cmp-style-" + code;
+      let el = document.getElementById(id);
+      if (!el) {
+        el = document.createElement("style");
+        el.id = id;
+        document.head.appendChild(el);
+      }
+      el.textContent = toStr(cssText);
+    }
+    function createShadowRootContainer() {
+      const host = document.createElement("div");
+      host.style.all = "initial";
+      const shadow = host.attachShadow({ mode: "open" });
+      return { host, shadow };
+    }
+    function defaultMountTarget() {
+      return document.body;
+    }
+    function compileComponentJs(jsCode) {
+      const code = toStr(jsCode);
+      if (!code.trim()) {
+        return function() {
+          return {};
+        };
+      }
+      return new Function("api", "templateRootEl", "props", code);
+    }
+    const state = {
+      initialized: false,
+      projectId: null,
+      apiKey: null,
+      apiUrl: "",
+      cssIsolation: "scoped",
+      components: {}
+    };
+    function registerComponent(def) {
+      const code = toStr(def.code).trim().toLowerCase();
+      if (!code) return;
+      const version = def.version;
+      const html = def.html;
+      const js = def.js;
+      const css = def.css;
+      ensureTemplate(code, html);
+      const component = {
+        code,
+        version,
+        css,
+        js,
+        create: function(props, options) {
+          const opts = options || {};
+          const mountEl = opts.mountEl || defaultMountTarget();
+          const isolation = opts.cssIsolation || state.cssIsolation;
+          const tpl = ensureTemplate(code, html);
+          const fragment = tpl.content.cloneNode(true);
+          let templateRootEl;
+          let instanceRoot;
+          let shadow = null;
+          if (isolation === "shadow") {
+            const c = createShadowRootContainer();
+            instanceRoot = c.host;
+            shadow = c.shadow;
+            templateRootEl = shadow;
+            if (css) {
+              const style = document.createElement("style");
+              style.textContent = toStr(css);
+              shadow.appendChild(style);
+            }
+            shadow.appendChild(fragment);
+          } else {
+            instanceRoot = document.createElement("div");
+            templateRootEl = instanceRoot;
+            if (css) injectCssScoped(code, css);
+            instanceRoot.appendChild(fragment);
+          }
+          mountEl.appendChild(instanceRoot);
+          const api = {
+            unmount: function() {
+              try {
+                instanceRoot.remove();
+              } catch {
+              }
+            },
+            mountEl,
+            hostEl: instanceRoot,
+            shadowRoot: shadow
+          };
+          const fn = compileComponentJs(js);
+          let exported = {};
+          try {
+            exported = fn(api, templateRootEl, props || {}) || {};
+          } catch (e) {
+            exported = {
+              error: e
+            };
+          }
+          return Object.assign({ api }, exported);
+        }
+      };
+      state.components[code] = component;
+      uiCmp[code] = component;
+      uiComponents[code] = component;
+    }
+    async function init(options) {
+      const opts = options || {};
+      const projectId = toStr(opts.projectId).trim();
+      if (!projectId) throw new Error("projectId is required");
+      const apiUrl = normalizeApiUrl(opts.apiUrl);
+      const apiKey = opts.apiKey;
+      state.projectId = projectId;
+      state.apiKey = apiKey;
+      state.apiUrl = apiUrl;
+      const cssIsolation = toStr(opts.cssIsolation || "scoped").trim().toLowerCase();
+      state.cssIsolation = cssIsolation === "shadow" ? "shadow" : "scoped";
+      const base = state.apiUrl;
+      const url = base + "/api/ui-components/projects/" + encodeURIComponent(projectId) + "/manifest";
+      const data = await fetchJson(url, buildHeaders(apiKey));
+      const items = data && Array.isArray(data.components) ? data.components : [];
+      for (const def of items) {
+        registerComponent(def);
+      }
+      state.initialized = true;
+      return { project: data ? data.project : null, count: items.length };
+    }
+    async function load(code) {
+      const c = toStr(code).trim().toLowerCase();
+      if (!c) throw new Error("code is required");
+      if (!state.projectId) throw new Error("uiCmp not initialized");
+      if (state.components[c]) return state.components[c];
+      const base = state.apiUrl;
+      const url = base + "/api/ui-components/projects/" + encodeURIComponent(state.projectId) + "/components/" + encodeURIComponent(c);
+      const data = await fetchJson(url, buildHeaders(state.apiKey));
+      if (!data || !data.component) throw new Error("Component not found");
+      registerComponent(data.component);
+      return state.components[c];
+    }
+    const uiCmp = {
+      init,
+      load,
+      _state: state
+    };
+    const uiComponents = uiCmp;
+    window.uiCmp = uiCmp;
+    window.uiComponents = uiComponents;
+  })();
+})();

package/sdk/ui-components/browser/src/index.js

@@ -0,0 +1,228 @@
+(function () {
+  function toStr(v) {
+    return v === undefined || v === null ? '' : String(v);
+  }
+
+  function normalizeApiUrl(apiUrl) {
+    const u = toStr(apiUrl).trim();
+    if (!u) return '';
+    return u.replace(/\/$/, '');
+  }
+
+  function buildHeaders(apiKey) {
+    const headers = {};
+    const key = toStr(apiKey).trim();
+    if (key) headers['x-project-key'] = key;
+    return headers;
+  }
+
+  async function fetchJson(url, headers) {
+    const res = await fetch(url, { headers: headers || {} });
+    const text = await res.text();
+    let data = null;
+    try {
+      data = text ? JSON.parse(text) : null;
+    } catch {
+      data = null;
+    }
+    if (!res.ok) {
+      const msg = data && data.error ? data.error : 'Request failed';
+      const err = new Error(msg);
+      err.status = res.status;
+      throw err;
+    }
+    return data;
+  }
+
+  function ensureTemplate(code, html) {
+    const id = 'ui-cmp-' + code;
+    let tpl = document.getElementById(id);
+    if (!tpl) {
+      tpl = document.createElement('template');
+      tpl.id = id;
+      document.body.appendChild(tpl);
+    }
+    tpl.innerHTML = toStr(html);
+    return tpl;
+  }
+
+  function injectCssScoped(code, cssText) {
+    const id = 'ui-cmp-style-' + code;
+    let el = document.getElementById(id);
+    if (!el) {
+      el = document.createElement('style');
+      el.id = id;
+      document.head.appendChild(el);
+    }
+    el.textContent = toStr(cssText);
+  }
+
+  function createShadowRootContainer() {
+    const host = document.createElement('div');
+    host.style.all = 'initial';
+    const shadow = host.attachShadow({ mode: 'open' });
+    return { host, shadow };
+  }
+
+  function defaultMountTarget() {
+    return document.body;
+  }
+
+  function compileComponentJs(jsCode) {
+    const code = toStr(jsCode);
+    if (!code.trim()) {
+      return function () {
+        return {};
+      };
+    }
+    return new Function('api', 'templateRootEl', 'props', code);
+  }
+
+  const state = {
+    initialized: false,
+    projectId: null,
+    apiKey: null,
+    apiUrl: '',
+    cssIsolation: 'scoped',
+    components: {},
+  };
+
+  function registerComponent(def) {
+    const code = toStr(def.code).trim().toLowerCase();
+    if (!code) return;
+
+    const version = def.version;
+    const html = def.html;
+    const js = def.js;
+    const css = def.css;
+
+    ensureTemplate(code, html);
+
+    const component = {
+      code,
+      version,
+      css,
+      js,
+      create: function (props, options) {
+        const opts = options || {};
+        const mountEl = opts.mountEl || defaultMountTarget();
+        const isolation = opts.cssIsolation || state.cssIsolation;
+
+        const tpl = ensureTemplate(code, html);
+        const fragment = tpl.content.cloneNode(true);
+
+        let templateRootEl;
+        let instanceRoot;
+        let shadow = null;
+
+        if (isolation === 'shadow') {
+          const c = createShadowRootContainer();
+          instanceRoot = c.host;
+          shadow = c.shadow;
+          templateRootEl = shadow;
+          if (css) {
+            const style = document.createElement('style');
+            style.textContent = toStr(css);
+            shadow.appendChild(style);
+          }
+          shadow.appendChild(fragment);
+        } else {
+          instanceRoot = document.createElement('div');
+          templateRootEl = instanceRoot;
+          if (css) injectCssScoped(code, css);
+          instanceRoot.appendChild(fragment);
+        }
+
+        mountEl.appendChild(instanceRoot);
+
+        const api = {
+          unmount: function () {
+            try {
+              instanceRoot.remove();
+            } catch {}
+          },
+          mountEl,
+          hostEl: instanceRoot,
+          shadowRoot: shadow,
+        };
+
+        const fn = compileComponentJs(js);
+        let exported = {};
+        try {
+          exported = fn(api, templateRootEl, props || {}) || {};
+        } catch (e) {
+          exported = {
+            error: e,
+          };
+        }
+
+        return Object.assign({ api }, exported);
+      },
+    };
+
+    state.components[code] = component;
+    uiCmp[code] = component;
+    uiComponents[code] = component;
+  }
+
+  async function init(options) {
+    const opts = options || {};
+    const projectId = toStr(opts.projectId).trim();
+    if (!projectId) throw new Error('projectId is required');
+
+    const apiUrl = normalizeApiUrl(opts.apiUrl);
+    const apiKey = opts.apiKey;
+
+    state.projectId = projectId;
+    state.apiKey = apiKey;
+    state.apiUrl = apiUrl;
+
+    const cssIsolation = toStr(opts.cssIsolation || 'scoped').trim().toLowerCase();
+    state.cssIsolation = cssIsolation === 'shadow' ? 'shadow' : 'scoped';
+
+    const base = state.apiUrl;
+    const url = base + '/api/ui-components/projects/' + encodeURIComponent(projectId) + '/manifest';
+
+    const data = await fetchJson(url, buildHeaders(apiKey));
+    const items = data && Array.isArray(data.components) ? data.components : [];
+
+    for (const def of items) {
+      registerComponent(def);
+    }
+
+    state.initialized = true;
+    return { project: data ? data.project : null, count: items.length };
+  }
+
+  async function load(code) {
+    const c = toStr(code).trim().toLowerCase();
+    if (!c) throw new Error('code is required');
+    if (!state.projectId) throw new Error('uiCmp not initialized');
+    if (state.components[c]) return state.components[c];
+
+    const base = state.apiUrl;
+    const url =
+      base +
+      '/api/ui-components/projects/' +
+      encodeURIComponent(state.projectId) +
+      '/components/' +
+      encodeURIComponent(c);
+
+    const data = await fetchJson(url, buildHeaders(state.apiKey));
+    if (!data || !data.component) throw new Error('Component not found');
+
+    registerComponent(data.component);
+    return state.components[c];
+  }
+
+  const uiCmp = {
+    init,
+    load,
+    _state: state,
+  };
+
+  const uiComponents = uiCmp;
+
+  window.uiCmp = uiCmp;
+  window.uiComponents = uiComponents;
+})();

package/src/controllers/admin.controller.js

@@ -1,5 +1,12 @@
 const User = require('../models/User');
 const StripeWebhookEvent = require('../models/StripeWebhookEvent');
+const Organization = require('../models/Organization');
+const OrganizationMember = require('../models/OrganizationMember');
+const Asset = require('../models/Asset');
+const Notification = require('../models/Notification');
+const Invite = require('../models/Invite');
+const EmailLog = require('../models/EmailLog');
+const FormSubmission = require('../models/FormSubmission');
 const asyncHandler = require('../utils/asyncHandler');
 const fs = require('fs');
 const path = require('path');
@@ -353,12 +360,94 @@ const provisionCoolifyDeploy = asyncHandler(async (req, res) => {
   }
 });
 
+// Delete user (admin only)
+const deleteUser = asyncHandler(async (req, res) => {
+  
+  const userId = req.params.id;
+  
+  // 1. Validate user exists
+  const user = await User.findById(userId);
+  if (!user) {
+    return res.status(404).json({ error: 'User not found' });
+  }
+  
+  // 2. Prevent self-deletion
+  // Note: In a real implementation, you'd get the admin ID from req.admin or similar
+  // For now, we'll skip this check as the basic auth doesn't provide user identity
+  
+  // 3. Check if this is the last admin
+  const adminCount = await User.countDocuments({ role: 'admin' });
+  if (user.role === 'admin' && adminCount <= 1) {
+    return res.status(400).json({ error: 'Cannot delete the last admin user' });
+  }
+  
+  // 4. Cleanup dependencies
+  await cleanupUserData(userId);
+  
+  // 5. Delete user
+  await User.findByIdAndDelete(userId);
+  
+  // 6. Log action
+  console.log(`Admin deleted user: ${user.email} (${userId})`);
+  
+  res.json({ message: 'User deleted successfully' });
+});
+
+// Helper function to clean up user data
+async function cleanupUserData(userId) {
+  
+  try {
+    // Handle organizations owned by user
+    const ownedOrgs = await Organization.find({ ownerUserId: userId });
+    for (const org of ownedOrgs) {
+      // Check if organization has other members
+      const memberCount = await OrganizationMember.countDocuments({ 
+        orgId: org._id, 
+        userId: { $ne: userId } 
+      });
+      
+      if (memberCount === 0) {
+        // Delete organization if no other members
+        await Organization.findByIdAndDelete(org._id);
+        console.log(`Deleted organization ${org.name} (${org._id}) - no other members`);
+      } else {
+        // Remove owner but keep organization
+        org.ownerUserId = null;
+        await org.save();
+        console.log(`Removed owner from organization ${org.name} (${org._id}) - has other members`);
+      }
+    }
+    
+    // Remove from all organization memberships
+    await OrganizationMember.deleteMany({ userId: userId });
+    
+    // Delete user's assets
+    await Asset.deleteMany({ ownerUserId: userId });
+    
+    // Delete notifications
+    await Notification.deleteMany({ userId: userId });
+    
+    // Clean up other references
+    await Invite.deleteMany({ createdByUserId: userId });
+    await EmailLog.deleteMany({ userId: userId });
+    await FormSubmission.deleteMany({ userId: userId });
+    
+    // Note: We keep ActivityLog and AuditEvent for audit purposes
+    
+    console.log(`Completed cleanup for user ${userId}`);
+  } catch (error) {
+    console.error('Error during user cleanup:', error);
+    throw error;
+  }
+}
+
 module.exports = {
   getUsers,
   registerUser,
   getUser,
   updateUserSubscription,
   updateUserPassword,
+  deleteUser,
   reconcileUser,
   generateToken,
   getWebhookEvents,

package/src/controllers/adminHeadless.controller.js

@@ -7,6 +7,12 @@ const {
   getDynamicModel,
 } = require('../services/headlessModels.service');
 
+const {
+  listExternalCollections,
+  inferExternalModelFromCollection,
+  createOrUpdateExternalModel,
+} = require('../services/headlessExternalModels.service');
+
 const llmService = require('../services/llm.service');
 const { getSettingValue } = require('../services/globalSettings.service');
 const { createAuditEvent, getBasicAuthActor } = require('../services/audit.service');
@@ -399,6 +405,82 @@ exports.deleteModel = async (req, res) => {
   }
 };
 
+// External models (Mongo collections)
+exports.listExternalCollections = async (req, res) => {
+  try {
+    const q = String(req.query.q || '').trim() || null;
+    const includeSystem = String(req.query.includeSystem || '').trim().toLowerCase() === 'true';
+    const items = await listExternalCollections({ q, includeSystem });
+    return res.json({ items });
+  } catch (error) {
+    console.error('Error listing external mongo collections:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.inferExternalCollection = async (req, res) => {
+  try {
+    const body = req.body && typeof req.body === 'object' ? req.body : {};
+    const collectionName = String(body.collectionName || '').trim();
+    const sampleSize = body.sampleSize;
+    const result = await inferExternalModelFromCollection({ collectionName, sampleSize });
+    return res.json(result);
+  } catch (error) {
+    console.error('Error inferring external collection schema:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.importExternalModel = async (req, res) => {
+  try {
+    const body = req.body && typeof req.body === 'object' ? req.body : {};
+    const collectionName = String(body.collectionName || '').trim();
+    const codeIdentifier = String(body.codeIdentifier || '').trim();
+    const displayName = String(body.displayName || '').trim();
+    const sampleSize = body.sampleSize;
+
+    const result = await createOrUpdateExternalModel({
+      collectionName,
+      codeIdentifier,
+      displayName,
+      sampleSize,
+    });
+
+    return res.status(result.created ? 201 : 200).json({ item: result.item, inference: result.inference });
+  } catch (error) {
+    console.error('Error importing external model:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.syncExternalModel = async (req, res) => {
+  try {
+    const codeIdentifier = String(req.params.codeIdentifier || '').trim();
+    const existing = await getModelDefinitionByCode(codeIdentifier);
+    if (!existing) return res.status(404).json({ error: 'Model not found' });
+
+    const isExternal = existing.sourceType === 'external' || existing.isExternal === true;
+    if (!isExternal) {
+      return res.status(400).json({ error: 'Model is not external' });
+    }
+
+    const body = req.body && typeof req.body === 'object' ? req.body : {};
+    const sampleSize = body.sampleSize;
+
+    const result = await createOrUpdateExternalModel({
+      collectionName: existing.sourceCollectionName,
+      codeIdentifier: existing.codeIdentifier,
+      displayName: existing.displayName,
+      sampleSize,
+    });
+
+    return res.json({ item: result.item, inference: result.inference });
+  } catch (error) {
+    console.error('Error syncing external model:', error);
+    return handleServiceError(res, error);
+  }
+};
+
 exports.validateModelDefinition = async (req, res) => {
   try {
     const body = req.body || {};