fix: minor improvements

Author: twlite

apps/test-bot/src/app/commands/(developer)/middleware.ts

@@ -6,7 +6,7 @@ export function beforeExecute(ctx: MiddlewareContext) {
 
   const user = ctx.isInteraction() ? ctx.interaction.user : ctx.message.author;
 
-  if (user.id === '12345678901234567890') {
+  if (user.id !== '12345678901234567890') {
     if (ctx.isSlashCommand()) {
       ctx.interaction.reply({
         content: 'You are not allowed to use this command.',

apps/test-bot/src/app/commands/(developer)/server.ts

@@ -1,4 +1,9 @@
-import type { CommandData, SlashCommand, MessageCommand } from 'commandkit';
+import {
+  type CommandData,
+  type SlashCommand,
+  type MessageCommand,
+  Logger,
+} from 'commandkit';
 
 export const command: CommandData = {
   name: 'server',
@@ -7,9 +12,11 @@ export const command: CommandData = {
 };
 
 export const chatInput: SlashCommand = async (ctx) => {
+  Logger.log('Running server command');
   await ctx.interaction.reply('Hello from server!');
 };
 
 export const message: MessageCommand = async (ctx) => {
+  Logger.log('Running server command');
   await ctx.message.reply('Hello from server!');
 };

packages/commandkit/src/CommandKit.ts

@@ -123,6 +123,7 @@ export class CommandKit extends EventEmitter {
 
     await this.#init();
 
+    this.commandHandler.registerCommandHandler();
     this.incrementClientListenersCount();
 
     if (token !== false && !this.options.client.isReady()) {
@@ -133,6 +134,8 @@ export class CommandKit extends EventEmitter {
       await this.options.client.login(
         token ?? process.env.TOKEN ?? process.env.DISCORD_TOKEN,
       );
+    } else if (this.options.client.isReady()) {
+      await this.commandHandler.registrar.register();
     }
 
     this.#started = true;

packages/commandkit/src/app/handlers/AppCommandHandler.ts

@@ -26,9 +26,18 @@ import { MessageCommandParser } from '../commands/MessageCommandParser';
 import { CommandKitErrorCodes, isErrorType } from '../../utils/error-codes';
 import { ParsedCommand, ParsedMiddleware, ParsedSubCommand } from '../router';
 import { CommandRegistrar } from '../register/CommandRegistrar';
-import { GenericFunction } from '../../context/async-context';
+import {
+  GenericFunction,
+  makeContextAwareFunction,
+  useEnvironment,
+} from '../../context/async-context';
 import { Logger } from '../../logger/Logger';
 import { AsyncFunction } from '../../cache';
+import {
+  afterCommand,
+  CommandKitEnvironment,
+  CommandKitEnvironmentType,
+} from '../../context/environment';
 
 export type RunCommand = <T extends AsyncFunction>(fn: T) => T;
 
@@ -238,7 +247,14 @@ export class AppCommandHandler {
 
     let runCommand: RunCommand | null = null;
 
+    const env = new CommandKitEnvironment(this.commandkit);
+    env.setType(CommandKitEnvironmentType.CommandHandler);
+    env.variables.set('commandHandlerType', 'app');
+    env.variables.set('currentCommandName', prepared.command.command.name);
+    env.variables.set('execHandlerKind', executionMode);
+
     const ctx = new MiddlewareContext(this.commandkit, {
+      environment: env,
       executionMode,
       interaction: !(source instanceof Message)
         ? (source as ChatInputCommandInteraction)
@@ -271,11 +287,35 @@ export class AppCommandHandler {
 
     if (fn) {
       try {
-        const _executeCommand = async () => fn(ctx.clone());
+        const _executeCommand = makeContextAwareFunction(
+          env,
+          async () => fn(ctx.clone()),
+          this.#finalizer.bind(this),
+        );
+
         const executeCommand =
           runCommand != null
             ? (runCommand as RunCommand)(_executeCommand)
             : _executeCommand;
+
+        afterCommand((env) => {
+          const error = env.getExecutionError();
+          const marker = env.getMarker();
+          const time = `${env.getExecutionTime().toFixed(2)}ms`;
+
+          if (error) {
+            Logger.error(
+              `[${marker} - ${time}] Error executing command: ${error.stack || error}`,
+            );
+
+            return;
+          }
+
+          Logger.info(`[${marker} - ${time}] Command executed successfully`);
+        });
+
+        env.markStart(prepared.command.command.name);
+
         const res = await this.commandkit.plugins.execute(
           async (ctx, plugin) => {
             return plugin.executeCommand(ctx, source, prepared, executeCommand);
@@ -290,12 +330,24 @@ export class AppCommandHandler {
       }
     }
 
-    // Run middleware after command execution
-    for (const middleware of prepared.middlewares) {
-      await middleware.data.afterExecute(ctx);
+    try {
+      // Run middleware after command execution
+      for (const middleware of prepared.middlewares) {
+        await middleware.data.afterExecute(ctx);
+      }
+    } finally {
+      env.markEnd();
     }
   }
 
+  async #finalizer() {
+    const env = useEnvironment();
+
+    await env.runDeferredFunctions();
+
+    env.clearAllDeferredFunctions();
+  }
+
   public async prepareCommandRun(
     source: Interaction | Message,
   ): Promise<PreparedAppCommandExecution | null> {
@@ -367,7 +419,7 @@ export class AppCommandHandler {
         if (isErrorType(e, CommandKitErrorCodes.InvalidCommandPrefix)) {
           return null;
         }
-        console.error(e);
+        Logger.error(e);
         return null;
       }
     } else {