@angelitosystems/nest-devtools 1.0.6 → 1.0.7

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import { DevToolsUserConfig } from '@angelitosystems/devtools-core';
-export { DevToolsUserConfig, RequestContext, requestContext } from '@angelitosystems/devtools-core';
+import { DevToolsConfig, DevToolsUserConfig, ProfileKind, ProfileResult } from '@angelitosystems/devtools-core';
+export { DevToolsUserConfig, ProfileKind, ProfileResult, RequestContext, requestContext } from '@angelitosystems/devtools-core';
 import { INestApplication } from '@nestjs/common';
+import { ProjectInfo, Redactor, DevToolsEventName, DevToolsEventMap } from '@angelitosystems/devtools-protocol';
 
 /** Public helper: report an error manually from anywhere in the app. */
 declare function captureError(error: unknown, options?: {
@@ -9,6 +10,30 @@ declare function captureError(error: unknown, options?: {
     service?: string;
 }): void;
 
+interface PluginContext {
+    readonly config: DevToolsConfig;
+    readonly project: ProjectInfo;
+    readonly redactor: Redactor;
+    emit<K extends DevToolsEventName>(event: K, payload: DevToolsEventMap[K]): void;
+    custom(name: string, data?: unknown): void;
+}
+interface DevToolsPlugin {
+    readonly name: string;
+    onInit?(context: PluginContext): void | Promise<void>;
+    onAttach?(app: INestApplication, context: PluginContext): void | (() => void) | Promise<void | (() => void)>;
+    onDispose?(): void | Promise<void>;
+}
+/** Runs third-party instrumentation without allowing it to affect the app. */
+declare class PluginManager {
+    private readonly plugins;
+    private readonly cleanups;
+    private readonly initialized;
+    constructor(plugins: DevToolsPlugin[]);
+    attach(app: INestApplication, config: DevToolsConfig, project: ProjectInfo): () => void;
+    private run;
+    private reportFailure;
+}
+
 /** Result of calling NestDevTools.init(). */
 interface InitResult {
     /** True when instrumentation is live. */
@@ -19,6 +44,9 @@ interface InitResult {
     projectName: string;
     server: string;
 }
+type NestDevToolsOptions = DevToolsUserConfig & {
+    plugins?: DevToolsPlugin[];
+};
 /**
  * Main entry point: `NestDevTools.init(app, config?)`.
  *
@@ -29,17 +57,26 @@ declare class NestDevTools {
     private static readonly cleanups;
     private static initialized;
     /** Initialize DevTools for a NestJS application. One active instance per process. */
-    static init(app: INestApplication, userConfig?: DevToolsUserConfig): InitResult;
+    static init(app: INestApplication, userConfig?: NestDevToolsOptions): InitResult;
     /** Teardown everything (mostly useful in tests). */
     static destroy(): void;
     /** Whether the SDK is currently active in this process. */
     static isActive(): boolean;
+    /** Start an explicit CPU or heap profile. */
+    static startProfile(kind: ProfileKind): Promise<{
+        profileId: string;
+        startedAt: number;
+    }>;
+    /** Stop the active profile and return its captured result. */
+    static stopProfile(): Promise<ProfileResult>;
 }
 /** Convenience functional alias: devtools.init(app). */
 declare const devtools: {
     init: typeof NestDevTools.init;
     destroy: typeof NestDevTools.destroy;
     isActive: typeof NestDevTools.isActive;
+    startProfile: typeof NestDevTools.startProfile;
+    stopProfile: typeof NestDevTools.stopProfile;
 };
 
-export { type InitResult, NestDevTools, captureError, devtools };
+export { type DevToolsPlugin, type InitResult, NestDevTools, type NestDevToolsOptions, type PluginContext, PluginManager, captureError, devtools };

package/dist/index.js

@@ -1353,6 +1353,84 @@ function printConnectionStatus(state, dashboard) {
   writeOriginalConsole("log", `   ${paint(DIM, "Reintentando en segundo plano \u2014 se conectar\xE1 solo cuando el dashboard est\xE9 arriba.")}`);
 }
 
+// src/plugins.ts
+import { Redactor as Redactor7 } from "@angelitosystems/devtools-protocol";
+var PluginManager = class {
+  constructor(plugins) {
+    this.plugins = plugins;
+  }
+  plugins;
+  cleanups = [];
+  initialized = [];
+  attach(app, config, project) {
+    const redactor = new Redactor7({ redact: config.redact, allow: config.allow, maxBytes: config.maxPayloadBytes });
+    const context = {
+      config,
+      project,
+      redactor,
+      emit: (event, payload) => {
+        try {
+          emit(event, redactor.redact(payload));
+        } catch {
+        }
+      },
+      custom: (name, data) => {
+        try {
+          emit("plugin.event", {
+            projectId: project.projectId,
+            plugin: "custom",
+            name,
+            data: redactor.redact(data),
+            timestamp: Date.now()
+          });
+        } catch {
+        }
+      }
+    };
+    for (const plugin of this.plugins) {
+      if (!plugin || !plugin.name) continue;
+      this.initialized.push(plugin);
+      this.run(plugin.name, () => plugin.onInit?.(context));
+      this.run(plugin.name, async () => {
+        const cleanup = await plugin.onAttach?.(app, context);
+        if (typeof cleanup === "function") this.cleanups.push(cleanup);
+      });
+    }
+    return () => {
+      for (const cleanup of this.cleanups.splice(0)) {
+        try {
+          cleanup();
+        } catch {
+        }
+      }
+      for (const plugin of this.initialized.splice(0)) this.run(plugin.name, () => plugin.onDispose?.());
+    };
+  }
+  run(name, operation) {
+    try {
+      const result = operation();
+      if (result && typeof result.then === "function") {
+        void result.catch((error) => this.reportFailure(name, error));
+      }
+    } catch (error) {
+      this.reportFailure(name, error);
+    }
+  }
+  reportFailure(name, error) {
+    try {
+      emit("log.created", {
+        projectId: "plugin-system",
+        level: "error",
+        message: `DevTools plugin ${name} failed: ${error instanceof Error ? error.message : String(error)}`,
+        processId: process.pid,
+        timestamp: Date.now(),
+        context: "plugin"
+      });
+    } catch {
+    }
+  }
+};
+
 // src/sdk.ts
 var NestDevTools = class {
   static cleanups = [];
@@ -1398,6 +1476,9 @@ var NestDevTools = class {
         }
       }
     });
