zumito-framework 1.24.0 → 1.25.0

package/dist/ZumitoFramework.js

@@ -25,6 +25,7 @@ import { ErrorType } from './definitions/ErrorType.js';
 import { MongoService } from './services/MongoService.js';
 import { registerDefaultExecutionRules } from './modules/core/baseModule/defaultRules.js';
 import { DatabaseManager } from 'zumito-db';
+import { registerFrameworkInspector, startInspectorFileWriter } from './utils/Inspector.js';
 // import better-logging
 betterLogging(console);
 /**
@@ -148,6 +149,7 @@ export class ZumitoFramework {
         ServiceContainer.addService(CommandManager, [], true, this.commands);
         ServiceContainer.addService(EventManager, [], true, this.eventManager);
         ServiceContainer.addService(SlashCommandRefresher, [], true, new SlashCommandRefresher(this));
+        registerFrameworkInspector(this);
         if (settings.logLevel) {
             console.logLevel = settings.logLevel;
         }
@@ -155,6 +157,7 @@ export class ZumitoFramework {
             .then(() => {
             if (callback)
                 callback(this);
+            startInspectorFileWriter(this);
         })
             .catch((err) => {
             console.error(err, err.message, err.stack, err.name);
@@ -188,7 +191,7 @@ export class ZumitoFramework {
         }
     }
     async initializeDatabase() {
-        const mongoUri = this.settings?.mongoQueryString || process.env.MONGO_URI;
+        const mongoUri = this.settings?.mongoQueryString || process.env.DATABASE_URI;
         const dbSettings = this.settings.database;
         let config;
         if (dbSettings?.default) {
@@ -208,7 +211,7 @@ export class ZumitoFramework {
         else {
             console.error('[🗄️🔴] No database configured.');
             console.error('  Set database.default in zumito.config.ts (memory, tingo, mongo, sqlite)');
-            console.error('  or set MONGO_URI / mongoQueryString for MongoDB.');
+            console.error('  or set DATABASE_URI / mongoQueryString for MongoDB.');
             process.exit(1);
         }
         if (this.settings.models) {

package/dist/services/ServiceContainer.d.ts

@@ -5,6 +5,12 @@ declare class ServiceContainerManager {
     getServiceByName<T>(serviceName: string): T;
     addInstance(serviceClass: any, instance: any): void;
     hasService(serviceClass: any): boolean;
+    getAllServiceEntries(): Array<{
+        name: string;
+        dependencies: string[];
+        singleton: boolean;
+        hasInstance: boolean;
+    }>;
 }
 export declare const ServiceContainer: ServiceContainerManager;
 export {};

package/dist/services/ServiceContainer.js

@@ -62,6 +62,18 @@ class ServiceContainerManager {
         const serviceName = typeof serviceClass == 'string' ? serviceClass : serviceClass.name;
         return this.services.has(serviceName);
     }
+    getAllServiceEntries() {
+        const entries = [];
+        for (const [name, svc] of this.services) {
+            entries.push({
+                name,
+                dependencies: svc.dependencies,
+                singleton: svc.singleton,
+                hasInstance: svc.instance !== undefined,
+            });
+        }
+        return entries;
+    }
 }
 if (!global.ServiceContainer)
     global.ServiceContainer = new ServiceContainerManager();

package/dist/utils/Inspector.d.ts

@@ -0,0 +1,61 @@
+import { ZumitoFramework } from '../ZumitoFramework.js';
+export interface FrameworkSnapshot {
+    version: string;
+    uptime: number;
+    discord: {
+        status: 'connected' | 'disconnected';
+        user: {
+            id: string;
+            tag: string;
+        } | null;
+        guildCount: number;
+    };
+    database: {
+        connected: boolean;
+        driver: string;
+    };
+    commands: {
+        total: number;
+        items: Array<{
+            name: string;
+            type: string;
+            description: string;
+            aliases: string[];
+            categories: string[];
+            hidden: boolean;
+        }>;
+    };
+    modules: {
+        total: number;
+        items: Array<{
+            name: string;
+            displayName: string;
+            status: string;
+            dependencies: string[];
+            commandCount: number;
+            eventCount: number;
+        }>;
+    };
+    services: {
+        total: number;
+        items: Array<{
+            name: string;
+            singleton: boolean;
+            hasInstance: boolean;
+            dependencies: string[];
+        }>;
+    };
+    events: {
+        total: number;
+        items: Array<{
+            name: string;
+            source: string;
+        }>;
+    };
+}
+/**
+ * Write the inspector snapshot to .zumito/inspector-state.json in the current
+ * working directory. Returns a cleanup function that stops the write interval.
+ */
+export declare function startInspectorFileWriter(framework: ZumitoFramework): () => void;
+export declare function registerFrameworkInspector(framework: ZumitoFramework): void;

package/dist/utils/Inspector.js

