create-chapterjs 0.2.3 → 0.4.0

package/README.md

@@ -0,0 +1,37 @@
+# create-chapterjs
+
+Creates a [ChapterJS](https://www.chapterjs.org) Discord bot: a project where every file of `src/` is a command, an event, a button, a task… and where the `chapterjs` CLI does everything else.
+
+```bash
+pnpm create chapterjs my-bot
+```
+
+```bash
+npm create chapterjs my-bot
+```
+
+```bash
+yarn create chapterjs my-bot
+```
+
+```bash
+bun create chapterjs my-bot
+```
+
+`pnpm create chapter` works too.
+
+## What it asks
+
+- **The folder**, when it is not given: `.` is the current folder, which must be new or empty.
+- **The package manager**, among those installed on your machine: the one you ran the command with is preselected.
+- **A template**: `default` is one file, the `ready` event, and the [tutorial](https://www.chapterjs.org/tutorial) starts from it. The others are complete bots to start from or to read: `tickets` (support tickets in private threads), `music` (a player with a queue and buttons), `community` (welcome cards, roles people pick, weekly stats) and `moderation` (timeouts, purge, slowmode, lock, and a log of every action).
+
+A question with only one possible answer is not asked: its answer is shown with `ℹ`. Node 24 or later is needed, and the command says so at once when it is older.
+
+Then it copies the template, installs its dependencies, and tells you what to do next: fill `.env` with your bot token and your test server, and run `chapterjs dev`. Every template but `default` comes with a scenario file that `chapterjs test` runs, to start your own from. The project depends on the exact version of `chapterjs` this command had: `pnpm create chapterjs@1.0.0` gives a project on `chapterjs@1.0.0`.
+
+📖 [Quickstart](https://www.chapterjs.org/quickstart) · [Project structure and templates](https://www.chapterjs.org/setup/project-structure) · [Source and issues](https://github.com/chapterjs/chapterjs)
+
+## License
+
+[MIT](./LICENSE)

package/dist/choose.js

@@ -0,0 +1,27 @@
+import * as p from '@clack/prompts';
+/**
+ * A select menu that never asks a question with only one answer: when a single
+ * choice can be picked, it is taken right away and the user is told why.
+ * Returns `undefined` when no choice can be picked, and the cancel symbol when
+ * the user presses Ctrl+C or Esc.
+ */
+export async function choose({ message, choices, initialValue, onlyChoice, }) {
+    const enabled = choices.filter(choice => !choice.disabled);
+    const [first] = enabled;
+    if (!first)
+        return undefined;
+    if (enabled.length === 1) {
+        p.log.info(onlyChoice(first.value));
+        return first.value;
+    }
+    // clack's option type can't be resolved for a generic `Value`, so the menu is
+    // typed with `string`: it only ever returns one of `choices`.
+    const picked = await p.select({
+        message,
+        initialValue: enabled.some(choice => choice.value === initialValue)
+            ? initialValue
+            : first.value,
+        options: choices,
+    });
+    return picked;
+}

package/dist/index.js

@@ -1,5 +1,99 @@
 #!/usr/bin/env node
-// Alias so `pnpm create chapterjs` works too: runs the create-chapter CLI.
-// @ts-expect-error create-chapter only ships a bin, without type declarations.
-await import('create-chapter/dist/index.js');
-export {};
+import * as p from '@clack/prompts';
+import { readFileSync } from 'node:fs';
+import { relative, resolve } from 'node:path';
+import { detectPackageManager, install, installedVersions, packageManagers, runScript, } from './package-manager.js';
+import { choose } from './choose.js';
+import { createProject, validateTargetDir } from './project.js';
+import { listTemplates } from './templates.js';
+import { nodeTooOld } from './node-version.js';
+/** Stops cleanly when the user presses Ctrl+C or Esc on a prompt. */
+function orExit(value) {
+    if (p.isCancel(value)) {
+        p.cancel('Cancelled, nothing was created.');
+        process.exit(0);
+    }
+    return value;
+}
+// create-chapterjs and chapterjs are always released with the same version.
+const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+p.intro(`Create a ChapterJS bot (v${version})`);
+const tooOld = nodeTooOld();
+if (tooOld) {
+    p.cancel(tooOld);
+    process.exit(1);
+}
+// Started now so it runs while the user answers the first question.
+const versionsCheck = installedVersions();
+// `pnpm create chapterjs my-bot` skips the first question when the folder is valid.
+const argDir = process.argv[2];
+const argError = argDir === undefined ? undefined : validateTargetDir(argDir);
+if (argError)
+    p.log.warn(argError);
+const dir = argDir !== undefined && argError === undefined
+    ? argDir.trim()
+    : orExit(await p.text({
+        message: 'Where should the project be created? (. for the current folder)',
+        placeholder: 'my-bot',
+        defaultValue: 'my-bot',
+        validate: value => validateTargetDir(value || 'my-bot'),
+    })).trim();
+const versions = await versionsCheck;
+const pm = orExit(await choose({
+    message: 'Which package manager do you want to use?',
+    initialValue: detectPackageManager(),
+    choices: packageManagers.map(value => {
+        const version = versions[value];
+        return version === undefined
+            ? { value, label: `${value} (not installed)`, disabled: true }
+            : { value, hint: `v${version}` };
+    }),
+    onlyChoice: value => `Using ${value}, the only package manager installed`,
+}));
+if (pm === undefined) {
+    p.cancel(`No package manager found. Install one of ${packageManagers.join(', ')}, then run this command again.`);
+    process.exit(1);
+}
+const templates = await listTemplates();
+const template = orExit(await choose({
+    message: 'Which template do you want to start from?',
+    choices: templates.map(({ name, description }) => ({
+        value: name,
+        hint: description,
+    })),
+    onlyChoice: value => `Using the ${value} template`,
+}));
+if (template === undefined) {
+    p.cancel('No template found. Reinstall create-chapterjs and try again.');
+    process.exit(1);
+}
+// The exact version, not a range: `create chapterjs@X` makes a project on
+// `chapterjs@X`, and the project only changes version when its developer
+// runs the command `chapterjs dev` gives them.
+await createProject({
+    dir,
+    template,
+    chapterjsVersion: version,
+    packageManager: pm,
+});
+p.log.success(`Project created in ${resolve(dir)}`);
+const spinner = p.spinner();
+spinner.start(`Installing dependencies with ${pm}`);
+const result = await install(pm, dir);
+if (result.ok) {
+    spinner.stop(`Dependencies installed with ${pm}`);
+}
+else {
+    spinner.error(`The dependencies could not be installed with ${pm}`);
+    if (result.output)
+        p.log.message(result.output);
+}
+const cd = relative(process.cwd(), resolve(dir));
+const steps = [
+    ...(cd ? [`cd ${cd.includes(' ') ? `"${cd}"` : cd}`] : []),
+    ...(result.ok ? [] : [`${pm} install`]),
+    'Copy .env.example to .env and fill in BOT_TOKEN and DEV_GUILD_ID',
+    runScript(pm, 'dev'),
+];
+p.note(steps.join('\n'), 'Next steps');
+p.outro('Happy building!');

package/dist/node-version.js

@@ -0,0 +1,13 @@
+/** The oldest Node.js a ChapterJS bot runs on, as `engines` says. */
+export const MINIMUM_NODE = 24;
+/**
+ * What to tell the person when this Node.js is older than ChapterJS needs,
+ * or `null` when it is recent enough: refused before creating anything,
+ * since the bot could not run.
+ */
+export function nodeTooOld(version = process.versions.node) {
+    const major = Number(version.split('.')[0]);
+    if (major >= MINIMUM_NODE)
+        return null;
+    return `ChapterJS needs Node.js ${MINIMUM_NODE} or newer, and this is Node.js ${version}. Install the LTS version from https://nodejs.org, then run the command again.`;
+}

package/dist/package-manager.js

@@ -0,0 +1,59 @@
+import { spawn } from 'node:child_process';
+import { tmpdir } from 'node:os';
+/** In menu order: pnpm, the one ChapterJS itself uses, comes first. */
+export const packageManagers = ['pnpm', 'npm', 'yarn', 'bun'];
+/**
+ * The package manager that launched `create chapterjs`, read from the user agent
+ * it sets (e.g. `pnpm/11.0.0 npm/? node/v24.0.0 darwin arm64`).
+ */
+export function detectPackageManager() {
+    const name = process.env.npm_config_user_agent?.split('/')[0];
+    return packageManagers.find(pm => pm === name) ?? 'pnpm';
+}
+/**
+ * The installed version of each package manager, or `undefined` when it isn't
+ * installed. All are checked at once, so this takes as long as the slowest one.
+ */
+export async function installedVersions() {
+    const versions = await Promise.all(packageManagers.map(pm => new Promise(resolve => {
+        let output = '';
+        const child = spawn(pm, ['--version'], {
+            // Outside the current folder: a `packageManager` field in a parent
+            // package.json makes corepack refuse to run any other manager.
+            cwd: tmpdir(),
+            // Corepack must never stop to ask before downloading a manager.
+            env: { ...process.env, COREPACK_ENABLE_DOWNLOAD_PROMPT: '0' },
+            shell: process.platform === 'win32',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        child.stdout.on('data', (chunk) => (output += chunk));
+        child.on('error', () => resolve(undefined));
+        child.on('close', code => resolve(code === 0 ? output.trim() || undefined : undefined));
+    })));
+    return Object.fromEntries(packageManagers.map((pm, i) => [pm, versions[i]]));
+}
+/** The command that runs a package.json script, e.g. `pnpm dev` or `npm run dev`. */
+export function runScript(pm, script) {
+    return pm === 'npm' ? `npm run ${script}` : `${pm} ${script}`;
+}
+/** Runs `<pm> install` in `cwd`, capturing the output instead of printing it. */
+export function install(pm, cwd) {
+    return new Promise(resolve => {
+        let output = '';
+        const child = spawn(pm, ['install'], {
+            cwd,
+            // Package managers are `.cmd` shims on Windows, which only a shell can run.
+            shell: process.platform === 'win32',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        child.stdout.on('data', (chunk) => (output += chunk));
+        child.stderr.on('data', (chunk) => (output += chunk));
+        child.on('error', (error) => {
+            const reason = error.code === 'ENOENT'
+                ? `${pm} is not installed on this computer.`
+                : error.message;
+            resolve({ ok: false, output: reason });
+        });
+        child.on('close', code => resolve({ ok: code === 0, output: output.trim() }));
+    });
+}

package/dist/project.js

@@ -0,0 +1,82 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { cp, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { basename, join, resolve } from 'node:path';
+import { templatesDir } from './templates.js';
+/** Files that don't make a folder "used": a project can still be created there. */
+const ignoredFiles = new Set([
+    '.git',
+    '.DS_Store',
+    'Thumbs.db',
+    '.idea',
+    '.vscode',
+]);
+/** Returns why `input` can't hold a new project, or `undefined` when it can. */
+export function validateTargetDir(input) {
+    const dir = input?.trim();
+    if (!dir)
+        return 'Type a folder name, or . to use the current folder.';
+    const path = resolve(dir);
+    if (!existsSync(path))
+        return undefined;
+    if (!statSync(path).isDirectory())
+        return `${dir} is a file, not a folder. Pick another name.`;
+    const used = readdirSync(path).some(file => !ignoredFiles.has(file));
+    if (used) {
+        return path === process.cwd()
+            ? 'The current folder is not empty. Type a name to create a new folder instead.'
+            : `The folder ${dir} is not empty. Pick another name.`;
+    }
+    return undefined;
+}
+/** A valid npm package name from a folder name, e.g. `Mon Bot Été` → `mon-bot-ete`. */
+export function toPackageName(dir) {
+    const name = basename(resolve(dir))
+        // `é` → `e`: split letters from their accents, then drop the accents.
+        .normalize('NFD')
+        .replace(/\p{Diacritic}/gu, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9-~._]+/g, '-')
+        .replace(/-{2,}/g, '-')
+        // npm names can't start with `.` or `_`, and 214 characters is the maximum.
+        .replace(/^[-._]+/, '')
+        .slice(0, 214)
+        .replace(/[-.]+$/, '');
+    return name || 'chapter-bot';
+}
+/**
+ * What pnpm needs to install a project whose framework comes with esbuild
+ * (which `chapterjs build` compiles the bot with). esbuild has an install
+ * script it does not need; pnpm refuses to go on until the project says whether that
+ * script may run. It may not: no script of a dependency runs.
+ * `allowBuilds` is read by pnpm 11, `ignoredBuiltDependencies` by pnpm 10.
+ */
+export const PNPM_WORKSPACE = `# esbuild works without its install script: pnpm is told not to run it.
+allowBuilds:
+  esbuild: false
+ignoredBuiltDependencies:
+  - esbuild
+`;
+/** Copies the template into `dir` and names the project after its folder. */
+export async function createProject({ dir, template, chapterjsVersion, packageManager, templatesRoot = templatesDir, }) {
+    const root = resolve(dir);
+    await cp(join(templatesRoot, template), root, { recursive: true });
+    // Where the files the bot sends go (`asset()`): git and npm keep no empty
+    // folder, so no template can ship it; every project gets it here.
+    await mkdir(join(root, 'public'), { recursive: true });
+    // npm strips `.gitignore` from published packages, so templates ship it as `_gitignore`.
+    const gitignore = join(root, '_gitignore');
+    if (existsSync(gitignore))
+        await rename(gitignore, join(root, '.gitignore'));
+    const pkgPath = join(root, 'package.json');
+    const pkg = JSON.parse(await readFile(pkgPath, 'utf8'));
+    pkg.name = toPackageName(dir);
+    // The template's description is for the menu, not for the user's bot.
+    delete pkg.description;
+    pkg.dependencies = { ...pkg.dependencies, chapterjs: chapterjsVersion };
+    await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    // Only for the package manager that reads it: nothing to explain to the
+    // others.
+    if (packageManager === 'pnpm') {
+        await writeFile(join(root, 'pnpm-workspace.yaml'), PNPM_WORKSPACE);
+    }
+}

package/dist/templates.js

@@ -0,0 +1,31 @@
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+/** `templates/` ships next to `dist/` in the published package. */
+export const templatesDir = fileURLToPath(new URL('../templates/', import.meta.url));
+/**
+ * Every folder of `templates/` with a package.json is a template: adding one
+ * needs no code change.
+ */
+export async function listTemplates(dir = templatesDir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const templates = await Promise.all(entries
+        .filter(entry => entry.isDirectory())
+        .map(async (entry) => {
+        const pkgPath = join(dir, entry.name, 'package.json');
+        if (!existsSync(pkgPath))
+            return undefined;
+        const pkg = JSON.parse(await readFile(pkgPath, 'utf8'));
+        const description = typeof pkg.description === 'string' ? pkg.description : undefined;
+        return { name: entry.name, description };
+    }));
+    // `default` first, so it is the preselected choice.
+    return templates
+        .filter(template => template !== undefined)
+        .sort((a, b) => a.name === 'default'
+        ? -1
+        : b.name === 'default'
+            ? 1
+            : a.name.localeCompare(b.name));
+}

package/package.json

@@ -1,21 +1,35 @@
 {
   "name": "create-chapterjs",
-  "version": "0.2.3",
-  "description": "Alias of create-chapter: scaffolds a ChapterJS Discord bot",
+  "version": "0.4.0",
+  "description": "Creates a ChapterJS Discord bot: pnpm create chapterjs",
+  "keywords": [
+    "discord",
+    "discord-bot",
+    "bot",
+    "framework",
+    "typescript",
+    "slash-commands",
+    "esm",
+    "create",
+    "scaffold",
+    "template",
+    "chapterjs"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/chapterjs/chapterjs.git",
     "directory": "packages/create-chapterjs"
   },
-  "homepage": "https://chapterjs.dev",
+  "homepage": "https://www.chapterjs.org",
   "bugs": "https://github.com/chapterjs/chapterjs/issues",
   "type": "module",
   "bin": {
     "create-chapterjs": "./dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "templates"
   ],
   "devDependencies": {
     "@chapterjs/test-utils": "0.0.0",
@@ -25,7 +39,7 @@
     "vitest": "^5.0.3"
   },
   "dependencies": {
-    "create-chapter": "^0.2.3"
+    "@clack/prompts": "^1.8.1"
   },
   "engines": {
     "node": ">=24"

package/templates/community/.env.example

@@ -0,0 +1,7 @@
+# Your bot token: https://discord.com/developers/applications → your app → Bot → Reset Token
+BOT_TOKEN=
+# The ID of the server used by `chapterjs dev` (right-click the server → Copy Server ID)
+DEV_GUILD_ID=
+# Only for stores declared with storage: 'redis' (https://www.chapterjs.org/storage#in-redis)
+# REDIS_URL=redis://localhost:6379
+# REDIS_PASSWORD=

package/templates/community/_gitignore

@@ -0,0 +1,5 @@
+node_modules
+dist
+.env
+.chapterjs
+data

package/templates/community/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "community-bot",
+  "description": "Welcome messages, roles people pick, and weekly server stats",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "chapterjs dev",
+    "start": "chapterjs start",
+    "build": "chapterjs build",
+    "test": "chapterjs test",
+    "typecheck": "tsc -b",
+    "postinstall": "chapterjs sync"
+  },
+  "dependencies": {
+    "chapterjs": "latest"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^7.0.2"
+  },
+  "engines": {
+    "node": ">=24"
+  }
+}

package/templates/community/src/community.test.ts

@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict';
+import { scenario } from 'chapterjs/test';
+import roles, { pick } from './roles/roles';
+import { weekly } from './stats/weekly';
+
+// `chapterjs test` runs these against a Discord in memory: no token, no
+// server. The welcome channel does not exist there, so the bot writes in
+// the system channel of the server, #general.
+export default [
+  scenario('people are welcomed, and waved goodbye', async bot => {
+    const newbie = await bot.join('newbie');
+    bot
+      .channel('general')
+      .last!.says('Welcome to Test Server')
+      .hasEmbed('Newbie');
+
+    await bot.leave(newbie);
+    bot.channel('general').last!.says('Newbie left.');
+  }),
+
+  scenario('people pick their roles, once the roles exist', async bot => {
+    const menu = await bot.use(roles);
+    menu.isEphemeral().says('Pick the roles');
+
+    const missing = await bot.select(pick, ['Announcements']);
+    missing.updatesMessage().says('Your roles: Announcements.');
+    missing.followUps[0]!.says('do not exist in this server yet');
+
+    bot.role('Announcements');
+    bot.role('Events');
+    bot.role('Gaming');
+    const picked = await bot.select(pick, ['Announcements', 'Gaming']);
+    picked.says('Your roles: Announcements, Gaming.');
+    assert.deepEqual([...bot.someone.roles].sort(), [
+      'Announcements',
+      'Gaming',
+    ]);
+
+    const none = await bot.select(pick, []);
+    none.says('You have none of these roles now.');
+    assert.deepEqual(bot.someone.roles, []);
+  }),
+
+  scenario('the weekly stats are posted', async bot => {
+    await bot.run(weekly);
+    bot.channel('general').last!.hasEmbed('A new week on Test Server');
+  }),
+];

package/templates/community/src/messages.ts

@@ -0,0 +1,49 @@
+import { language } from 'chapterjs';
+
+// The texts of the bot, one language() per language. `t` picks the one of
+// who will read the message: the person for a private answer, the server
+// otherwise, and the default language for a task.
+export const en = language({
+  locale: 'en-US',
+  default: true,
+  texts: {
+    welcome: 'Welcome to {server}, {user}!',
+    goodbye: '{name} left. See you!',
+    pickRoles: 'Pick the roles you want:',
+    rolesPlaceholder: 'Your roles',
+    noRoles: 'You have none of these roles now.',
+    rolesUpdated: 'Your roles: {roles}.',
+    rolesMissing:
+      'These roles do not exist in this server yet: {roles}. Ask an admin to create them.',
+    statsTitle: 'A new week on {server}',
+    members: 'Members',
+    textChannels: 'Text channels',
+    voiceChannels: 'Voice channels',
+    roles: 'Roles',
+  },
+  commands: {
+    roles: { description: 'Picks the roles you want' },
+  },
+});
+
+export const fr = language({
+  locale: 'fr',
+  texts: {
+    welcome: 'Bienvenue sur {server}, {user} !',
+    goodbye: '{name} est parti. À bientôt !',
+    pickRoles: 'Choisissez vos rôles :',
+    rolesPlaceholder: 'Vos rôles',
+    noRoles: 'Vous n’avez plus aucun de ces rôles.',
+    rolesUpdated: 'Vos rôles : {roles}.',
+    rolesMissing:
+      'Ces rôles n’existent pas encore sur ce serveur : {roles}. Demandez à un admin de les créer.',
+    statsTitle: 'Une nouvelle semaine sur {server}',
+    members: 'Membres',
+    textChannels: 'Salons textuels',
+    voiceChannels: 'Salons vocaux',
+    roles: 'Rôles',
+  },
+  commands: {
+    roles: { description: 'Choisit les rôles que vous voulez' },
+  },
+});

package/templates/community/src/presence.ts

@@ -0,0 +1,6 @@
+import { presence } from 'chapterjs';
+
+// What the bot shows under its name.
+export default presence({
+  activity: { type: 'watching', name: 'over the server' },
+});

package/templates/community/src/roles/roles.ts

@@ -0,0 +1,60 @@
+import { command, select } from 'chapterjs';
+
+// The roles people may give themselves: change the list, and create them
+// in your server with the same names.
+const SELF_ROLES = ['Announcements', 'Events', 'Gaming'] as const;
+
+// /roles shows the menu, with what the person already has picked.
+export default command({
+  name: 'roles',
+  ephemeral: true,
+  async run({ interaction, member, t }) {
+    const mine = member.roles
+      .map(role => role.name)
+      .filter((name): name is (typeof SELF_ROLES)[number] =>
+        (SELF_ROLES as readonly string[]).includes(name)
+      );
+    await interaction.reply({
+      content: t('pickRoles'),
+      components: [pick({ defaults: mine })],
+    });
+  },
+});
+
+// A select menu is named by its export. `values` is what was picked, typed
+// from `options`; `min: 0` lets the person remove every role.
+export const pick = select({
+  placeholder: ({ t }) => t('rolesPlaceholder'),
+  options: SELF_ROLES,
+  min: 0,
+  max: SELF_ROLES.length,
+  async run({ interaction, values, member, guild, t }) {
+    const roles = [...guild.roles.values()];
+    const missing: string[] = [];
+    for (const name of SELF_ROLES) {
+      const role = roles.find(role => role.name === name);
+      if (!role) {
+        missing.push(name);
+        continue;
+      }
+      const wanted = values.includes(name);
+      if (wanted && !member.hasRole(role))
+        await member.addRole(role, 'Picked with /roles');
+      if (!wanted && member.hasRole(role))
+        await member.removeRole(role, 'Removed with /roles');
+    }
+    await interaction.update({
+      content:
+        values.length === 0
+          ? t('noRoles')
+          : t('rolesUpdated', { roles: values.join(', ') }),
+      components: [],
+    });
+    if (missing.length > 0) {
+      await interaction.followUp({
+        content: t('rolesMissing', { roles: missing.join(', ') }),
+        ephemeral: true,
+      });
+    }
+  },
+});

package/templates/community/src/stats/weekly.ts

@@ -0,0 +1,50 @@
+import { ChannelType, task } from 'chapterjs';
+import { communityChannel } from '../welcome/channel';
+
+// A task runs by itself: every Monday at 9:00, in the timezone given. The
+// name of the export is the name of the task. `t` is the default language.
+export const weekly = task({
+  cron: '0 9 * * 1',
+  timezone: 'Europe/Paris',
+  async run({ guilds, t }) {
+    for (const guild of guilds.values()) {
+      const channel = communityChannel(guild, 'general');
+      if (!channel) continue;
+      const channels = [...guild.channels.values()];
+      await channel.send({
+        embeds: [
+          {
+            title: t('statsTitle', { server: guild.name }),
+            color: 0xc026d3,
+            fields: [
+              {
+                name: t('members'),
+                value: String(guild.memberCount ?? '?'),
+                inline: true,
+              },
+              {
+                name: t('textChannels'),
+                value: String(
+                  channels.filter(c => c.type === ChannelType.GuildText).length
+                ),
+                inline: true,
+              },
+              {
+                name: t('voiceChannels'),
+                value: String(
+                  channels.filter(c => c.type === ChannelType.GuildVoice).length
+                ),
+                inline: true,
+              },
+              {
+                name: t('roles'),
+                value: String(guild.roles.size - 1),
+                inline: true,
+              },
+            ],
+          },
+        ],
+      });
+    }
+  },
+});