+    if (userConfig?.plugins && userConfig.plugins.length > 0) {
+      registerCleanup(new PluginManager(userConfig.plugins).attach(app, config, projectInfo));
+    }
     const adapter = app.getHttpAdapter();
     const httpReady = Boolean(adapter && ["http", "express"].includes(adapter.getType()));
     const http = new HttpInstrumentation({ config, projectInfo });
@@ -1442,11 +1523,21 @@ var NestDevTools = class {
   static isActive() {
     return this.initialized;
   }
+  /** Start an explicit CPU or heap profile. */
+  static startProfile(kind) {
+    return coreDevtools2.startProfile(kind);
+  }
+  /** Stop the active profile and return its captured result. */
+  static stopProfile() {
+    return coreDevtools2.stopProfile();
+  }
 };
 var devtools = {
   init: NestDevTools.init.bind(NestDevTools),
   destroy: NestDevTools.destroy.bind(NestDevTools),
-  isActive: NestDevTools.isActive.bind(NestDevTools)
+  isActive: NestDevTools.isActive.bind(NestDevTools),
+  startProfile: NestDevTools.startProfile.bind(NestDevTools),
+  stopProfile: NestDevTools.stopProfile.bind(NestDevTools)
 };
 function safeHostname() {
   try {
@@ -1484,6 +1575,7 @@ function dashboardUrl(server) {
 import { requestContext as requestContext8 } from "@angelitosystems/devtools-core";
 export {
   NestDevTools,
+  PluginManager,
   captureError,
   devtools,
   requestContext8 as requestContext