@intranefr/superbackend 1.6.7 → 1.7.8

package/src/cli/direct/help.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+
+/**
+ * Help text for the direct CLI
+ */
+
+const { colorize } = require('./cli-utils');
+
+function printHelp() {
+  console.log(`
+${colorize("bold", "SuperBackend Direct CLI")}
+
+${colorize("bold", "Usage:")}
+  node src/cli/direct.js <resource> <command> [options]
+
+${colorize("bold", "Resources & Commands:")}
+
+  ${colorize("cyan", "agents")}           - Manage AI agents
+    list, get, create, update, delete
+
+  ${colorize("cyan", "settings")}         - Manage global settings
+    list, get, create, update, delete
+
+  ${colorize("cyan", "users")}            - Manage users
+    list, get, create, update, delete, disable, enable
+
+  ${colorize("cyan", "json-configs")}     - Manage JSON configs
+    list, get, create, update, delete
+
+  ${colorize("cyan", "blog-posts")}       - Manage blog posts
+    list, get, create, update, delete, publish, unpublish
+
+  ${colorize("cyan", "orgs")}             - Manage organizations
+    list, get, create, update, delete
+
+  ${colorize("cyan", "crons")}            - Manage cron jobs
+    list, get, create, delete, enable, disable
+
+  ${colorize("cyan", "errors")}           - Manage error logs
+    list, get, delete, clear
+
+  ${colorize("cyan", "scripts")}          - Manage script definitions
+    list, get, create, delete
+
+  ${colorize("cyan", "workflows")}        - Manage workflows
+    list, get, create, delete, enable, disable
+
+  ${colorize("cyan", "health-checks")}    - Manage health checks
+    list, get, create, delete
+
+  ${colorize("cyan", "pages")}            - Manage pages
+    list, get, create, update, delete
+
+  ${colorize("cyan", "assets")}           - Manage assets
+    list, get, delete, clear
+
+  ${colorize("cyan", "forms")}            - Manage form submissions
+    list, get, delete, clear
+
+  ${colorize("cyan", "i18n")}             - Manage i18n entries
+    list, get, create, delete
+
+  ${colorize("cyan", "notifications")}    - Manage notifications
+    list, get, delete, clear
+
+  ${colorize("cyan", "rbac-roles")}       - Manage RBAC roles
+    list, get, create, delete
+
+  ${colorize("cyan", "rbac-groups")}      - Manage RBAC groups
+    list, get, create, delete
+
+  ${colorize("cyan", "invites")}          - Manage invites
+    list, get, create, delete, clear
+
+  ${colorize("cyan", "waiting-list")}     - Manage waiting list
+    list, delete, clear
+
+  ${colorize("cyan", "cache")}            - Manage cache entries
+    list, get, delete, clear
+
+  ${colorize("cyan", "audit-logs")}       - Manage audit logs
+    list, get, clear
+
+  ${colorize("cyan", "db-stats")}         - Database statistics
+  ${colorize("cyan", "db-indexes")}       - Database indexes
+  ${colorize("cyan", "db-cleanup")}       - Database cleanup
+
+  ${colorize("cyan", "experiments")}      - Manage experiments
+  ${colorize("cyan", "experiment-assignments")} - Experiment assignments
+
+  ${colorize("cyan", "telegram")}         - Manage Telegram bots
+  ${colorize("cyan", "rate-limits")}      - Manage rate limits
+  ${colorize("cyan", "console-logs")}     - Manage console logs
+  ${colorize("cyan", "activity-logs")}    - Manage activity logs
+  ${colorize("cyan", "email-logs")}       - Manage email logs
+  ${colorize("cyan", "webhooks")}         - Manage webhooks
+
+  ${colorize("cyan", "stripe-items")}     - Stripe catalog items
+  ${colorize("cyan", "stripe-events")}    - Stripe webhook events
+
+  ${colorize("cyan", "demo-projects")}    - Demo projects
+  ${colorize("cyan", "demo-steps")}       - Demo steps
+
+  ${colorize("cyan", "external-dbs")}     - External DB connections
+  ${colorize("cyan", "org-members")}      - Organization members
+
+  ${colorize("cyan", "page-collections")} - Page collections
+  ${colorize("cyan", "block-definitions")} - Block definitions
+  ${colorize("cyan", "context-blocks")}   - Context blocks
+  ${colorize("cyan", "ui-components")}    - UI components
+  ${colorize("cyan", "headless-models")}  - Headless models
+  ${colorize("cyan", "headless-tokens")}  - Headless API tokens
+
+  ${colorize("cyan", "blog-automation-locks")} - Blog automation locks
+  ${colorize("cyan", "blog-automation-runs")} - Blog automation runs
+
+  ${colorize("cyan", "cron-executions")}  - Cron execution history
+  ${colorize("cyan", "workflow-executions")} - Workflow executions
+  ${colorize("cyan", "script-runs")}      - Script execution history
+
+  ${colorize("cyan", "health-incidents")} - Health incidents
+  ${colorize("cyan", "health-attempts")}  - Health auto-heal attempts
+
+  ${colorize("cyan", "error-aggregates")} - Error aggregates
+  ${colorize("cyan", "metric-buckets")}   - Metric buckets
+
+  ${colorize("cyan", "virtual-ejs-files")} - Virtual EJS files
+  ${colorize("cyan", "virtual-ejs-groups")} - Virtual EJS groups
+  ${colorize("cyan", "markdowns")}        - Manage markdowns
+
+  ${colorize("cyan", "batch-delete")}     - Batch delete documents
+  ${colorize("cyan", "batch-update")}     - Batch update documents
+  ${colorize("cyan", "collection-count")} - Count documents
+  ${colorize("cyan", "collection-schema")} - Show collection schema
+  ${colorize("cyan", "export-collection")} - Export collection to JSON
+
+  ${colorize("cyan", "find-duplicates")}    - Find duplicate documents
+  ${colorize("cyan", "remove-duplicates")}  - Remove duplicate documents
+  ${colorize("cyan", "validate-refs")}      - Validate references
+  ${colorize("cyan", "repair-refs")}        - Repair broken references
+
+  ${colorize("cyan", "add-index")}          - Add index to collection
+  ${colorize("cyan", "drop-index")}         - Drop index from collection
+  ${colorize("cyan", "reindex")}            - Rebuild collection indexes
+  ${colorize("cyan", "compact")}            - Compact collection
+  ${colorize("cyan", "validate-collection")} - Validate collection integrity
+  ${colorize("cyan", "rename-collection")}  - Rename collection
+  ${colorize("cyan", "list-collections")}   - List all collections
+  ${colorize("cyan", "create-collection")}  - Create new collection
+  ${colorize("cyan", "drop-collection")}    - Drop collection
+
+  ${colorize("cyan", "db-info")}            - Database server info
+  ${colorize("cyan", "db-users")}           - Database users
+  ${colorize("cyan", "slow-queries")}       - Find slow queries
+  ${colorize("cyan", "enable-profiling")}   - Enable query profiling
+  ${colorize("cyan", "disable-profiling")}  - Disable query profiling
+
+  ${colorize("cyan", "user-permissions")}   - Show user permissions
+  ${colorize("cyan", "grant-role")}         - Grant role to user
+  ${colorize("cyan", "revoke-role")}        - Revoke role from user
+  ${colorize("cyan", "group-members")}      - Show group members
+  ${colorize("cyan", "add-to-group")}       - Add user to group
+  ${colorize("cyan", "remove-from-group")}  - Remove user from group
+
+  ${colorize("cyan", "agent-stats")}        - Agent statistics
+  ${colorize("cyan", "agent-sessions")}     - List agent sessions
+  ${colorize("cyan", "clear-agent-sessions")} - Clear old sessions
+
+  ${colorize("cyan", "migration-status")}   - Migration status check
+  ${colorize("cyan", "add-timestamps")}     - Add timestamps to docs
+  ${colorize("cyan", "data-digest")}        - Database digest report
+
+${colorize("bold", "Options:")}
+  --name NAME           Resource name
+  --model MODEL         AI model name (for agents)
+  --key KEY             Setting key / Collection name / User ID
+  --value VALUE         Value (context-dependent)
+  --description DESC    Description / Additional parameter
+  --email EMAIL         User email
+  --password PASSWORD   User password
+  --role ROLE           User role
+  --alias ALIAS         JSON config alias
+  --json JSON           JSON config data
+  --output FORMAT       Output: json, text, table (default: json)
+  --quiet               Only output data
+  --verbose             Show additional details
+  -h, --help            Show this help
+
+${colorize("bold", "Environment Variables:")}
+  MONGODB_URI         MongoDB connection string
+  MODE                Environment mode (loads .env.MODE)
+`);
+}
+
+module.exports = { printHelp };

