pi-roundtable 0.1.0 → 0.2.0

package/src/cli/add-plugin.test.ts

@@ -1,107 +0,0 @@
-import { afterEach, expect, test } from "bun:test";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { addPlugin } from "./add-plugin.ts";
-import { init } from "./init.ts";
-import { tempDir } from "./testing/fixtures.ts";
-
-const dirs: ReturnType<typeof tempDir>[] = [];
-afterEach(() => {
-	for (const dir of dirs.splice(0)) dir.done();
-});
-const project = () => {
-	const dir = tempDir();
-	dirs.push(dir);
-	init({
-		cwd: dir.path,
-		bun: { version: "1.3.10", required: ">=1.3.0" },
-		version: "1.2.3",
-	});
-	return dir;
-};
-const read = (dir: string, file: string) =>
-	readFileSync(join(dir, file), "utf8");
-
-test("add plugin renders the plugin and its test from the hello template and lists it", () => {
-	const dir = project();
-	const report = addPlugin({ cwd: dir.path, name: "my-notes" });
-	expect(report.ok).toBe(true);
-	expect(report.changed).toEqual([
-		"plugins/my-notes.ts",
-		"plugins/my-notes.test.ts",
-		"roundtable.config.ts",
-	]);
-	const plugin = read(dir.path, "plugins/my-notes.ts");
-	expect(plugin).toContain("export const myNotes = definePlugin(");
-	expect(plugin).toContain('name: "my-notes"');
-	expect(plugin).toContain("my_notes_greet");
-	expect(read(dir.path, "plugins/my-notes.test.ts")).toContain(
-		'import { myNotes } from "./my-notes.ts"',
-	);
-	const config = read(dir.path, "roundtable.config.ts");
-	expect(config).toContain('import { myNotes } from "./plugins/my-notes.ts";');
-	expect(config).toContain("plugins: [hello, myNotes]");
-});
-
-test("a second plugin joins the first", () => {
-	const dir = project();
-	addPlugin({ cwd: dir.path, name: "alpha" });
-	addPlugin({ cwd: dir.path, name: "beta" });
-	expect(read(dir.path, "roundtable.config.ts")).toContain(
-		"plugins: [hello, alpha, beta]",
-	);
-});
-
-test("add plugin refuses a name that is not lowercase kebab-case, changing nothing", () => {
-	const dir = project();
-	const before = read(dir.path, "roundtable.config.ts");
-	for (const name of [
-		"MyNotes",
-		"my_notes",
-		"-a",
-		"a--b",
-		"1a",
-		"",
-		"a b",
-		"../x",
-	]) {
-		const report = addPlugin({ cwd: dir.path, name });
-		expect(report.ok).toBe(false);
-		expect(report.problems.join(" ")).toContain("is not a plugin name");
-	}
-	expect(read(dir.path, "roundtable.config.ts")).toBe(before);
-});
-
-test("add plugin refuses an existing file and leaves the config alone", () => {
-	const dir = project();
-	const before = read(dir.path, "roundtable.config.ts");
-	const report = addPlugin({ cwd: dir.path, name: "hello" });
-	expect(report.ok).toBe(false);
-	expect(report.problems.join(" ")).toContain("plugins/hello.ts");
-	expect(report.problems.join(" ")).toContain("already");
-	expect(read(dir.path, "roundtable.config.ts")).toBe(before);
-	dir.write("plugins/mine.test.ts", "// mine");
-	expect(addPlugin({ cwd: dir.path, name: "mine" }).ok).toBe(false);
-	expect(existsSync(join(dir.path, "plugins/mine.ts"))).toBe(false);
-});
-
-test("add plugin refuses a config whose plugin list it cannot find, writing no plugin file", () => {
-	const dir = project();
-	dir.write("roundtable.config.ts", "export default buildConfig();\n");
-	const report = addPlugin({ cwd: dir.path, name: "extra" });
-	expect(report.ok).toBe(false);
-	expect(report.problems.join(" ")).toContain("cannot find the plugin list");
-	expect(existsSync(join(dir.path, "plugins/extra.ts"))).toBe(false);
-	expect(existsSync(join(dir.path, "plugins/extra.test.ts"))).toBe(false);
-	expect(read(dir.path, "roundtable.config.ts")).toBe(
-		"export default buildConfig();\n",
-	);
-});
-
-test("add plugin outside a project says where it looked", () => {
-	const dir = tempDir();
-	dirs.push(dir);
-	const report = addPlugin({ cwd: dir.path, name: "extra" });
-	expect(report.ok).toBe(false);
-	expect(report.problems.join(" ")).toContain("roundtable.config.ts is not in");
-});

