@serverkgg/bridge 0.0.21 → 0.1.2

package/src/bot/detect/botToken.ts

@@ -0,0 +1,126 @@
+import { BotPlatform } from "./botPlatform";
+
+export const BOT_TOKEN_KEYS: Readonly<Record<BotPlatform, readonly string[]>> = {
+	[BotPlatform.Discord]: [
+		"DISCORD_TOKEN",
+		"DISCORD_BOT_TOKEN",
+		"BOT_TOKEN",
+		"TOKEN",
+	],
+	[BotPlatform.Telegram]: [
+		"TELEGRAM_TOKEN",
+		"TELEGRAM_BOT_TOKEN",
+		"BOT_TOKEN",
+		"TOKEN",
+	],
+};
+
+const TELEGRAM_TOKEN = /^(?<id>\d{1,20}):[A-Za-z0-9_-]{20,128}$/;
+
+const DISCORD_TOKEN = /^(?<id>[A-Za-z0-9_-]{16,40})\.[A-Za-z0-9_-]{4,16}\.[A-Za-z0-9_-]{20,128}$/;
+
+const SNOWFLAKE = /^\d{17,20}$/;
+
+const PLATFORM_KEY_HINTS: readonly [
+	RegExp,
+	BotPlatform,
+][] = [
+	[
+		/DISCORD/i,
+		BotPlatform.Discord,
+	],
+	[
+		/TELEGRAM/i,
+		BotPlatform.Telegram,
+	],
+];
+
+const decodeBase64Url = (segment: string) => {
+	const standard = segment.replaceAll("-", "+").replaceAll("_", "/");
+	const padded = standard.padEnd(standard.length + ((4 - (standard.length % 4)) % 4), "=");
+
+	try {
+		return atob(padded);
+	} catch {
+		return null;
+	}
+};
+
+export const telegramBotId = (token: string): string | null => {
+	return TELEGRAM_TOKEN.exec(token.trim())?.groups?.id ?? null;
+};
+
+export const discordApplicationId = (token: string): string | null => {
+	const segment = DISCORD_TOKEN.exec(token.trim())?.groups?.id;
+
+	if (!segment) {
+		return null;
+	}
+
+	const decoded = decodeBase64Url(segment);
+
+	return decoded !== null && SNOWFLAKE.test(decoded) ? decoded : null;
+};
+
+export const platformOfToken = (value: string): BotPlatform | null => {
+	if (telegramBotId(value) !== null) {
+		return BotPlatform.Telegram;
+	}
+
+	if (discordApplicationId(value) !== null) {
+		return BotPlatform.Discord;
+	}
+
+	return null;
+};
+
+export const platformOfKey = (key: string): BotPlatform | null => {
+	for (const [pattern, platform] of PLATFORM_KEY_HINTS) {
+		if (pattern.test(key)) {
+			return platform;
+		}
+	}
+
+	return null;
+};
+
+export interface BotEnvironmentMaps {
+	variables: Readonly<Record<string, string>>;
+	secrets: Readonly<Record<string, string>>;
+}
+
+export interface BotTokenMatch {
+	key: string;
+	value: string;
+}
+
+const entriesOf = (maps: BotEnvironmentMaps) => {
+	return [
+		...Object.entries(maps.secrets),
+		...Object.entries(maps.variables),
+	];
+};
+
+export const findBotToken = (platform: BotPlatform, maps: BotEnvironmentMaps): BotTokenMatch | null => {
+	const entries = entriesOf(maps).filter(([, value]) => platformOfToken(value) === platform);
+
+	for (const name of BOT_TOKEN_KEYS[platform]) {
+		const named = entries.find(([key]) => key === name);
+
+		if (named) {
+			return {
+				key: named[0],
+				value: named[1].trim(),
+			};
+		}
+	}
+
+	const first = entries[0];
+
+	return first
+		? {
+				key: first[0],
+				value: first[1].trim(),
+			}
+		: null;
+};

package/src/bot/detect/detect.test.ts