package/src/cli/direct/migration.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+/**
+ * Migration utilities: migration-status, add-timestamps, data-digest
+ */
+
+const mongoose = require("mongoose");
+
+const migrationStatus = {
+  async execute(options, context) {
+    if (options.command && options.command !== "execute") return;
+    const db = context.db;
+    const collections = await db.listCollections().toArray();
+    const status = {};
+
+    for (const coll of collections) {
+      const count = await db.collection(coll.name).countDocuments();
+      const sample = await db.collection(coll.name).findOne();
+      status[coll.name] = {
+        count,
+        hasCreatedAt: sample?.createdAt ? true : false,
+        hasUpdatedAt: sample?.updatedAt ? true : false,
+      };
+    }
+
+    return { totalCollections: collections.length, status };
+  },
+};
+
+const addTimestamps = {
+  async execute(options, context) {
+    const db = context.db;
+    const collectionName = options.key;
+    const dryRun = options.value === "dry";
+
+    if (!collectionName) throw new Error("--key (collection name) is required");
+
+    const collection = db.collection(collectionName);
+    const docs = await collection
+      .find({
+        $or: [
+          { createdAt: { $exists: false } },
+          { updatedAt: { $exists: false } },
+        ],
+      })
+      .toArray();
+
+    if (dryRun) {
+      return {
+        collection: collectionName,
+        dryRun: true,
+        docsToUpdate: docs.length,
+        samples: docs.slice(0, 5).map((d) => ({ _id: d._id })),
+      };
+    }
+
+    let updatedCount = 0;
+    const now = new Date();
+
+    for (const doc of docs) {
+      await collection.updateOne(
+        { _id: doc._id },
+        {
+          $set: {
+            createdAt: doc.createdAt || now,
+            updatedAt: doc.updatedAt || now,
+          },
+        },
+      );
+      updatedCount++;
+    }
+
+    return { collection: collectionName, updatedCount, totalDocs: docs.length };
+  },
+};
+
+const dataDigest = {
+  async execute(options, context) {
+    if (options.command && options.command !== "execute") return;
+    const db = context.db;
+    const collections = await db.listCollections().toArray();
+
+    const digest = {
+      timestamp: new Date().toISOString(),
+      totalCollections: collections.length,
+      totalDocuments: 0,
+      totalSize: 0,
+      collections: [],
+    };
+
+    for (const coll of collections) {
+      const stats = await db.collection(coll.name).stats();
+      digest.totalDocuments += stats.count;
+      digest.totalSize += stats.size;
+      digest.collections.push({
+        name: coll.name,
+        count: stats.count,
+        size: stats.size,
+        storageSize: stats.storageSize,
+      });
+    }
+
+    return digest;
+  },
+};
+
+module.exports = { migrationStatus, addTimestamps, dataDigest };