package/src/cli/checks/basic.test.ts

@@ -1,276 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { Project } from "../project.ts";
-import type { Result } from "../report.ts";
-import {
-	fakeHttp,
-	fakePorts,
-	tempDir,
-	validConfig,
-} from "../testing/fixtures.ts";
-import { checkBun } from "./bun.ts";
-import { checkConfiguration, checkPlugins } from "./configuration.ts";
-import { checkEnvironment } from "./environment.ts";
-import { checkModelLogin } from "./model.ts";
-import { checkPublicUrl } from "./public-url.ts";
-
-const dirs: ReturnType<typeof tempDir>[] = [];
-afterEach(() => {
-	for (const dir of dirs.splice(0)) dir.done();
-});
-
-/** The failure's problem and fix text, or an assertion failure when the check passed or skipped. */
-function failure(result: Result): string {
-	if (result.status !== "fail")
-		throw new Error(`expected a failure, got ${JSON.stringify(result)}`);
-	return `${result.problem}\n${result.fix}`;
-}
-
-describe("Bun", () => {
-	test("passes on a version in range", () => {
-		expect(checkBun({ version: "1.3.10", required: ">=1.3.0" }).status).toBe(
-			"ok",
-		);
-	});
-	test("fails when missing, with the install page as the fix", () => {
-		const text = failure(checkBun({ version: undefined, required: ">=1.3.0" }));
-		expect(text).toContain("not installed");
-		expect(text).toContain("https://bun.sh/docs/installation");
-	});
-	test("fails when too old, saying to upgrade", () => {
-		const text = failure(checkBun({ version: "1.2.0", required: ">=1.3.0" }));
-		expect(text).toContain("1.2.0");
-		expect(text).toContain("bun upgrade");
-	});
-});
-
-describe("environment", () => {
-	const example =
-		"# comment\nDISCORD_TOKEN=\nDATABASE_URL=postgres://x\n# OPTIONAL=\nOWNER_ID=\n";
-	test("passes when every listed variable has a value", () => {
-		const dir = tempDir();
-		dirs.push(dir);
-		dir.write(".env.example", example);
-		expect(
-			checkEnvironment(dir.path, {
-				DISCORD_TOKEN: "t",
-				DATABASE_URL: "d",
-				OWNER_ID: "1",
-			}).status,
-		).toBe("ok");
-	});
-	test("names every variable without a value, but not commented ones, and says to copy the example", () => {
-		const dir = tempDir();
-		dirs.push(dir);
-		dir.write(".env.example", example);
-		const text = failure(
-			checkEnvironment(dir.path, { DATABASE_URL: "d", OWNER_ID: "  " }),
-		);
-		expect(text).toContain("DISCORD_TOKEN, OWNER_ID");
-		expect(text).not.toContain("OPTIONAL");
-		expect(text).not.toContain("DATABASE_URL");
-		expect(text).toContain("Copy .env.example to .env");
-	});
-	test("says to fill .env when it exists", () => {
-		const dir = tempDir();
-		dirs.push(dir);
-		dir.write(".env.example", example);
-		dir.write(".env", "");
-		expect(failure(checkEnvironment(dir.path, {}))).toContain(
-			"Fill them in .env",
-		);
-	});
-	test("skips a project without an example", () => {
-		const dir = tempDir();
-		dirs.push(dir);
-		expect(checkEnvironment(dir.path, {}).status).toBe("skipped");
-	});
-});
-
-describe("configuration", () => {
-	const project = (config: unknown) => new Project("/x", fakePorts(config));
-	test("passes a configuration the schema accepts", async () => {
-		expect((await checkConfiguration(project(validConfig))).status).toBe("ok");
-	});
-	test("names the failing key, and says where to fix it", async () => {
-		const text = failure(
-			await checkConfiguration(
-				project({
-					...validConfig,
-					discord: { ...validConfig.discord, token: "" },
-				}),
-			),
-		);
-		expect(text).toContain("config discord.token");
-		expect(text).toContain("roundtable.config.ts");
-	});
-	test("names the closest known key for one it does not know", async () => {
-		const text = failure(
-			await checkConfiguration(project({ ...validConfig, modle: "x" })),
-		);
-		expect(text).toContain('Did you mean "model"');
-	});
-	test("fails with the loader's message when the file cannot be loaded", async () => {
-		const failing = new Project(
-			"/x",
-			fakePorts(undefined, {
-				loadConfig: async () => {
-					throw new Error("roundtable.config.ts is not in /x");
-				},
-			}),
-		);
-		expect(failure(await checkConfiguration(failing))).toContain(
-			"is not in /x",
-		);
-	});
-	test("fails with the assembly's own message", async () => {
-		const failing = new Project(
-			"/x",
-			fakePorts(validConfig, {
-				define: async () => {
-					throw new Error(
-						"config prompts.shared: cannot read ./persona/shared.md",
-					);
-				},
-			}),
-		);
-		expect(failure(await checkConfiguration(failing))).toContain(
-			"prompts.shared",
-		);
-	});
-});
-
-describe("plugins", () => {
-	const plugin = (name: string) => ({ name, setup: () => ({}) });
-	const withPlugins = (names: string[]) =>
-		new Project(
-			"/x",
-			fakePorts(
-				{ ...validConfig, plugins: [plugin("hello")] },
-				{
-					define: async () => ({
-						options: { logger: {} as never },
-						plugins: names.map(plugin),
-					}),
-				},
-			),
-		);
-	test("passes when every name is its own and lists the operator's", async () => {
-		const result = await checkPlugins(withPlugins(["database", "hello"]));
-		expect(result).toEqual({ status: "ok", detail: "yours: hello" });
-	});
-	test("fails on a repeated name and says to rename", async () => {
-		const text = failure(
-			await checkPlugins(withPlugins(["database", "hello", "hello"])),
-		);
-		expect(text).toContain("two plugins are named hello");
-		expect(text).toContain("Rename");
-	});
-	test("is skipped while the configuration is invalid", async () => {
-		const result = await checkPlugins(new Project("/x", fakePorts({})));
-		expect(result.status).toBe("skipped");
-	});
-});
-
-describe("model login", () => {
-	const login = (source: string | undefined, seen: string[] = []) =>
-		fakePorts(validConfig, {
-			login: async (dir, provider) => {
-				seen.push(`${dir} ${provider}`);
-				return source;
-			},
-		});
-	test("passes when the provider has a login and says where it comes from", async () => {
-		const seen: string[] = [];
-		const result = await checkModelLogin(
-			new Project("/x", login("ANTHROPIC_API_KEY", seen)),
-			login("ANTHROPIC_API_KEY", seen),
-		);
-		expect(result).toEqual({
-			status: "ok",
-			detail: "anthropic login from ANTHROPIC_API_KEY",
-		});
-		expect(seen).toEqual(["/data/pi anthropic"]);
-	});
-	test("fails when there is none, naming the provider, the model, and the ways to log in", async () => {
-		const ports = login(undefined);
-		const text = failure(
-			await checkModelLogin(new Project("/x", ports), ports),
-		);
-		expect(text).toContain("no login for anthropic");
-		expect(text).toContain("anthropic/claude-sonnet-5-5");
-		expect(text).toContain("ANTHROPIC_API_KEY");
-		expect(text).toContain("/data/pi/auth.json");
-	});
-	test("fails on a model that is not <provider>/<id>", async () => {
-		const ports = fakePorts({ ...validConfig, model: "sonnet" });
-		expect(
-			failure(await checkModelLogin(new Project("/x", ports), ports)),
-		).toContain("<provider>/<id>");
-	});
-	test("uses the configured agent directory", async () => {
-		const seen: string[] = [];
-		const ports = fakePorts(
-			{ ...validConfig, agentDir: "/agents" },
-			{
-				login: async (dir) => {
-					seen.push(dir);
-					return "x";
-				},
-			},
-		);
-		await checkModelLogin(new Project("/x", ports), ports);
-		expect(seen).toEqual(["/agents"]);
-	});
-});
-
-describe("public URL", () => {
-	const project = (url: unknown) =>
-		new Project("/x", fakePorts({ ...validConfig, http: { publicUrl: url } }));
-	test("passes a well-formed address without asking the network", async () => {
-		const http = fakeHttp({});
-		const result = await checkPublicUrl(
-			project("https://bot.example.test"),
-			http,
-			false,
-		);
-		expect(result.status).toBe("ok");
-		expect(http.requests).toEqual([]);
-	});
-	test("fails on something that is not a URL, showing an example", async () => {
-		const text = failure(
-			await checkPublicUrl(project("bot.example.test"), fakeHttp({}), false),
-		);
-		expect(text).toContain("not a URL");
-		expect(text).toContain("https://bot.example.com");
-	});
-	test("fails on a scheme Discord cannot fetch from", async () => {
-		expect(
-			failure(
-				await checkPublicUrl(
-					project("ftp://bot.example.test"),
-					fakeHttp({}),
-					false,
-				),
-			),
-		).toContain("http(s)");
-	});
-	test("with reachable, passes on any answer and fails when nothing answers", async () => {
-		const answering = fakeHttp({ "/": { status: 404, body: undefined } });
-		expect(
-			await checkPublicUrl(
-				project("https://bot.example.test"),
-				answering,
-				true,
-			),
-		).toEqual({
-			status: "ok",
-			detail: "https://bot.example.test answered 404",
-		});
-		const down = fakeHttp({ "/": new Error("connection refused") });
-		const text = failure(
-			await checkPublicUrl(project("https://bot.example.test"), down, true),
-		);
-		expect(text).toContain("connection refused");
-		expect(text).toContain("roundtable start");
-	});
-});

