adonisjs-server-stats 1.11.1 → 1.11.2

package/dist/src/provider/dashboard_init.js

@@ -18,6 +18,16 @@ export async function initDashboardStore(opts) {
         log.info('dashboard: SQLite store ready');
     }
     catch (err) {
+        const errMsg = err?.message ?? String(err);
+        const errStack = err?.stack ?? '(no stack)';
+        // Write to file since console.error may be swallowed by AdonisJS watcher
+        try {
+            const { writeFileSync } = await import('node:fs');
+            writeFileSync(app.makePath('server-stats-dashboard-error.log'), `${new Date().toISOString()}\nError: ${errMsg}\nStack: ${errStack}\n`);
+        }
+        catch { }
+        console.error('[server-stats] dashboard start error:', errMsg);
+        console.error('[server-stats] dashboard start stack:', errStack);
         logDashboardStartError(err);
         onResult({
             dashboardStore: null,
@@ -107,6 +117,7 @@ function pipeDashRequests(debugStore, dashboardStore) {
     });
 }
 function logDashboardStartError(err) {
+    const errMsg = err?.message ?? String(err);
     const c = classifyDashboardError(err);
     if (c === 'missing-dep') {
         log.block('Dashboard could not start — missing dependencies. Install with:', [
@@ -115,7 +126,11 @@ function logDashboardStartError(err) {
             '',
             dim('Dashboard has been disabled for this session.'),
             dim('Everything else (stats bar, debug panel) works without it.'),
+            '',
+            dim(`Error: ${errMsg}`),
         ]);
+        if (err?.stack)
+            console.error(err.stack);
         return;
     }
     if (c === 'timeout') {

package/dist/src/provider/provider_helpers_extra.d.ts

@@ -30,7 +30,7 @@ export declare function setupLogStreamBroadcast(transmit: {
     broadcast(ch: string, d: unknown): void;
 }, channelName: string, pinoHookActive: boolean, makePath: (...parts: string[]) => string): LogStreamService | null;
 /** Check if dashboard dependencies are available. Returns true if available, false if missing. */
-export declare function checkDashboardDepsHelper(config: ResolvedServerStatsConfig, _app: ApplicationService): Promise<boolean>;
+export declare function checkDashboardDepsHelper(config: ResolvedServerStatsConfig, app: ApplicationService): Promise<boolean>;
 /** Register the Edge.js plugin if Edge is available. Returns true if registered. */
 export declare function registerEdgePluginHelper(app: ApplicationService, config: ResolvedServerStatsConfig): Promise<boolean>;
 /** Set up the publisher-only email bridge for non-web environments. */

package/dist/src/provider/provider_helpers_extra.js

@@ -67,31 +67,58 @@ export function setupLogStreamBroadcast(transmit, channelName, pinoHookActive, m
 }
 // ── checkDashboardDepsHelper ────────────────────────────────────
 /** Check if dashboard dependencies are available. Returns true if available, false if missing. */
-export async function checkDashboardDepsHelper(config, _app) {
+export async function checkDashboardDepsHelper(config, app) {
     if (!config.devToolbar?.enabled || !config.devToolbar.dashboard)
         return true;
-    const { appImport } = await import('../utils/app_import.js');
+    const { createRequire } = await import('node:module');
+    const { join } = await import('node:path');
+    const { pathToFileURL } = await import('node:url');
     const missing = [];
-    try {
-        await appImport('knex');
-    }
-    catch {
+    const errors = [];
+    // Try multiple resolution strategies for monorepo compatibility
+    const tryImport = async (specifier) => {
+        // Strategy 1: resolve from app root (handles monorepo hoisting)
+        const appRoot = app.makePath('');
+        try {
+            const appRequire = createRequire(join(appRoot, 'package.json'));
+            const resolved = appRequire.resolve(specifier);
+            await import(pathToFileURL(resolved).href);
+            return true;
+        }
+        catch { }
+        // Strategy 2: resolve from cwd (original approach)
+        try {
+            const cwdRequire = createRequire(join(process.cwd(), 'package.json'));
+            const resolved = cwdRequire.resolve(specifier);
+            await import(pathToFileURL(resolved).href);
+            return true;
+        }
+        catch { }
+        // Strategy 3: bare import (works when installed normally)
+        try {
+            await import(specifier);
+            return true;
+        }
+        catch (err) {
+            errors.push(`${specifier}: ${err?.message ?? err}`);
+            return false;
+        }
+    };
+    if (!(await tryImport('knex')))
         missing.push('knex');
-    }
-    try {
-        await appImport('better-sqlite3');
-    }
-    catch {
+    if (!(await tryImport('better-sqlite3')))
         missing.push('better-sqlite3');
-    }
     if (missing.length === 0)
         return true;
     log.block(`Dashboard requires ${missing.join(' and ')}. Install with:`, [
         '',
         bold(`npm install ${missing.join(' ')}`),
         '',
-        dim('Dashboard routes have been skipped for now.'),
+        dim('Dashboard has been disabled for this session.'),
         dim('Everything else (stats bar, debug panel) works without it.'),
+        ...(errors.length > 0
+            ? ['', dim('Resolution errors:'), ...errors.map((e) => dim(`  ${e}`))]
+            : []),
     ]);
     return false;
 }

package/dist/src/provider/server_stats_provider.js

@@ -56,6 +56,9 @@ export default class ServerStatsProvider {
         }
         setVerbose(config.verbose);
         log.info('booting...');
+        // Register app root for module resolution (critical in monorepos)
+        const { setAppRoot } = await import('../utils/app_import.js');
+        setAppRoot(this.app.makePath(''));
         if (config.shouldShow)
             setShouldShow(config.shouldShow);
         await this.registerRoutes(config);
@@ -155,11 +158,14 @@ export default class ServerStatsProvider {
         const pfx = buildExcludedPrefixes(tc, config.endpoint);
         if (pfx.length > 0)
             setExcludedPrefixes(pfx);
-        if (!this.debugStore)
+        if (!this.debugStore) {
+            log.warn('debugStore is null after toolbar setup — apiController will not be created');
             return;
+        }
         const { DataAccess: DA } = await import('../data/data_access.js');
         const { ApiController: AC } = await import('../controller/api_controller.js');
         this.apiController = new AC(new DA(this.debugStore, () => this.dashboardStore, this.app.makePath('logs', 'adonisjs.log')));
+        log.info('apiController created');
     }
     async setupLogBroadcast() {
         const t = (await this.resolve('transmit'));
@@ -172,7 +178,8 @@ export default class ServerStatsProvider {
         try {
             return await this.app.container.make(binding);
         }
-        catch {
+        catch (err) {
+            log.info(`resolve('${binding}') failed: ${err?.message ?? err}`);
             return null;
         }
     }

package/dist/src/provider/toolbar_setup.js

@@ -117,8 +117,15 @@ export function applyToolbarResult(result, tc, provider) {
             provider.transmitChannels.push(ch);
     }
     provider.emailBridgeRedis = result.emailBridgeRedis;
-    if (!tc.dashboard || !provider.dashboardDepsAvailable)
+    if (!tc.dashboard) {
+        log.info('dashboard: skipped — dashboard is disabled in config');
         return;
+    }
+    if (!provider.dashboardDepsAvailable) {
+        log.info('dashboard: skipped — dependencies (knex/better-sqlite3) not available');
+        return;
+    }
+    log.info('dashboard: scheduling async initialization...');
     setImmediate(() => {
         initDashboardStore({
             tc,
@@ -133,9 +140,17 @@ export function applyToolbarResult(result, tc, provider) {
                 provider.dashboardController = r.dashboardController;
                 provider.dashboardLogStream = r.dashboardLogStream;
                 provider.dashboardBroadcastTimer = r.dashboardBroadcastTimer;
+                if (r.dashboardController) {
+                    log.info('dashboard: controller ready — API endpoints are now live');
+                }
+                else {
+                    log.warn('dashboard: init completed but controller is null — dashboard API will return 503');
+                }
             },
         }).catch((e) => {
-            log.warn(`dashboard setup failed: ${e?.message ?? e}`);
+            log.warn(`dashboard: setup failed: ${e?.message ?? e}`);
+            if (e?.stack)
+                log.warn(e.stack);
         });
     });
 }

package/dist/src/routes/dashboard_routes.js

@@ -1,16 +1,27 @@
+import { log } from '../utils/logger.js';
 function bindDash(getController, method) {
     return async (ctx) => {
         const controller = getController();
-        if (!controller)
-            return ctx.response.serviceUnavailable({ error: 'Dashboard is starting up, please retry' });
+        if (!controller) {
+            log.warn(`503 on ${ctx.request.url()} — dashboardController is null (method: ${method}). ` +
+                'Dashboard may still be initializing or failed to start. Check for earlier errors.');
+            return ctx.response.serviceUnavailable({
+                error: 'Dashboard is not available. Check server logs for initialization errors.',
+            });
+        }
         return controller[method].call(controller, ctx);
     };
 }
 function bindApi(getApi, fn) {
     return async (ctx) => {
         const api = getApi();
-        if (!api)
-            return ctx.response.serviceUnavailable({ error: 'Dashboard is starting up, please retry' });
+        if (!api) {
+            log.warn(`503 on ${ctx.request.url()} — apiController is null. ` +
+                'Dashboard may still be initializing or failed to start. Check for earlier errors.');
+            return ctx.response.serviceUnavailable({
+                error: 'Dashboard is not available. Check server logs for initialization errors.',
+            });
+        }
         return fn(api, ctx);
     };
 }

package/dist/src/utils/app_import.d.ts

@@ -1,20 +1,21 @@
 /**
- * Dynamically import a module, resolving from the app root (`process.cwd()`)
+ * Set the AdonisJS application root for module resolution.
+ * In monorepos, cwd may be the workspace root while the app lives
+ * in a sub-directory — this ensures we also look there.
+ */
+export declare function setAppRoot(appRoot: string): void;
+/**
+ * Dynamically import a module, resolving from the app root
  * instead of from this package's location.
  *
- * This is critical when `adonisjs-server-stats` is symlinked into the app
- * (e.g. via `file:../../adonisjs-server-stats` in package.json). Without
- * this, Node.js dereferences the symlink and resolves bare specifiers from
- * the package's *real* directory tree — which may contain devDependency
- * stubs with different module identity than the app's actual packages.
- *
- * Falls back to a normal `import()` when `createRequire` resolution fails
- * (e.g. when the package is installed normally, not symlinked).
+ * Tries multiple strategies for monorepo/symlink compatibility:
+ * 1. createRequire from each resolution root + ESM import
+ * 2. createRequire from each resolution root + CJS require (for native modules)
+ * 3. Bare import() fallback
  */
 export declare function appImport<T = unknown>(specifier: string): Promise<T>;
 /**
  * Same as {@link appImport} but also returns the resolved file path.
- * Useful for diagnostic logging.
  */
 export declare function appImportWithPath<T = unknown>(specifier: string): Promise<{
     module: T;

package/dist/src/utils/app_import.js

@@ -2,43 +2,93 @@ import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 /**
- * Dynamically import a module, resolving from the app root (`process.cwd()`)
+ * Resolution roots used by appImport, in priority order.
+ * By default uses process.cwd(). Call {@link setAppRoot} to prepend
+ * the AdonisJS app root (important in monorepos where cwd != app root).
+ */
+const resolutionRoots = [process.cwd()];
+/**
+ * Set the AdonisJS application root for module resolution.
+ * In monorepos, cwd may be the workspace root while the app lives
+ * in a sub-directory — this ensures we also look there.
+ */
+export function setAppRoot(appRoot) {
+    if (!resolutionRoots.includes(appRoot)) {
+        resolutionRoots.unshift(appRoot);
+    }
+}
+/**
+ * Dynamically import a module, resolving from the app root
  * instead of from this package's location.
  *
- * This is critical when `adonisjs-server-stats` is symlinked into the app
- * (e.g. via `file:../../adonisjs-server-stats` in package.json). Without
- * this, Node.js dereferences the symlink and resolves bare specifiers from
- * the package's *real* directory tree — which may contain devDependency
- * stubs with different module identity than the app's actual packages.
- *
- * Falls back to a normal `import()` when `createRequire` resolution fails
- * (e.g. when the package is installed normally, not symlinked).
+ * Tries multiple strategies for monorepo/symlink compatibility:
+ * 1. createRequire from each resolution root + ESM import
+ * 2. createRequire from each resolution root + CJS require (for native modules)
+ * 3. Bare import() fallback
  */
 export async function appImport(specifier) {
-    try {
-        const appRequire = createRequire(join(process.cwd(), 'package.json'));
-        const resolved = appRequire.resolve(specifier);
-        return await import(pathToFileURL(resolved).href);
+    const errors = [];
+    for (const root of resolutionRoots) {
+        try {
+            const appRequire = createRequire(join(root, 'package.json'));
+            const resolved = appRequire.resolve(specifier);
+            // Strategy A: ESM import via file URL
+            try {
+                return await import(pathToFileURL(resolved).href);
+            }
+            catch { }
+            // Strategy B: CJS require (works for native addons like better-sqlite3)
+            try {
+                return appRequire(specifier);
+            }
+            catch { }
+        }
+        catch (err) {
+            errors.push(err);
+        }
     }
-    catch {
-        // Fallback: normal import (works when not symlinked)
+    // Strategy C: bare import (works when installed normally, not symlinked)
+    try {
         return await import(specifier);
     }
+    catch (err) {
+        errors.push(err);
+    }
+    throw errors[0] ?? new Error(`Could not import '${specifier}'`);
 }
 /**
  * Same as {@link appImport} but also returns the resolved file path.
- * Useful for diagnostic logging.
  */
 export async function appImportWithPath(specifier) {
-    try {
-        const appRequire = createRequire(join(process.cwd(), 'package.json'));
-        const resolved = appRequire.resolve(specifier);
-        const module = await import(pathToFileURL(resolved).href);
-        return { module: module, resolvedPath: resolved };
+    const errors = [];
+    for (const root of resolutionRoots) {
+        try {
+            const appRequire = createRequire(join(root, 'package.json'));
+            const resolved = appRequire.resolve(specifier);
+            // Strategy A: ESM import via file URL
+            try {
+                const module = await import(pathToFileURL(resolved).href);
+                return { module: module, resolvedPath: resolved };
+            }
+            catch { }
+            // Strategy B: CJS require (works for native addons like better-sqlite3)
+            try {
+                const module = appRequire(specifier);
+                return { module, resolvedPath: resolved };
+            }
+            catch { }
+        }
+        catch (err) {
+            errors.push(err);
+        }
     }
-    catch {
-        // Fallback: normal import (works when not symlinked)
+    // Strategy C: bare import
+    try {
         const module = await import(specifier);
         return { module: module, resolvedPath: `(bare import: ${specifier})` };
     }
+    catch (err) {
+        errors.push(err);
+    }
+    throw errors[0] ?? new Error(`Could not import '${specifier}'`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adonisjs-server-stats",
-  "version": "1.11.1",
+  "version": "1.11.2",
   "description": "Real-time server monitoring for AdonisJS v6 applications",
   "keywords": [
     "adonisjs",