@intranefr/superbackend 1.6.6 → 1.6.7

package/.env.example

@@ -65,3 +65,7 @@ MAX_FILE_SIZE_HARD_CAP=10485760
 # Set to 'false' to disable console manager initialization
 # When disabled, console methods are not overridden and no console entries are tracked
 # CONSOLE_MANAGER_ENABLED=true
+
+# Admin Dashboard
+# Maximum number of tabs allowed in the admin dashboard (default: 5)
+ADMIN_MAX_TABS=5

package/README.md

@@ -26,6 +26,8 @@ Node.js middleware that gives your project backend superpowers. Handles authenti
 - **Workflows System**: Node-based automation with LLM integration, conditionals, and HTTP calls
 - **LLM UI Integration**: AI-powered UI components and conversational interfaces
 - **Admin Scripts & Terminals**: Operational tooling for script execution and terminal management
+- **AI Agent System**: Configurable AI agents with tool integration and multi-interface support
+- **CLI Tools**: Terminal-based agent interaction and management commands
 - **Migration System**: Database migration and data transfer between environments
 - **Upload Namespaces**: Advanced file organization with customizable storage rules
 - **UI Components**: Project-scoped reusable UI widgets with browser SDK integration
@@ -85,6 +87,22 @@ const backend = new SuperBackend({
 
 ---
 
+## CLI Tools
+
+SuperBackend includes command-line tools for AI agent interaction:
+
+```bash
+# List available agents
+npx @intranefr/superbackend agent-list
+
+# Start interactive chat with an agent
+npx @intranefr/superbackend agent-chat
+```
+
+See [CLI-README.md](CLI-README.md) for detailed CLI usage.
+
+---
+
 ## Documentation
 
 See the `docs/features/` directory for detailed guides:

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@intranefr/superbackend",
-  "version": "1.6.6",
+  "version": "1.6.7",
   "description": "Node.js middleware that gives your project backend superpowers",
   "main": "index.js",
+  "bin": {
+    "agent-chat": "src/cli/agent-chat.js",
+    "agent-list": "src/cli/agent-list.js"
+  },
   "scripts": {
     "start": "node server.js",
     "dev": "nodemon --verbose --ignore uploads --ignore stdout.log --ignore '*.log' server.js",
@@ -10,6 +14,7 @@
     "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",
+    "build:sdk:superdemos:browser": "esbuild sdk/superdemos/browser/src/index.js --bundle --format=iife --global-name=SuperDemos --outfile=public/sdk/superdemos.iife.js",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage"

package/public/js/admin-superdemos.js

@@ -0,0 +1,396 @@
+(() => {
+  const { createApp, ref, computed, onBeforeUnmount } = Vue;
+
+  function withToast(fn, showToast) {
+    return async (...args) => {
+      try {
+        return await fn(...args);
+      } catch (e) {
+        showToast(e.message, 'error');
+        return null;
+      }
+    };
+  }
+
+  createApp({
+    setup() {
+      const cfg = window.__adminSuperDemosConfig || {};
+      const baseUrl = String(cfg.baseUrl || '');
+      const API_BASE = window.location.origin + baseUrl;
+
+      const origin = computed(() => window.location.origin);
+      const qaPageUrl = computed(() => `${window.location.origin}${baseUrl}/superdemos-qa.html`);
+
+      const toast = ref({ show: false, message: '', type: 'success' });
+      let toastTimer = null;
+      const showToast = (message, type) => {
+        toast.value = { show: true, message: String(message || ''), type: type || 'success' };
+        if (toastTimer) clearTimeout(toastTimer);
+        toastTimer = setTimeout(() => {
+          toast.value.show = false;
+        }, 2500);
+      };
+
+      const api = async (path, options) => {
+        const res = await fetch(baseUrl + path, {
+          method: (options && options.method) || 'GET',
+          headers: { 'Content-Type': 'application/json' },
+          body: options && options.body ? JSON.stringify(options.body) : undefined,
+        });
+        const text = await res.text();
+        let data = null;
+        try {
+          data = text ? JSON.parse(text) : null;
+        } catch {
+          data = null;
+        }
+        if (!res.ok) throw new Error((data && data.error) || ('Request failed: ' + res.status));
+        return data;
+      };
+
+      const projects = ref([]);
+      const selectedProject = ref(null);
+      const demos = ref([]);
+      const selectedDemo = ref(null);
+      const steps = ref([]);
+
+      const lastGeneratedKey = ref('');
+
+      const newProject = ref({ name: '', projectId: '', isPublic: true });
+      const newDemo = ref({ name: '', startUrlPattern: '' });
+      const projectStylePreset = ref('default');
+      const projectStyleOverrides = ref('');
+
+      const lastSelection = ref(null);
+
+      const authoring = ref({
+        targetUrl: '',
+        sessionId: '',
+        token: '',
+        connectUrl: '',
+        wsStatus: 'disconnected',
+      });
+
+      let ws = null;
+
+      function closeWs() {
+        try {
+          if (ws) ws.close();
+        } catch {}
+        ws = null;
+        authoring.value.wsStatus = 'disconnected';
+      }
+
+      function connectWs(sessionId, token) {
+        closeWs();
+
+        const proto = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+        const wsUrl = `${proto}//${window.location.host}${baseUrl}/api/superdemos/ws?sessionId=${encodeURIComponent(
+          sessionId,
+        )}&role=admin&token=${encodeURIComponent(token)}`;
+
+        ws = new WebSocket(wsUrl);
+        authoring.value.wsStatus = 'connecting';
+
+        ws.addEventListener('open', () => {
+          authoring.value.wsStatus = 'connected';
+        });
+
+        ws.addEventListener('close', () => {
+          authoring.value.wsStatus = 'disconnected';
+        });
+
+        ws.addEventListener('error', () => {
+          authoring.value.wsStatus = 'error';
+        });
+
+        ws.addEventListener('message', (evt) => {
+          let msg;
+          try {
+            msg = JSON.parse(String(evt.data || ''));
+          } catch {
+            return;
+          }
+
+          if (msg.type === 'select' && msg.element) {
+            lastSelection.value = msg.element;
+          }
+
+          if (msg.type === 'hover' && msg.element && !lastSelection.value) {
+            // helpful for first feedback
+            lastSelection.value = msg.element;
+          }
+        });
+      }
+
+      const refreshProjects = async () => {
+        const data = await api('/api/admin/superdemos/projects');
+        const items = Array.isArray(data && data.items) ? data.items : [];
+        projects.value = items
+          .filter(Boolean)
+          .map((p) => ({
+            ...p,
+            projectId: String((p && p.projectId) || ''),
+            name: String((p && p.name) || ''),
+            isPublic: Boolean(p && p.isPublic),
+          }))
+          .filter((p) => p.projectId);
+      };
+
+      const refreshDemos = async (projectId) => {
+        const data = await api('/api/admin/superdemos/projects/' + encodeURIComponent(projectId) + '/demos');
+        const items = Array.isArray(data && data.items) ? data.items : [];
+        demos.value = items
+          .filter(Boolean)
+          .map((d) => ({
+            ...d,
+            demoId: String((d && d.demoId) || ''),
+            name: String((d && d.name) || ''),
+            status: String((d && d.status) || 'draft'),
+            publishedVersion: Number((d && d.publishedVersion) || 0),
+          }))
+          .filter((d) => d.demoId);
+      };
+
+      const refreshSteps = async (demoId) => {
+        const data = await api('/api/admin/superdemos/demos/' + encodeURIComponent(demoId) + '/steps');
+        const items = (data && data.items) || [];
+        steps.value = items.map((s) => ({
+          selector: s.selector,
+          selectorHints: s.selectorHints || null,
+          message: s.message,
+          placement: s.placement || 'auto',
+          waitFor: s.waitFor || null,
+          advance: s.advance || { type: 'manualNext' },
+        }));
+      };
+
+      const refreshAll = withToast(async () => {
+        await refreshProjects();
+        if (selectedProject.value) await refreshDemos(selectedProject.value.projectId);
+        if (selectedDemo.value) await refreshSteps(selectedDemo.value.demoId);
+        showToast('Refreshed', 'success');
+      }, showToast);
+
+      const saveProjectStyleSettings = withToast(async () => {
+        if (!selectedProject.value) return;
+        const data = await api('/api/admin/superdemos/projects/' + encodeURIComponent(selectedProject.value.projectId), {
+          method: 'PUT',
+          body: {
+            stylePreset: projectStylePreset.value || 'default',
+            styleOverrides: projectStyleOverrides.value || '',
+          },
+        });
+        selectedProject.value = { ...data.item };
+        showToast('Project style settings saved', 'success');
+      }, showToast);
+
+      const copyText = async (text, label) => {
+        const v = String(text || '');
+        if (!v) {
+          showToast('Nothing to copy', 'error');
+          return;
+        }
+        try {
+          await navigator.clipboard.writeText(v);
+          showToast(`${label || 'Value'} copied`, 'success');
+        } catch {
+          showToast('Clipboard copy failed', 'error');
+        }
+      };
+
+      const createProject = withToast(async () => {
+        lastGeneratedKey.value = '';
+        const data = await api('/api/admin/superdemos/projects', {
+          method: 'POST',
+          body: {
+            name: newProject.value.name,
+            projectId: newProject.value.projectId || undefined,
+            isPublic: Boolean(newProject.value.isPublic),
+          },
+        });
+        if (data && data.apiKey) lastGeneratedKey.value = data.apiKey;
+        newProject.value = { name: '', projectId: '', isPublic: true };
+        await refreshProjects();
+        showToast('Project created', 'success');
+      }, showToast);
+
+      const selectProject = withToast(async (p) => {
+        selectedProject.value = { ...p };
+        projectStylePreset.value = String(p.stylePreset || 'default');
+        projectStyleOverrides.value = String(p.styleOverrides || '');
+        selectedDemo.value = null;
+        demos.value = [];
+        steps.value = [];
+        closeWs();
+        authoring.value = { targetUrl: '', sessionId: '', token: '', connectUrl: '', wsStatus: 'disconnected' };
+        lastSelection.value = null;
+        await refreshDemos(p.projectId);
+      }, showToast);
+
+      const createDemo = withToast(async () => {
+        if (!selectedProject.value) return;
+        const data = await api(
+          '/api/admin/superdemos/projects/' + encodeURIComponent(selectedProject.value.projectId) + '/demos',
+          {
+            method: 'POST',
+            body: {
+              name: newDemo.value.name,
+              startUrlPattern: newDemo.value.startUrlPattern || null,
+            },
+          },
+        );
+        newDemo.value = { name: '', startUrlPattern: '' };
+        await refreshDemos(selectedProject.value.projectId);
+        showToast('Demo created', 'success');
+        return data;
+      }, showToast);
+
+      const selectDemo = withToast(async (d) => {
+        selectedDemo.value = { ...d };
+        steps.value = [];
+        closeWs();
+        authoring.value = { targetUrl: '', sessionId: '', token: '', connectUrl: '', wsStatus: 'disconnected' };
+        lastSelection.value = null;
+        await refreshSteps(d.demoId);
+      }, showToast);
+
+      const publishDemo = withToast(async () => {
+        if (!selectedDemo.value) return;
+        const data = await api('/api/admin/superdemos/demos/' + encodeURIComponent(selectedDemo.value.demoId) + '/publish', {
+          method: 'POST',
+        });
+        await refreshDemos(selectedProject.value.projectId);
+        selectedDemo.value = data.item;
+        showToast('Published', 'success');
+      }, showToast);
+
+      const saveSteps = withToast(async () => {
+        if (!selectedDemo.value) return;
+        await api('/api/admin/superdemos/demos/' + encodeURIComponent(selectedDemo.value.demoId) + '/steps', {
+          method: 'PUT',
+          body: {
+            steps: steps.value.map((s) => ({
+              selector: s.selector,
+              selectorHints: s.selectorHints || null,
+              message: s.message,
+              placement: s.placement || 'auto',
+              waitFor: s.waitFor || null,
+              advance: s.advance || { type: 'manualNext' },
+            })),
+          },
+        });
+        showToast('Steps saved', 'success');
+      }, showToast);
+
+      const removeStep = (idx) => {
+        steps.value = steps.value.filter((_, i) => i !== idx);
+      };
+
+      const moveStep = (idx, delta) => {
+        const next = idx + delta;
+        if (next < 0 || next >= steps.value.length) return;
+        const copy = [...steps.value];
+        const [item] = copy.splice(idx, 1);
+        copy.splice(next, 0, item);
+        steps.value = copy;
+      };
+
+      const addStepFromSelection = () => {
+        if (!lastSelection.value) {
+          showToast('No selection from SDK yet', 'error');
+          return;
+        }
+        steps.value = [
+          ...steps.value,
+          {
+            selector: String(lastSelection.value.selector || ''),
+            selectorHints: lastSelection.value.hints || null,
+            message: '...',
+            placement: 'auto',
+            waitFor: null,
+            advance: { type: 'manualNext' },
+          },
+        ];
+      };
+
+      const startAuthoring = withToast(async () => {
+        if (!selectedDemo.value) return;
+        const data = await api('/api/admin/superdemos/authoring-sessions', {
+          method: 'POST',
+          body: {
+            demoId: selectedDemo.value.demoId,
+            targetUrl: authoring.value.targetUrl,
+          },
+        });
+
+        authoring.value.sessionId = data.sessionId;
+        authoring.value.token = data.token;
+        authoring.value.connectUrl = data.connectUrl;
+
+        connectWs(data.sessionId, data.token);
+        showToast('Authoring session created', 'success');
+      }, showToast);
+
+      const setQaTargetUrl = () => {
+        authoring.value.targetUrl = qaPageUrl.value;
+        showToast('Target URL set to QA page', 'success');
+      };
+
+      const previewStep = (step) => {
+        if (!ws || ws.readyState !== ws.OPEN) {
+          showToast('WS not connected', 'error');
+          return;
+        }
+        const s = step || {};
+        ws.send(
+          JSON.stringify({
+            type: 'preview_bubble',
+            selector: s.selector,
+            message: s.message,
+            placement: s.placement || 'auto',
+          }),
+        );
+      };
+
+      refreshAll().catch(() => {});
+
+      onBeforeUnmount(() => {
+        closeWs();
+      });
+
+      return {
+        origin,
+        qaPageUrl,
+        toast,
+        projects,
+        selectedProject,
+        demos,
+        selectedDemo,
+        steps,
+        newProject,
+        newDemo,
+        projectStylePreset,
+        projectStyleOverrides,
+        createProject,
+        refreshAll,
+        selectProject,
+        createDemo,
+        selectDemo,
+        publishDemo,
+        saveSteps,
+        removeStep,
+        moveStep,
+        authoring,
+        startAuthoring,
+        setQaTargetUrl,
+        saveProjectStyleSettings,
+        copyText,
+        lastGeneratedKey,
+        lastSelection,
+        addStepFromSelection,
+        previewStep,
+      };
+    },
+  }).mount('#app');
+})();