package/src/cli/checks/database.test.ts

@@ -1,117 +0,0 @@
-import { expect, test } from "bun:test";
-import type { Migration } from "../../core/db/migrations.ts";
-import { MigrationError } from "../../core/errors.ts";
-import { describeDb, testDatabaseUrl } from "../../core/testing/database.ts";
-import { Project } from "../project.ts";
-import { fakePorts, validConfig } from "../testing/fixtures.ts";
-import { checkDatabase, type DatabasePort, postgres } from "./database.ts";
-
-const migration: Migration = { name: "doctor-probe", up: async () => {} };
-const withMigration = (name = "probe") =>
-	new Project(
-		"/x",
-		fakePorts(validConfig, {
-			define: async () => ({
-				options: { logger: {} as never },
-				plugins: [{ name, setup: () => ({}), migrations: [migration] }],
-			}),
-		}),
-	);
-
-test("passes when the database answers and the migrations run, without printing the password", async () => {
-	const asked: unknown[] = [];
-	const port: DatabasePort = {
-		check: async (url, migrations) => void asked.push([url, migrations]),
-	};
-	const result = await checkDatabase(withMigration(), port);
-	expect(result.status).toBe("ok");
-	if (result.status === "ok") {
-		expect(result.detail).toContain("db.example.test:5432/bot");
-		expect(result.detail).not.toContain("secret");
-	}
-	expect(asked).toEqual([[validConfig.database.url, [migration]]]);
-});
-
-test("fails when the database is unreachable, naming it and saying how to start one", async () => {
-	const port: DatabasePort = {
-		check: async () => {
-			throw new Error("connection refused");
-		},
-	};
-	const result = await checkDatabase(withMigration(), port);
-	expect(result.status).toBe("fail");
-	if (result.status === "fail") {
-		expect(result.problem).toContain("db.example.test:5432/bot");
-		expect(result.problem).toContain("connection refused");
-		expect(result.problem).not.toContain("secret");
-		expect(result.fix).toContain("docker compose up -d");
-	}
-});
-
-test("fails when a migration fails, naming it", async () => {
-	const port: DatabasePort = {
-		check: async () => {
-			throw new MigrationError("owner-memory", new Error("permission denied"));
-		},
-	};
-	const result = await checkDatabase(withMigration(), port);
-	expect(result.status).toBe("fail");
-	if (result.status === "fail") {
-		expect(result.problem).toContain("migration owner-memory failed");
-		expect(result.problem).toContain("permission denied");
-	}
-});
-
-test("still tests reachability from the raw url while the configuration is invalid, and skips without a url", async () => {
-	const asked: unknown[] = [];
-	const port: DatabasePort = {
-		check: async (url, migrations) => void asked.push([url, migrations]),
-	};
-	const invalid = new Project(
-		"/x",
-		fakePorts({ database: { url: "postgres://h/d" } }),
-	);
-	const result = await checkDatabase(invalid, port);
-	expect(result.status).toBe("ok");
-	expect(asked).toEqual([["postgres://h/d", undefined]]);
-	const none = await checkDatabase(new Project("/x", fakePorts({})), port);
-	expect(none.status).toBe("skipped");
-});
-
-describeDb("against PostgreSQL", () => {
-	test("runs the migrations inside a rolled-back transaction, including ones that open their own", async () => {
-		const table = `doctor_probe_${Date.now()}`;
-		const run: Migration = {
-			name: "creates",
-			up: async (sql) => {
-				await sql`create table ${sql(table)} (id int)`;
-				await sql.begin(async (inner) => {
-					await inner`insert into ${inner(table)} values (1)`;
-				});
-			},
-		};
-		await postgres.check(testDatabaseUrl, [run]);
-		const pool = new Bun.SQL(testDatabaseUrl, { max: 1 });
-		try {
-			const [found] = await pool`select to_regclass(${table}) as name`;
-			expect(found?.name).toBeNull();
-		} finally {
-			await pool.close();
-		}
-	});
-
-	test("reports a failing migration as a MigrationError and an unreachable server as an error", async () => {
-		const broken: Migration = {
-			name: "broken",
-			up: async (sql) => {
-				await sql`select * from no_such_table_anywhere`;
-			},
-		};
-		await expect(
-			postgres.check(testDatabaseUrl, [broken]),
-		).rejects.toBeInstanceOf(MigrationError);
-		await expect(
-			postgres.check("postgres://nobody@127.0.0.1:1/none", undefined),
-		).rejects.toThrow();
-	});
-});