package/src/cli/direct/rbac-advanced.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+/**
+ * RBAC Advanced: user-permissions, grant-role, revoke-role, group-members, add-to-group, remove-from-group
+ */
+
+const mongoose = require('mongoose');
+
+const userPermissions = {
+  async execute(options) {
+    const User = mongoose.model('User');
+    const RbacUserRole = mongoose.model('RbacUserRole');
+    const RbacRole = mongoose.model('RbacRole');
+
+    const userId = options.key;
+    if (!userId) throw new Error('--key (user ID) is required');
+
+    const user = await User.findById(userId).lean();
+    if (!user) return { error: 'User not found' };
+
+    const userRoles = await RbacUserRole.find({ userId }).populate('roleId').lean();
+    const roles = userRoles.map(ur => ur.roleId);
+
+    return { userId, email: user.email, role: user.role, rbacRoles: roles.map(r => ({ name: r.name, description: r.description })) };
+  },
+};
+
+const grantRole = {
+  async execute(options) {
+    const RbacUserRole = mongoose.model('RbacUserRole');
+    const RbacRole = mongoose.model('RbacRole');
+
+    const userId = options.key;
+    const roleName = options.value;
+
+    if (!userId) throw new Error('--key (user ID) is required');
+    if (!roleName) throw new Error('--value (role name) is required');
+
+    const role = await RbacRole.findOne({ name: roleName });
+    if (!role) throw new Error(`Role '${roleName}' not found`);
+
+    const existing = await RbacUserRole.findOne({ userId, roleId: role._id });
+    if (existing) return { message: 'User already has this role', userId, roleId: role._id };
+
+    await RbacUserRole.create({ userId, roleId: role._id });
+    return { success: true, userId, roleId: role._id, roleName };
+  },
+};
+
+const revokeRole = {
+  async execute(options) {
+    const RbacUserRole = mongoose.model('RbacUserRole');
+    const RbacRole = mongoose.model('RbacRole');
+
+    const userId = options.key;
+    const roleName = options.value;
+
+    if (!userId) throw new Error('--key (user ID) is required');
+    if (!roleName) throw new Error('--value (role name) is required');
+
+    const role = await RbacRole.findOne({ name: roleName });
+    if (!role) throw new Error(`Role '${roleName}' not found`);
+
+    const result = await RbacUserRole.deleteOne({ userId, roleId: role._id });
+    return { success: result.deletedCount > 0, userId, roleId: role._id, roleName };
+  },
+};
+
+const groupMembers = {
+  async execute(options) {
+    const RbacGroup = mongoose.model('RbacGroup');
+    const RbacGroupMember = mongoose.model('RbacGroupMember');
+
+    const groupId = options.key;
+
+    if (!groupId) {
+      const groups = await RbacGroup.find().lean();
+      const result = [];
+      for (const group of groups) {
+        const members = await RbacGroupMember.find({ groupId }).populate('userId').lean();
+        result.push({
+          groupId: group._id,
+          name: group.name,
+          memberCount: members.length,
+          members: members.map(m => ({ userId: m.userId?._id, email: m.userId?.email })),
+        });
+      }
+      return { groups: result };
+    }
+
+    const group = await RbacGroup.findById(groupId).lean();
+    if (!group) throw new Error('Group not found');
+
+    const members = await RbacGroupMember.find({ groupId }).populate('userId').lean();
+    return { groupId, name: group.name, members: members.map(m => ({ userId: m.userId?._id, email: m.userId?.email })) };
+  },
+};
+
+const addToGroup = {
+  async execute(options) {
+    const RbacGroupMember = mongoose.model('RbacGroupMember');
+
+    const groupId = options.key;
+    const userId = options.value;
+
+    if (!groupId) throw new Error('--key (group ID) is required');
+    if (!userId) throw new Error('--value (user ID) is required');
+
+    const existing = await RbacGroupMember.findOne({ groupId, userId });
+    if (existing) return { message: 'User already in group', groupId, userId };
+
+    await RbacGroupMember.create({ groupId, userId });
+    return { success: true, groupId, userId };
+  },
+};
+
+const removeFromGroup = {
+  async execute(options) {
+    const RbacGroupMember = mongoose.model('RbacGroupMember');
+
+    const groupId = options.key;
+    const userId = options.value;
+
+    if (!groupId) throw new Error('--key (group ID) is required');
+    if (!userId) throw new Error('--value (user ID) is required');
+
+    const result = await RbacGroupMember.deleteOne({ groupId, userId });
+    return { success: result.deletedCount > 0, groupId, userId };
+  },
+};
+
+module.exports = { userPermissions, grantRole, revokeRole, groupMembers, addToGroup, removeFromGroup };