feat: tasks package

Author: twlite

packages/tasks/examples/commands/mute.ts

@@ -0,0 +1,85 @@
+import { CommandData, SlashCommand } from 'commandkit';
+import { ApplicationCommandOptionType, PermissionFlagsBits } from 'discord.js';
+import { UnmuteTaskData } from '../unmute';
+
+export const command: CommandData = {
+  name: 'mute',
+  description: 'Mute a user for a specified duration',
+  options: [
+    {
+      name: 'user',
+      description: 'The user to mute',
+      type: ApplicationCommandOptionType.User,
+      required: true,
+    },
+    {
+      name: 'duration',
+      description: 'Duration of the mute (e.g., 30m, 1h, 2d)',
+      type: ApplicationCommandOptionType.String,
+      required: true,
+    },
+    {
+      name: 'reason',
+      description: 'Reason for the mute',
+      type: ApplicationCommandOptionType.String,
+    },
+  ],
+  defaultMemberPermissions: [PermissionFlagsBits.ModerateMembers],
+};
+
+export const chatInput: SlashCommand = async (ctx) => {
+  const userToMute = ctx.options.getUser('user', true);
+  const duration = ctx.options.getString('duration', true);
+  const reason = ctx.options.getString('reason');
+
+  try {
+    // Get the member to mute
+    const member = await ctx.guild?.members.fetch(userToMute.id);
+
+    if (!member) {
+      return ctx.reply({
+        content: '❌ Could not find that user in this server.',
+        ephemeral: true,
+      });
+    }
+
+    // In a real implementation, you would add a muted role here
+    // await member.roles.add('muted-role-id');
+
+    // Create a task to unmute the user after the specified duration
+    const task = await ctx.tasks.create({
+      name: 'unmute', // must match the name of the task file
+      data: {
+        guildId: ctx.guild?.id as string,
+        userId: userToMute.id,
+        reason,
+      } as UnmuteTaskData,
+      duration: duration,
+    });
+
+    await ctx.reply({
+      content: `✅ ${userToMute} has been muted for ${duration}. They will be automatically unmuted. (Task ID: ${task.id})`,
+    });
+
+    // You could also save the task ID to a database to reference it later
+    // This allows you to cancel or update the task if needed
+  } catch (error) {
+    console.error('Error in mute command:', error);
+    await ctx.reply({
+      content: '❌ An error occurred while trying to mute that user.',
+      ephemeral: true,
+    });
+  }
+};
+
+// Example of how to cancel a mute task early (e.g., in an unmute command)
+export async function cancelMuteTask(ctx: any, userId: string) {
+  // You would need to retrieve the task ID from your database
+  // const taskId = await getTaskIdFromDatabase(guildId, userId);
+  const taskId = 'task-id-from-database';
+
+  if (taskId) {
+    await ctx.tasks.cancel(taskId);
+    console.log(`Cancelled unmute task for user ${userId}`);
+  }
+}

packages/tasks/examples/config.ts

@@ -0,0 +1,47 @@
+import { CommandKit } from 'commandkit';
+import { Client, GatewayIntentBits } from 'discord.js';
+import { tasks, configureTaskManager, bullmq } from '../src';
+
+// Create a Discord.js client
+const client = new Client({
+  intents: [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMembers,
+    // Add other intents as needed
+  ],
+});
+
+// Set up CommandKit with the tasks plugin
+const commandkit = new CommandKit({
+  client,
+  devGuildIds: ['YOUR_DEV_GUILD_ID'],
+  commandsPath: `${__dirname}/commands`,
+  plugins: [tasks()],
+});
+
+// Configure the task manager to use the BullMQ driver
+configureTaskManager(async (manager) => {
+  // Create a BullMQ driver with Redis configuration
+  const driver = bullmq({
+    redis: {
+      host: 'localhost', // Redis host
+      port: 6379, // Redis port
+      // password: 'your-redis-password', // Uncomment if needed
+      // url: 'redis://localhost:6379', // Alternative to host/port
+    },
+    queue: 'my-discord-bot-tasks', // Custom queue name
+  });
+
+  // Set the driver for the task manager
+  manager.useDriver(driver);
+});
+
+// Login with your bot token
+client.login('YOUR_BOT_TOKEN');
+
+// Handle process termination
+process.on('SIGINT', async () => {
+  console.log('Shutting down...');
+  await commandkit.destroy();
+  process.exit(0);
+});

packages/tasks/examples/refresh-exchange-rate.ts

@@ -0,0 +1,23 @@
+import type { TaskContext, TaskConfig } from '../src';
+
+export const config: TaskConfig = {
+  name: 'refresh-exchange-rate', // uses file name by default
+  // Run every 24 hours using cron syntax
+  pattern: '0 0 * * *',
+  // Alternative way to specify using friendly syntax
+  // every: '1 day',
+};
+
+export default async function refreshExchangeRate(ctx: TaskContext) {
+  // ctx contains client and commandkit instances
+  const { client, commandkit } = ctx;
+
+  // This is where you would fetch exchange rate data from an API
+  console.log(`[${new Date().toISOString()}] Refreshing exchange rates...`);
+
+  // Example: Update exchange rates in your database or cache
+  // const rates = await fetchExchangeRates();
+  // await updateDatabase(rates);
+
+  console.log('Exchange rates updated successfully!');
+}