@@ -0,0 +1,543 @@
+import { describe, expect, test } from "bun:test";
+import { BotFramework } from "./botFramework";
+import { BotInspectWarning } from "./botInspectWarning";
+import { BotPackageManager } from "./botPackageManager";
+import { BotPlatform } from "./botPlatform";
+import { BotRuntime } from "./botRuntime";
+import {
+	compareCodePoints,
+	DETECT_SOURCE_FILE_LIMIT,
+	DETECT_SOURCE_MAX_BYTES,
+	detect,
+	detectWantedFiles,
+	parsePyprojectDependencies,
+	parseRequirements,
+} from "./detect";
+import type { DetectResult } from "./detectResult";
+
+const project = (contents: Record<string, string>, extra: string[] = []) => {
+	return detect({
+		files: [
+			...Object.keys(contents),
+			...extra,
+		].map((path) => ({
+			path,
+		})),
+		contents,
+	});
+};
+
+const DISCORD_NODE = {
+	"package.json": JSON.stringify({
+		name: "discord-bot",
+		type: "module",
+		main: "index.js",
+		scripts: {
+			start: "node index.js",
+		},
+		dependencies: {
+			"discord.js": "^14.27.0",
+		},
+	}),
+	"index.js":
+		'const token = process.env.DISCORD_TOKEN;\nawait client.login(token);\nimport { Client } from "discord.js";',
+	".env.example": "DISCORD_TOKEN=\n",
+};
+
+const TELEGRAM_PYTHON = {
+	"requirements.txt": "httpx==0.28.1\npython-telegram-bot==21.11.1\n",
+	"main.py":
+		'import os\nfrom telegram.ext import Application\napp = Application.builder().token(os.environ["TELEGRAM_TOKEN"]).build()\n',
+	".env.example": "TELEGRAM_TOKEN=\n",
+};
+
+describe("detect on the templates", () => {
+	test("reads the discord.js template end to end", () => {
+		expect(
+			project(DISCORD_NODE, [
+				"package-lock.json",
+				"README.md",
+			]),
+		).toEqual({
+			runtime: BotRuntime.Node,
+			package: "bot-node",
+			packageManager: BotPackageManager.Npm,
+			framework: BotFramework.DiscordJs,
+			platform: BotPlatform.Discord,
+			install: {
+				command: "npm ci",
+				source: "package-lock.json",
+			},
+			start: {
+				command: "node index.js",
+				source: "package.json",
+			},
+			env: [
+				{
+					key: "DISCORD_TOKEN",
+					sensitive: true,
+					source: ".env.example",
+					example: null,
+				},
+			],
+			tokenKey: "DISCORD_TOKEN",
+			warnings: [],
+		} satisfies DetectResult);
+	});
+
+	test("reads the python-telegram-bot template end to end", () => {
+		expect(project(TELEGRAM_PYTHON)).toEqual({
+			runtime: BotRuntime.Python,
+			package: "bot-python",
+			packageManager: BotPackageManager.Pip,
+			framework: BotFramework.PythonTelegramBot,
+			platform: BotPlatform.Telegram,
+			install: {
+				command: "pip install -r requirements.txt",
+				source: "requirements.txt",
+			},
+			start: {
+				command: "python main.py",
+				source: "main.py",
+			},
+			env: [
+				{
+					key: "TELEGRAM_TOKEN",
+					sensitive: true,
+					source: ".env.example",
+					example: null,
+				},
+			],
+			tokenKey: "TELEGRAM_TOKEN",
+			warnings: [],
+		} satisfies DetectResult);
+	});
+
+	test("reads the lockfile a pnpm or yarn project ships", () => {
+		expect(
+			project(DISCORD_NODE, [
+				"pnpm-lock.yaml",
+			]).install,
+		).toEqual({
+			command: "corepack pnpm install --frozen-lockfile",
+			source: "pnpm-lock.yaml",
+		});
+		expect(
+			project(DISCORD_NODE, [
+				"yarn.lock",
+			]).packageManager,
+		).toBe(BotPackageManager.Yarn);
+	});
+
+	test("installs a pyproject project with pip", () => {
+		const result = project({
+			"pyproject.toml": '[project]\nname = "bot"\ndependencies = [\n  "discord.py>=2.4",\n]\n',
+			"bot.py": 'import discord\nimport os\nos.getenv("DISCORD_TOKEN")\n',
+		});
+
+		expect(result.install).toEqual({
+			command: "pip install .",
+			source: "pyproject.toml",
+		});
+		expect(result.framework).toBe(BotFramework.DiscordPy);
+		expect(result.start).toEqual({
+			command: "python bot.py",
+			source: "bot.py",
+		});
+	});
+});
+
+describe("detect start commands", () => {
+	test("follows the launcher's order: start script, main, known files, then the Procfile", () => {
+		expect(
+			project({
+				"package.json": JSON.stringify({
+					main: "src/app.js",
+				}),
+				"src/app.js": "",
+				"index.js": "",
+			}).start,
+		).toEqual({
+			command: "node src/app.js",
+			source: "package.json",
+		});
+		expect(
+			project({
+				"package.json": "{}",
+				"src/bot.js": "",
+			}).start,
+		).toEqual({
+			command: "node src/bot.js",
+			source: "src/bot.js",
+		});
+		expect(
+			project({
+				"package.json": "{}",
+				Procfile: "web: node server.js\nworker: node worker.js\n",
+			}).start,
+		).toEqual({
+			command: "node worker.js",
+			source: "Procfile",
+		});
+	});
+
+	test("warns when nothing starts and when node would run TypeScript directly", () => {
+		expect(
+			project({
+				"package.json": "{}",
+			}).warnings,
+		).toContain(BotInspectWarning.NoStart);
+		expect(
+			project({
+				"package.json": "{}",
+				"index.ts": "",
+			}).warnings,
+		).toContain(BotInspectWarning.TypescriptEntry);
+		expect(
+			project({
+				"package.json": JSON.stringify({
+					scripts: {
+						start: "tsx src/index.ts",
+					},
+				}),
+			}).warnings,
+		).not.toContain(BotInspectWarning.TypescriptEntry);
+	});
+});
+
+describe("detect warnings", () => {
+	test("flags a missing lockfile, loose requirements and a missing manifest", () => {
+		expect(
+			project({
+				"package.json": "{}",
+				"index.js": "",
+			}).warnings,
+		).toEqual([
+			BotInspectWarning.NoLockfile,
+		]);
+		expect(
+			project({
+				"requirements.txt": "discord.py\naiohttp>=3\n",
+				"main.py": "",
+			}).warnings,
+		).toEqual([
+			BotInspectWarning.UnpinnedRequirements,
+		]);
+		expect(
+			project({
+				"main.py": "import discord",
+			}).warnings,
+		).toEqual([
+			BotInspectWarning.NoManifest,
+		]);
+		expect(
+			project({
+				"README.md": "",
+			}).warnings,
+		).toEqual([
+			BotInspectWarning.NoStart,
+			BotInspectWarning.NoManifest,
+		]);
+	});
+
+	test("flags committed secrets and dependency folders but not the templates for them", () => {
+		expect(
+			project(DISCORD_NODE, [
+				"package-lock.json",
+				".env",
+				"config/.env.production",
+				"node_modules/discord.js/package.json",
+				"node_modules/some/.env",
+				".venv/pyvenv.cfg",
+				".env.sample",
+			]).warnings,
+		).toEqual([
+			BotInspectWarning.EnvCommitted,
+			BotInspectWarning.NodeModulesCommitted,
+			BotInspectWarning.VenvCommitted,
+		]);
+	});
+
+	test("flags two runtimes and picks the one whose framework it found", () => {
+		const result = project({
+			...DISCORD_NODE,
+			"requirements.txt": "requests==2.32.0\n",
+		});
+
+		expect(result.runtime).toBe(BotRuntime.Node);
+		expect(result.warnings).toContain(BotInspectWarning.TwoRuntimes);
+	});
+
+	test("flags two platforms and leaves the choice to the customer", () => {
+		const result = project({
+			"package.json": JSON.stringify({
+				dependencies: {
+					"discord.js": "14",
+					grammy: "1",
+				},
+			}),
+			"index.js": "",
+		});
+
+		expect(result.platform).toBeNull();
+		expect(result.framework).toBeNull();
+		expect(result.warnings).toContain(BotInspectWarning.TwoPlatforms);
+	});
+
+	test("drops keys the platform owns and warns, but keeps quiet about keys the runtime gives anyway", () => {
+		const result = project({
+			...DISCORD_NODE,
+			"index.js": "process.env.REPO_URL; process.env.HOME; process.env.SERVERK_BOT; process.env.GUILD_ID;",
+		});
+
+		expect(result.env.map((entry) => entry.key)).toEqual([
+			"DISCORD_TOKEN",
+			"GUILD_ID",
+		]);
+		expect(result.warnings).toContain(BotInspectWarning.ReservedEnvKey);
+
+		const quiet = project({
+			...DISCORD_NODE,
+			"index.js": "process.env.PATH; process.env.BOT_PLATFORM;",
+		});
+
+		expect(quiet.warnings).not.toContain(BotInspectWarning.ReservedEnvKey);
+	});
+});
+
+describe("detect with serverk.json", () => {
+	test("lets the repository's own file win and says when the code disagrees", () => {
+		const result = project({
+			...DISCORD_NODE,
+			"serverk.json": JSON.stringify({
+				platform: "telegram",
+				start: "node dist/main.js",
+				env: [
+					{
+						key: "OWNER_ID",
+						sensitive: false,
+						example: "1234",
+					},
+				],
+			}),
+		});
+
+		expect(result.platform).toBe(BotPlatform.Telegram);
+		expect(result.start).toEqual({
+			command: "node dist/main.js",
+			source: "serverk.json",
+		});
+		expect(result.env[0]).toEqual({
+			key: "OWNER_ID",
+			sensitive: false,
+			source: "serverk.json",
+			example: "1234",
+		});
+		expect(result.warnings).toContain(BotInspectWarning.ManifestDisagrees);
+	});
+
+	test("installs with the file's own install command over the lockfile's", () => {
+		const result = project({
+			...DISCORD_NODE,
+			"package-lock.json": "{}",
+			"serverk.json": JSON.stringify({
+				install: "npm ci --omit=dev",
+			}),
+		});
+
+		expect(result.install).toEqual({
+			command: "npm ci --omit=dev",
+			source: "serverk.json",
+		});
+		expect(result.packageManager).toBe(BotPackageManager.Npm);
+	});
+
+	test("reports a broken file and falls back to the code", () => {
+		const result = project({
+			...DISCORD_NODE,
+			"package-lock.json": "{}",
+			"serverk.json": '{"runtime": "go", "start": "node other.js", "install": "npm i"}',
+		});
+
+		expect(result.runtime).toBe(BotRuntime.Node);
+		expect(result.start?.command).toBe("node index.js");
+		expect(result.install?.command).toBe("npm ci");
+		expect(result.warnings).toContain(BotInspectWarning.ManifestInvalid);
+	});
+});
+
+describe("compareCodePoints", () => {
+	test("orders by code point, the way Python sorts strings, whatever the locale", () => {
+		expect(
+			[
+				"b.js",
+				"B.js",
+				"a.js",
+				"\u{1F916}.js",
+				"ａ.js",
+			].sort(compareCodePoints),
+		).toEqual([
+			"B.js",
+			"a.js",
+			"b.js",
+			"ａ.js",
+			"\u{1F916}.js",
+		]);
+	});
+});
+
+describe("detect env suggestions", () => {
+	test("reads the example file first, then every way code reads the environment", () => {
+		const result = project({
+			"package.json": "{}",
+			"index.js": [
+				"const { GUILD_ID, OWNER: owner, ...rest } = process.env;",
+				'process.env["PREFIX"];',
+				"process.env.OPENAI_API_KEY;",
+			].join("\n"),
+			".env.example": "# comment\nexport LOG_LEVEL=info # verbose\nAPI_SECRET='shh'\n",
+		});
+
+		expect(result.env).toEqual([
+			{
+				key: "LOG_LEVEL",
+				sensitive: false,
+				source: ".env.example",
+				example: "info",
+			},
+			{
+				key: "API_SECRET",
+				sensitive: true,
+				source: ".env.example",
+				example: null,
+			},
+			{
+				key: "GUILD_ID",
+				sensitive: false,
+				source: "index.js",
+				example: null,
+			},
+			{
+				key: "OWNER",
+				sensitive: false,
+				source: "index.js",
+				example: null,
+			},
+			{
+				key: "PREFIX",
+				sensitive: false,
+				source: "index.js",
+				example: null,
+			},
+			{
+				key: "OPENAI_API_KEY",
+				sensitive: true,
+				source: "index.js",
+				example: null,
+			},
+		]);
+	});
+
+	test("names the token key the code reads for its platform", () => {
+		const result = project({
+			"requirements.txt": "discord.py==2.7.1\n",
+			"main.py": 'import os\nimport discord\nos.environ.get("MY_BOT_TOKEN")\nos.getenv("LOG_CHANNEL")\n',
+		});
+
+		expect(result.platform).toBe(BotPlatform.Discord);
+		expect(result.tokenKey).toBe("MY_BOT_TOKEN");
+	});
+});
+
+describe("detectWantedFiles", () => {
+	test("asks for the small files the kit reads and at most forty small sources", () => {
+		const files = [
+			{
+				path: "package.json",
+				size: 400,
+			},
+			{
+				path: "package-lock.json",
+				size: 90_000,
+			},
+			{
+				path: ".env.example",
+				size: 20,
+			},
+			{
+				path: "./src/index.js",
+				size: 100,
+			},
+			{
+				path: "index.js",
+				size: 100,
+			},
+			{
+				path: "huge.js",
+				size: DETECT_SOURCE_MAX_BYTES + 1,
+			},
+			{
+				path: "node_modules/discord.js/index.js",
+				size: 10,
+			},
+			...Array.from(
+				{
+					length: 60,
+				},
+				(_, index) => ({
+					path: `lib/deep/file${index}.js`,
+					size: 10,
+				}),
+			),
+		];
+
+		const wanted = detectWantedFiles(files);
+
+		expect(wanted.slice(0, 4)).toEqual([
+			"package.json",
+			".env.example",
+			"index.js",
+			"src/index.js",
+		]);
+		expect(wanted).not.toContain("package-lock.json");
+		expect(wanted).not.toContain("huge.js");
+		expect(wanted).not.toContain("node_modules/discord.js/index.js");
+		expect(wanted.length).toBe(2 + DETECT_SOURCE_FILE_LIMIT);
+	});
+});
+
+describe("the dependency readers", () => {
+	test("read requirement names and whether each one names a version", () => {
+		expect(parseRequirements("Discord.py[voice]==2.7.1\n-r base.txt\n# note\naiohttp ; python_version>'3'\n")).toEqual([
+			{
+				name: "discord-py",
+				pinned: true,
+			},
+			{
+				name: "aiohttp",
+				pinned: false,
+			},
+		]);
+	});
+
+	test("read project and poetry dependencies from pyproject.toml", () => {
+		expect(
+			parsePyprojectDependencies(
+				'[project]\ndependencies = ["hikari>=2", \'aiogram\']\n[tool.poetry.dependencies]\npython = "^3.12"\ntelethon = "*"\n',
+			),
+		).toEqual([
+			{
+				name: "hikari",
+				pinned: true,
+			},
+			{
+				name: "aiogram",
+				pinned: false,
+			},
+			{
+				name: "telethon",
+				pinned: false,
+			},
+		]);
+	});
+});