@@ -0,0 +1,194 @@
+import { createRequire } from 'module';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ServiceContainer } from '../services/ServiceContainer.js';
+const require = createRequire(import.meta.url);
+/**
+ * Write the inspector snapshot to .zumito/inspector-state.json in the current
+ * working directory. Returns a cleanup function that stops the write interval.
+ */
+export function startInspectorFileWriter(framework) {
+    const startTime = Date.now();
+    let pkg = {};
+    try {
+        pkg = require('../../package.json');
+    }
+    catch { /* ignore */ }
+    let lastJson = '';
+    let timer;
+    const write = () => {
+        const state = {
+            version: pkg.version || 'unknown',
+            uptime: Date.now() - startTime,
+            discord: {
+                status: framework.client?.isReady() ? 'connected' : 'disconnected',
+                user: framework.client?.user
+                    ? { id: framework.client.user.id, tag: framework.client.user.tag }
+                    : null,
+                guildCount: framework.client?.guilds?.cache?.size ?? 0,
+            },
+            database: {
+                connected: !!framework.db,
+                driver: framework.db ? getDriverName(framework) : 'none',
+            },
+            commands: serializeCommands(framework),
+            modules: serializeModules(framework),
+            services: serializeServices(),
+            events: serializeEvents(framework),
+        };
+        const json = JSON.stringify(state);
+        if (json === lastJson) {
+            return;
+        }
+        lastJson = json;
+        try {
+            const dir = path.join(process.cwd(), '.zumito');
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(path.join(dir, 'inspector-state.json'), json, 'utf-8');
+        }
+        catch {
+            // can't write – silently ignore
+        }
+    };
+    // Write immediately, then every 3s
+    write();
+    timer = setInterval(write, 3000);
+    return () => {
+        if (timer) {
+            clearInterval(timer);
+            timer = undefined;
+        }
+    };
+}
+export function registerFrameworkInspector(framework) {
+    const startTime = Date.now();
+    let pkg = {};
+    try {
+        pkg = require('../../package.json');
+    }
+    catch {
+        // fallback if package.json can't be read
+    }
+    const inspector = {
+        getSnapshot() {
+            const state = {
+                version: pkg.version || 'unknown',
+                uptime: Date.now() - startTime,
+                discord: {
+                    status: framework.client?.isReady() ? 'connected' : 'disconnected',
+                    user: framework.client?.user
+                        ? { id: framework.client.user.id, tag: framework.client.user.tag }
+                        : null,
+                    guildCount: framework.client?.guilds?.cache?.size ?? 0,
+                },
+                database: {
+                    connected: !!framework.db,
+                    driver: framework.db ? getDriverName(framework) : 'none',
+                },
+                commands: serializeCommands(framework),
+                modules: serializeModules(framework),
+                services: serializeServices(),
+                events: serializeEvents(framework),
+            };
+            return JSON.stringify(state);
+        },
+        getCommands() {
+            return JSON.stringify(serializeCommands(framework));
+        },
+        getModules() {
+            return JSON.stringify(serializeModules(framework));
+        },
+        getServices() {
+            return JSON.stringify(serializeServices());
+        },
+        getEvents() {
+            return JSON.stringify(serializeEvents(framework));
+        },
+    };
+    try {
+        globalThis.__ZUMITO_INSPECT__ = inspector;
+    }
+    catch {
+        // globalThis not available (non-Node environment?)
+    }
+}
+function getDriverName(framework) {
+    try {
+        const driver = framework.db.getDriver?.();
+        if (driver) {
+            return driver.constructor?.name || 'custom';
+        }
+    }
+    catch {
+        // ignore
+    }
+    return 'unknown';
+}
+function serializeCommands(framework) {
+    const items = [];
+    const allCommands = framework.commands?.getAll();
+    if (allCommands) {
+        for (const [, cmd] of allCommands) {
+            items.push({
+                name: cmd.name,
+                type: cmd.type || 'any',
+                description: cmd.description || '',
+                aliases: cmd.aliases || [],
+                categories: cmd.categories || [],
+                hidden: cmd.hidden === true,
+            });
+        }
+    }
+    return { total: items.length, items };
+}
+function serializeModules(framework) {
+    const items = [];
+    const allModules = framework.modules?.getAll();
+    if (allModules) {
+        for (const [name, mod] of allModules) {
+            const modClass = Object.getPrototypeOf(mod)?.constructor;
+            items.push({
+                name,
+                displayName: modClass?.moduleName || name,
+                status: 'loaded',
+                dependencies: Array.from(modClass?.dependencies || []),
+                commandCount: mod.getCommands?.()?.size ?? 0,
+                eventCount: mod.events?.size ?? 0,
+            });
+        }
+    }
+    return { total: items.length, items };
+}
+function serializeServices() {
+    const items = [];
+    try {
+        const entries = ServiceContainer.getAllServiceEntries();
+        for (const entry of entries) {
+            items.push({
+                name: entry.name,
+                singleton: entry.singleton,
+                hasInstance: entry.hasInstance,
+                dependencies: entry.dependencies,
+            });
+        }
+    }
+    catch {
+        // service container not ready
+    }
+    return { total: items.length, items };
+}
+function serializeEvents(framework) {
+    const items = [];
+    const allEvents = framework.events;
+    if (allEvents) {
+        for (const [, evt] of allEvents) {
+            items.push({
+                name: evt.name || 'unknown',
+                source: evt.source || evt.emitter || 'framework',
+            });
+        }
+    }
+    return { total: items.length, items };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zumito-framework",
-  "version": "1.24.0",
+  "version": "1.25.0",
   "description": "Discord.js bot framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",