packages/tasks/examples/unmute.ts

@@ -0,0 +1,41 @@
+import type { TaskContext } from '../src';
+
+// Define the data structure for the unmute task
+export interface UnmuteTaskData {
+  guildId: string;
+  userId: string;
+  reason?: string;
+}
+
+/**
+ * Unmute task that removes the muted role from a user after a specified duration
+ */
+export default async function unmute(ctx: TaskContext<UnmuteTaskData>) {
+  const { client, data, taskId } = ctx;
+  const { guildId, userId, reason } = data;
+
+  console.log(
+    `[${new Date().toISOString()}] Running unmute task ${taskId} for user ${userId} in guild ${guildId}`,
+  );
+
+  try {
+    // Get the guild
+    const guild = await client.guilds.fetch(guildId);
+
+    // Get the member
+    const member = await guild.members.fetch(userId);
+
+    // This would be the actual implementation to remove the muted role
+    // In a real bot, you would have a configuration for the muted role ID
+    // await member.roles.remove('muted-role-id');
+
+    console.log(
+      `Unmuted ${member.user.tag} ${reason ? `(Reason: ${reason})` : ''}`,
+    );
+  } catch (error) {
+    console.error(
+      `Failed to unmute user ${userId} in guild ${guildId}:`,
+      error,
+    );
+  }
+}

packages/tasks/package.json

@@ -26,10 +26,19 @@
     "url": "https://github.com/underctrl-io/commandkit/issues"
   },
   "homepage": "https://github.com/underctrl-io/commandkit#readme",
-  "devDependencies": {
+  "dependencies": {
     "bullmq": "^5.48.1",
+    "cron-parser": "^4.9.0",
+    "ms": "^2.1.3"
+  },
+  "devDependencies": {
+    "@types/ms": "^0.7.34",
     "commandkit": "workspace:*",
     "tsconfig": "workspace:*",
     "typescript": "^5.7.3"
+  },
+  "peerDependencies": {
+    "commandkit": "^1.0.0",
+    "discord.js": "^14.0.0"
   }
 }

packages/tasks/src/TaskContextManager.ts

@@ -1,3 +1,4 @@
+import { CommandKitTask, CreateTaskOptions, UpdateTaskOptions } from './driver';
 import { TaskManager } from './TaskManager';
 
 export type JSONEncodable =
@@ -18,17 +19,81 @@ export interface TaskDefinition {
 export class TaskContextManager {
   public constructor(private manager: TaskManager) {}
 
-  public async create(task: TaskDefinition) {}
+  /**
+   * Create a new dynamic task
+   * @param task Task definition
+   * @returns The created task
+   */
+  public async create(task: TaskDefinition): Promise<CommandKitTask> {
+    const driver = this.manager.getDriver();
+    if (!driver) {
+      throw new Error('Task driver not configured');
+    }
 
-  public async cancel(task: string) {}
+    const executor = this.manager.getExecutor(task.name);
+    if (!executor) {
+      throw new Error(`Task '${task.name}' not found`);
+    }
 
-  public async complete(task: string) {}
+    const options: CreateTaskOptions = {
+      name: task.name,
+      id: task.id || `${task.name}:${Date.now()}`,
+      data: task.data,
+      duration: task.duration,
+    };
 
-  public async fail(task: string) {}
+    return driver.createTask(options, executor);
+  }
+
+  /**
+   * Cancel a task by its ID
+   * @param taskId The ID of the task to cancel
+   * @returns Whether the task was successfully canceled
+   */
+  public async cancel(taskId: string): Promise<boolean> {
+    const driver = this.manager.getDriver();
+    if (!driver) {
+      throw new Error('Task driver not configured');
+    }
+
+    return driver.cancelTask(taskId);
+  }
+
+  /**
+   * Immediately invoke a task
+   * @param taskId The ID of the task to invoke
+   * @param data Optional data to pass to the task
+   */
+  public async invoke(taskId: string, data?: JSONEncodable): Promise<void> {
+    const driver = this.manager.getDriver();
+    if (!driver) {
+      throw new Error('Task driver not configured');
+    }
 
-  public async invoke(task: string, data: JSONEncodable) {}
+    await driver.invokeTask(taskId, data);
+  }
 
-  public async update(task: string, data: JSONEncodable) {}
+  /**
+   * Update an existing task
+   * @param taskId The ID of the task to update
+   * @param options Update options including data and/or duration
+   * @returns The updated task
+   */
+  public async update(
+    taskId: string,
+    options: UpdateTaskOptions,
+  ): Promise<CommandKitTask> {
+    const driver = this.manager.getDriver();
+    if (!driver) {
+      throw new Error('Task driver not configured');
+    }
+
+    return driver.updateTask(taskId, options);
+  }
+
+  public async complete(task: string) {}
+
+  public async fail(task: string) {}
 
   public async get(task: string) {}