package/src/cli/checks/discord.test.ts

@@ -1,200 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { PermissionFlagsBits } from "discord.js";
-import { INVITE_PERMISSIONS } from "../discord-api.ts";
-import { Project } from "../project.ts";
-import type { Result } from "../report.ts";
-import {
-	BOT_ID,
-	fakeHttp,
-	fakePorts,
-	healthyDiscord,
-	validConfig,
-} from "../testing/fixtures.ts";
-import {
-	checkChannel,
-	checkGuild,
-	checkIntents,
-	checkToken,
-	Discord,
-} from "./discord.ts";
-
-const guild = validConfig.discord.guild;
-const channel = validConfig.discord.entryChannel;
-const project = (config: unknown = validConfig) =>
-	new Project("/x", fakePorts(config));
-
-function failure(result: Result): string {
-	if (result.status !== "fail")
-		throw new Error(`expected a failure, got ${JSON.stringify(result)}`);
-	return `${result.problem}\n${result.fix}`;
-}
-
-const all = INVITE_PERMISSIONS;
-const bit = (name: keyof typeof PermissionFlagsBits): bigint =>
-	PermissionFlagsBits[name];
-const without = (name: keyof typeof PermissionFlagsBits): bigint =>
-	all & ~bit(name);
-
-describe("Discord token", () => {
-	test("passes and names the bot", async () => {
-		const http = fakeHttp(healthyDiscord(all));
-		const result = await checkToken(new Discord(project(), http));
-		expect(result).toEqual({ status: "ok", detail: "the bot is Bot" });
-	});
-	test("fails on a rejected token with where to reset it", async () => {
-		const http = fakeHttp({ "/users/@me": { status: 401, body: {} } });
-		const text = failure(await checkToken(new Discord(project(), http)));
-		expect(text).toContain("rejected the bot token");
-		expect(text).toContain("DISCORD_TOKEN");
-		expect(text).toContain("discord.com/developers");
-	});
-	test("fails when Discord cannot be reached, without a stack trace", async () => {
-		const http = fakeHttp({ "/users/@me": new Error("getaddrinfo ENOTFOUND") });
-		const text = failure(await checkToken(new Discord(project(), http)));
-		expect(text).toContain("cannot reach discord.com: getaddrinfo ENOTFOUND");
-		expect(text).toContain("network");
-	});
-	test("skips without a token, and sends the token as the bot's authorization", async () => {
-		const none = project({
-			...validConfig,
-			discord: { ...validConfig.discord, token: "" },
-		});
-		expect((await checkToken(new Discord(none, fakeHttp({})))).status).toBe(
-			"skipped",
-		);
-		let seen: Record<string, string> | undefined;
-		await checkToken(
-			new Discord(project(), {
-				get: async (_url, headers) => {
-					seen = headers;
-					return { status: 200, body: { id: BOT_ID } };
-				},
-			}),
-		);
-		expect(seen).toEqual({ Authorization: "Bot bot-token" });
-	});
-	test("asks Discord once for who the bot is however many checks need it", async () => {
-		const http = fakeHttp(healthyDiscord(all));
-		const discord = new Discord(project(), http);
-		await checkToken(discord);
-		await checkGuild(project(), discord);
-		await checkChannel(project(), discord);
-		expect(http.requests.filter((path) => path === "/users/@me")).toHaveLength(
-			1,
-		);
-	});
-});
-
-describe("Discord guild", () => {
-	test("passes when the bot is in the guild", async () => {
-		const http = fakeHttp(healthyDiscord(all));
-		const result = await checkGuild(project(), new Discord(project(), http));
-		expect(result).toEqual({
-			status: "ok",
-			detail: "the bot is in Test Guild",
-		});
-	});
-	test("fails when it is not, with an invitation that asks for what the bot needs", async () => {
-		const http = fakeHttp({
-			...healthyDiscord(all),
-			[`/guilds/${guild}`]: { status: 404, body: { code: 10004 } },
-		});
-		const text = failure(
-			await checkGuild(project(), new Discord(project(), http)),
-		);
-		expect(text).toContain(`not in the guild ${guild}`);
-		expect(text).toContain(`client_id=${BOT_ID}`);
-		expect(text).toContain(`permissions=${INVITE_PERMISSIONS}`);
-	});
-	test("is skipped when the token failed", async () => {
-		const http = fakeHttp({ "/users/@me": { status: 401, body: {} } });
-		expect(
-			(await checkGuild(project(), new Discord(project(), http))).status,
-		).toBe("skipped");
-	});
-});
-
-describe("Discord intents", () => {
-	test("passes with the Message Content intent, granted or limited", async () => {
-		for (const flags of [1 << 18, 1 << 19]) {
-			const http = fakeHttp({
-				...healthyDiscord(all),
-				"/applications/@me": { status: 200, body: { flags } },
-			});
-			expect((await checkIntents(new Discord(project(), http))).status).toBe(
-				"ok",
-			);
-		}
-	});
-	test("fails without it, saying where to turn it on", async () => {
-		const http = fakeHttp({
-			...healthyDiscord(all),
-			"/applications/@me": { status: 200, body: { flags: 0 } },
-		});
-		const text = failure(await checkIntents(new Discord(project(), http)));
-		expect(text).toContain("Message Content intent is off");
-		expect(text).toContain("Bot in https://discord.com/developers");
-	});
-});
-
-describe("Discord channel", () => {
-	const check = (routes: Record<string, never> | object) =>
-		checkChannel(project(), new Discord(project(), fakeHttp(routes as never)));
-	test("passes when the bot has every permission", async () => {
-		expect((await check(healthyDiscord(all))).status).toBe("ok");
-	});
-	test("fails naming the permission the bot lacks, Pin Messages included, and why it is needed", async () => {
-		const text = failure(await check(healthyDiscord(without("PinMessages"))));
-		expect(text).toContain("lacks PinMessages");
-		expect(text).toContain("pin the dashboard");
-	});
-	test("a channel overwrite that denies a permission counts, and an allow restores it", async () => {
-		const pin = bit("PinMessages");
-		const denied = healthyDiscord(all);
-		denied[`/channels/${channel}`] = {
-			status: 200,
-			body: {
-				guild_id: guild,
-				permission_overwrites: [
-					{ id: "700000000000000001", type: 0, allow: "0", deny: String(pin) },
-				],
-			},
-		};
-		expect(failure(await check(denied))).toContain("PinMessages");
-		const restored = healthyDiscord(all);
-		restored[`/channels/${channel}`] = {
-			status: 200,
-			body: {
-				guild_id: guild,
-				permission_overwrites: [
-					{ id: guild, type: 0, allow: "0", deny: String(pin) },
-					{ id: BOT_ID, type: 1, allow: String(pin), deny: "0" },
-				],
-			},
-		};
-		expect((await check(restored)).status).toBe("ok");
-	});
-	test("the owner of the guild and an administrator have every permission", async () => {
-		const administrator = 1n << 3n;
-		expect((await check(healthyDiscord(administrator))).status).toBe("ok");
-	});
-	test("fails when the channel does not exist or is in another guild", async () => {
-		const missing = healthyDiscord(all);
-		missing[`/channels/${channel}`] = { status: 404, body: {} };
-		expect(failure(await check(missing))).toContain("DISCORD_ENTRY_CHANNEL_ID");
-		const elsewhere = healthyDiscord(all);
-		elsewhere[`/channels/${channel}`] = {
-			status: 200,
-			body: { guild_id: "999", permission_overwrites: [] },
-		};
-		expect(failure(await check(elsewhere))).toContain("another guild");
-	});
-	test("is skipped without the channel or guild value", async () => {
-		const empty = project({
-			...validConfig,
-			discord: { ...validConfig.discord, entryChannel: "" },
-		});
-		const result = await checkChannel(empty, new Discord(empty, fakeHttp({})));
-		expect(result.status).toBe("skipped");
-	});
-});