@serverkgg/bridge 0.0.21 → 0.1.1

package/src/bot/botVariables.test.ts

@@ -0,0 +1,193 @@
+import { describe, expect, test } from "bun:test";
+import {
+	DEFAULT_REPO_BRANCH,
+	DEPLOYMENT_ID_PATTERN,
+	isRootDirectory,
+	REPO_BRANCH_PATTERN,
+	REPO_REF_PATTERN,
+	REPO_URL_PATTERN,
+	ROOT_DIRECTORY_LENGTH_LIMIT,
+	readBotConfig,
+	SNAPSHOT_ID_PATTERN,
+} from "./botVariables";
+import {
+	BOT_PLATFORM,
+	BotPlatform,
+	DEPLOYMENT_ID,
+	GIT_TOKEN,
+	INSTALL_COMMAND,
+	REPO_BRANCH,
+	REPO_REF,
+	REPO_URL,
+	ROOT_DIRECTORY,
+	SNAPSHOT_ID,
+	START_COMMAND,
+} from "./detect";
+
+const SHA = "0123456789abcdef0123456789abcdef01234567";
+
+const contextWith = (variables: Record<string, string>, secrets: Record<string, string> = {}) => {
+	return {
+		variable: (key: string) => variables[key] ?? null,
+		secret: (key: string) => secrets[key] ?? null,
+	};
+};
+
+describe("readBotConfig", () => {
+	test("reads the platform-owned keys, trims them and takes the git token from the secrets", () => {
+		expect(
+			readBotConfig(
+				contextWith(
+					{
+						[BOT_PLATFORM]: BotPlatform.Telegram,
+						[REPO_URL]: " https://github.com/you/bot ",
+						[REPO_REF]: SHA,
+						[REPO_BRANCH]: "dev",
+						[START_COMMAND]: "node src/bot.js",
+						[INSTALL_COMMAND]: "npm install --legacy-peer-deps",
+						[ROOT_DIRECTORY]: " apps/bot ",
+						[DEPLOYMENT_ID]: "dep_a1b2c3d4",
+						[SNAPSHOT_ID]: "snap_1",
+						[GIT_TOKEN]: "ignored-in-variables",
+					},
+					{
+						[GIT_TOKEN]: "ghs_installation",
+					},
+				),
+			),
+		).toEqual({
+			platform: BotPlatform.Telegram,
+			repo: "https://github.com/you/bot",
+			ref: SHA,
+			branch: "dev",
+			startCommand: "node src/bot.js",
+			installCommand: "npm install --legacy-peer-deps",
+			rootDirectory: "apps/bot",
+			deployment: "dep_a1b2c3d4",
+			snapshot: "snap_1",
+			gitToken: "ghs_installation",
+		});
+	});
+
+	test("answers nothing for empty values, main for the branch and null for an unknown platform", () => {
+		expect(
+			readBotConfig(
+				contextWith({
+					[BOT_PLATFORM]: "slack",
+					[REPO_URL]: "   ",
+				}),
+			),
+		).toEqual({
+			platform: null,
+			repo: null,
+			ref: null,
+			branch: DEFAULT_REPO_BRANCH,
+			startCommand: null,
+			installCommand: null,
+			rootDirectory: null,
+			deployment: null,
+			snapshot: null,
+			gitToken: null,
+		});
+	});
+});
+
+describe("the patterns", () => {
+	test("pin a ref only to a full sha-1 or sha-256", () => {
+		expect(REPO_REF_PATTERN.test(SHA)).toBe(true);
+		expect(REPO_REF_PATTERN.test("a".repeat(64))).toBe(true);
+		expect(REPO_REF_PATTERN.test(SHA.slice(0, 12))).toBe(false);
+		expect(REPO_REF_PATTERN.test(SHA.toUpperCase())).toBe(false);
+		expect(REPO_REF_PATTERN.test("main")).toBe(false);
+	});
+
+	test("keep deployment and snapshot ids to url-safe words", () => {
+		for (const pattern of [
+			DEPLOYMENT_ID_PATTERN,
+			SNAPSHOT_ID_PATTERN,
+		]) {
+			expect(pattern.test("dep_a1b2c3d4")).toBe(true);
+			expect(pattern.test("0f8e-uuid-like")).toBe(true);
+			expect(pattern.test("a".repeat(65))).toBe(false);
+			expect(pattern.test("../escape")).toBe(false);
+			expect(pattern.test("")).toBe(false);
+		}
+	});
+
+	test("take a root directory only as a plain relative folder path, the shape the api enforces", () => {
+		for (const root of [
+			"bot",
+			"apps/bot",
+			"packages/my-bot_v2",
+			"src.bot/v1.2",
+			"a".repeat(ROOT_DIRECTORY_LENGTH_LIMIT),
+		]) {
+			expect(isRootDirectory(root)).toBe(true);
+		}
+
+		for (const root of [
+			"",
+			"/bot",
+			"./bot",
+			".bot",
+			"..",
+			"apps/../bot",
+			"apps/./bot",
+			"apps/..",
+			"apps//bot",
+			"apps/bot/",
+			"apps\\bot",
+			"apps\u0000bot",
+			"apps bot",
+			"a".repeat(ROOT_DIRECTORY_LENGTH_LIMIT + 1),
+		]) {
+			expect(isRootDirectory(root)).toBe(false);
+		}
+	});
+
+	test("accept https repositories and git branch names", () => {
+		expect(REPO_URL_PATTERN.test("https://github.com/you/bot.git")).toBe(true);
+		expect(REPO_URL_PATTERN.test("https://user:pass@github.com/you/bot")).toBe(false);
+		expect(REPO_URL_PATTERN.test("git@github.com:you/bot.git")).toBe(false);
+		expect(REPO_BRANCH_PATTERN.test("feature/new-bot")).toBe(true);
+		expect(REPO_BRANCH_PATTERN.test("-rf")).toBe(false);
+	});
+
+	test("accept only branch names git check-ref-format accepts", () => {
+		for (const branch of [
+			"main",
+			"release-1.2",
+			"a.locked",
+			"deps/HEAD",
+			"x".repeat(128),
+		]) {
+			expect(REPO_BRANCH_PATTERN.test(branch), branch).toBe(true);
+		}
+
+		for (const branch of [
+			"HEAD",
+			"a..b",
+			"a//b",
+			"/main",
+			"main/",
+			"main.",
+			"a/.hidden",
+			".hidden",
+			"main.lock",
+			"a.lock/b",
+			"a@{1}",
+			"a\\b",
+			"a~1",
+			"a^2",
+			"a:b",
+			"a?b",
+			"a*b",
+			"a[b",
+			"with space",
+			"tab\there",
+			"x".repeat(129),
+		]) {
+			expect(REPO_BRANCH_PATTERN.test(branch), JSON.stringify(branch)).toBe(false);
+		}
+	});
+});

package/src/bot/botVariables.ts

@@ -0,0 +1,73 @@
+import type { BridgeContext } from "../context";
+import {
+	BOT_PLATFORM,
+	type BotPlatform,
+	DEPLOYMENT_ID,
+	GIT_TOKEN,
+	INSTALL_COMMAND,
+	isBotPlatform,
+	REPO_BRANCH,
+	REPO_REF,
+	REPO_URL,
+	ROOT_DIRECTORY,
+	SNAPSHOT_ID,
+	START_COMMAND,
+} from "./detect";
+
+export const REPO_URL_PATTERN = /^https:\/\/[^\s@/]+\/\S+$/;
+
+export const REPO_BRANCH_PATTERN =
+	/^(?!HEAD$)(?!.*(?:\.\.|\/\/|\/\.|\.lock(?:\/|$)|[/.]$))[A-Za-z0-9_][A-Za-z0-9._/-]{0,127}$/;
+
+export const REPO_REF_PATTERN = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+
+export const DEPLOYMENT_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+
+export const SNAPSHOT_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+
+export const ROOT_DIRECTORY_PATTERN =
+	/^(?![./])(?!.*(?:^|\/)\.{1,2}(?:\/|$))(?!.*\/\/)[A-Za-z0-9._\-/]*[A-Za-z0-9._-]$/;
+
+export const ROOT_DIRECTORY_LENGTH_LIMIT = 255;
+
+export const DEFAULT_REPO_BRANCH = "main";
+
+export const isRootDirectory = (value: string) => {
+	return value.length <= ROOT_DIRECTORY_LENGTH_LIMIT && ROOT_DIRECTORY_PATTERN.test(value);
+};
+
+export interface BotConfig {
+	platform: BotPlatform | null;
+	repo: string | null;
+	ref: string | null;
+	branch: string;
+	startCommand: string | null;
+	installCommand: string | null;
+	rootDirectory: string | null;
+	deployment: string | null;
+	snapshot: string | null;
+	gitToken: string | null;
+}
+
+const present = (value: string | null) => {
+	const trimmed = value?.trim() ?? "";
+
+	return trimmed.length === 0 ? null : trimmed;
+};
+
+export const readBotConfig = (context: Pick<BridgeContext, "variable" | "secret">): BotConfig => {
+	const platform = present(context.variable(BOT_PLATFORM));
+
+	return {
+		platform: isBotPlatform(platform) ? platform : null,
+		repo: present(context.variable(REPO_URL)),
+		ref: present(context.variable(REPO_REF)),
+		branch: present(context.variable(REPO_BRANCH)) ?? DEFAULT_REPO_BRANCH,
+		startCommand: present(context.variable(START_COMMAND)),
+		installCommand: present(context.variable(INSTALL_COMMAND)),
+		rootDirectory: present(context.variable(ROOT_DIRECTORY)),
+		deployment: present(context.variable(DEPLOYMENT_ID)),
+		snapshot: present(context.variable(SNAPSHOT_ID)),
+		gitToken: present(context.secret(GIT_TOKEN)),
+	};
+};

package/src/bot/detect/botFramework.ts

@@ -0,0 +1,23 @@
+export enum BotFramework {
+	DiscordJs = "discord-js",
+	Eris = "eris",
+	OceanicJs = "oceanic-js",
+	Grammy = "grammy",
+	Telegraf = "telegraf",
+	NodeTelegramBotApi = "node-telegram-bot-api",
+	DiscordPy = "discord-py",
+	PyCord = "py-cord",
+	Nextcord = "nextcord",
+	Disnake = "disnake",
+	Hikari = "hikari",
+	PythonTelegramBot = "python-telegram-bot",
+	Aiogram = "aiogram",
+	Pyrogram = "pyrogram",
+	Telethon = "telethon",
+}
+
+const FRAMEWORKS: ReadonlySet<string> = new Set(Object.values(BotFramework));
+
+export const isBotFramework = (value: string | null | undefined): value is BotFramework => {
+	return typeof value === "string" && FRAMEWORKS.has(value);
+};

package/src/bot/detect/botFrameworks.ts

@@ -0,0 +1,198 @@
+import { BotFramework } from "./botFramework";
+import { BotPlatform } from "./botPlatform";
+import { BotRuntime } from "./botRuntime";
+
+export interface BotFrameworkSpec {
+	framework: BotFramework;
+	name: string;
+	runtime: BotRuntime;
+	platform: BotPlatform;
+	packages: readonly string[];
+	modules: readonly string[];
+}
+
+export const BOT_FRAMEWORKS: readonly BotFrameworkSpec[] = [
+	{
+		framework: BotFramework.DiscordJs,
+		name: "discord.js",
+		runtime: BotRuntime.Node,
+		platform: BotPlatform.Discord,
+		packages: [
+			"discord.js",
+		],
+		modules: [
+			"discord.js",
+		],
+	},
+	{
+		framework: BotFramework.Eris,
+		name: "Eris",
+		runtime: BotRuntime.Node,
+		platform: BotPlatform.Discord,
+		packages: [
+			"eris",
+		],
+		modules: [
+			"eris",
+		],
+	},
+	{
+		framework: BotFramework.OceanicJs,
+		name: "Oceanic.js",
+		runtime: BotRuntime.Node,
+		platform: BotPlatform.Discord,
+		packages: [
+			"oceanic.js",
+		],
+		modules: [
+			"oceanic.js",
+		],
+	},
+	{
+		framework: BotFramework.Grammy,
+		name: "grammY",
+		runtime: BotRuntime.Node,
+		platform: BotPlatform.Telegram,
+		packages: [
+			"grammy",
+		],
+		modules: [
+			"grammy",
+		],
+	},
+	{
+		framework: BotFramework.Telegraf,
+		name: "Telegraf",
+		runtime: BotRuntime.Node,
+		platform: BotPlatform.Telegram,
+		packages: [
+			"telegraf",
+		],
+		modules: [
+			"telegraf",
+		],
+	},
+	{
+		framework: BotFramework.NodeTelegramBotApi,
+		name: "node-telegram-bot-api",
+		runtime: BotRuntime.Node,
+		platform: BotPlatform.Telegram,
+		packages: [
+			"node-telegram-bot-api",
+		],
+		modules: [
+			"node-telegram-bot-api",
+		],
+	},
+	{
+		framework: BotFramework.DiscordPy,
+		name: "discord.py",
+		runtime: BotRuntime.Python,
+		platform: BotPlatform.Discord,
+		packages: [
+			"discord.py",
+			"discord",
+		],
+		modules: [
+			"discord",
+		],
+	},
+	{
+		framework: BotFramework.PyCord,
+		name: "Pycord",
+		runtime: BotRuntime.Python,
+		platform: BotPlatform.Discord,
+		packages: [
+			"py-cord",
+		],
+		modules: [],
+	},
+	{
+		framework: BotFramework.Nextcord,
+		name: "nextcord",
+		runtime: BotRuntime.Python,
+		platform: BotPlatform.Discord,
+		packages: [
+			"nextcord",
+		],
+		modules: [
+			"nextcord",
+		],
+	},
+	{
+		framework: BotFramework.Disnake,
+		name: "disnake",
+		runtime: BotRuntime.Python,
+		platform: BotPlatform.Discord,
+		packages: [
+			"disnake",
+		],
+		modules: [
+			"disnake",
+		],
+	},
+	{
+		framework: BotFramework.Hikari,
+		name: "hikari",
+		runtime: BotRuntime.Python,
+		platform: BotPlatform.Discord,
+		packages: [
+			"hikari",
+		],
+		modules: [
+			"hikari",
+		],
+	},
+	{
+		framework: BotFramework.PythonTelegramBot,
+		name: "python-telegram-bot",
+		runtime: BotRuntime.Python,
+		platform: BotPlatform.Telegram,
+		packages: [
+			"python-telegram-bot",
+		],
+		modules: [
+			"telegram",
+		],
+	},
+	{
+		framework: BotFramework.Aiogram,
+		name: "aiogram",
+		runtime: BotRuntime.Python,
+		platform: BotPlatform.Telegram,
+		packages: [
+			"aiogram",
+		],
+		modules: [
+			"aiogram",
+		],
+	},
+	{
+		framework: BotFramework.Pyrogram,
+		name: "Pyrogram",
+		runtime: BotRuntime.Python,
+		platform: BotPlatform.Telegram,
+		packages: [
+			"pyrogram",
+		],
+		modules: [
+			"pyrogram",
+		],
+	},
+	{
+		framework: BotFramework.Telethon,
+		name: "Telethon",
+		runtime: BotRuntime.Python,
+		platform: BotPlatform.Telegram,
+		packages: [
+			"telethon",
+		],
+		modules: [
+			"telethon",
+		],
+	},
+];
+
+export const botFrameworkSpec = (framework: BotFramework): BotFrameworkSpec | null => {
+	return BOT_FRAMEWORKS.find((spec) => spec.framework === framework) ?? null;
+};

package/src/bot/detect/botInspectWarning.ts

@@ -0,0 +1,15 @@
+export enum BotInspectWarning {
+	NoLockfile = "no-lockfile",
+	NoStart = "no-start",
+	NoManifest = "no-manifest",
+	TypescriptEntry = "typescript-entry",
+	EnvCommitted = "env-committed",
+	NodeModulesCommitted = "node-modules-committed",
+	VenvCommitted = "venv-committed",
+	UnpinnedRequirements = "unpinned-requirements",
+	TwoRuntimes = "two-runtimes",
+	TwoPlatforms = "two-platforms",
+	ManifestDisagrees = "manifest-disagrees",
+	ManifestInvalid = "manifest-invalid",
+	ReservedEnvKey = "reserved-env-key",
+}

package/src/bot/detect/botPackageManager.ts

@@ -0,0 +1,6 @@
+export enum BotPackageManager {
+	Npm = "npm",
+	Pnpm = "pnpm",
+	Yarn = "yarn",
+	Pip = "pip",
+}

package/src/bot/detect/botPlatform.ts

@@ -0,0 +1,10 @@
+export enum BotPlatform {
+	Discord = "discord",
+	Telegram = "telegram",
+}
+
+const PLATFORMS: ReadonlySet<string> = new Set(Object.values(BotPlatform));
+
+export const isBotPlatform = (value: string | null | undefined): value is BotPlatform => {
+	return typeof value === "string" && PLATFORMS.has(value);
+};

package/src/bot/detect/botRuntime.ts

@@ -0,0 +1,15 @@
+export enum BotRuntime {
+	Node = "node",
+	Python = "python",
+}
+
+export const BOT_RUNTIME_PACKAGES: Readonly<Record<BotRuntime, string>> = {
+	[BotRuntime.Node]: "bot-node",
+	[BotRuntime.Python]: "bot-python",
+};
+
+const RUNTIMES: ReadonlySet<string> = new Set(Object.values(BotRuntime));
+
+export const isBotRuntime = (value: string | null | undefined): value is BotRuntime => {
+	return typeof value === "string" && RUNTIMES.has(value);
+};

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

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test";
+import { BotPlatform } from "./botPlatform";
+import { discordApplicationId, findBotToken, platformOfKey, platformOfToken, telegramBotId } from "./botToken";
+
+const DISCORD_ID = "1136470478027245683";
+
+const DISCORD_TOKEN = `${btoa(DISCORD_ID).replaceAll("=", "")}.GxYz12.${"a".repeat(38)}`;
+
+const TELEGRAM_TOKEN = "7123456789:AAHdqTcvCH1vGWJxfSeofSAs0K5PALDsaw";
+
+describe("token shapes", () => {
+	test("read the ids hidden in each platform's token", () => {
+		expect(telegramBotId(TELEGRAM_TOKEN)).toBe("7123456789");
+		expect(discordApplicationId(` ${DISCORD_TOKEN} `)).toBe(DISCORD_ID);
+		expect(platformOfToken(TELEGRAM_TOKEN)).toBe(BotPlatform.Telegram);
+		expect(platformOfToken(DISCORD_TOKEN)).toBe(BotPlatform.Discord);
+	});
+
+	test("do not mistake a JSON web token or a random key for a bot token", () => {
+		const jwt = `${btoa('{"alg":"HS256"}').replaceAll("=", "")}.eyJzdWIiOiIxIn0.${"b".repeat(43)}`;
+
+		expect(platformOfToken(jwt)).toBeNull();
+		expect(platformOfToken("sk-live-0123456789abcdef")).toBeNull();
+		expect(platformOfToken("")).toBeNull();
+	});
+
+	test("read the platform a key name points at", () => {
+		expect(platformOfKey("DISCORD_TOKEN")).toBe(BotPlatform.Discord);
+		expect(platformOfKey("my_telegram_chat")).toBe(BotPlatform.Telegram);
+		expect(platformOfKey("TOKEN")).toBeNull();
+	});
+});
+
+describe("findBotToken", () => {
+	test("prefers the tutorial names, then any value shaped like the platform's token", () => {
+		expect(
+			findBotToken(BotPlatform.Discord, {
+				variables: {},
+				secrets: {
+					OTHER: DISCORD_TOKEN,
+					DISCORD_TOKEN,
+				},
+			}),
+		).toEqual({
+			key: "DISCORD_TOKEN",
+			value: DISCORD_TOKEN,
+		});
+		expect(
+			findBotToken(BotPlatform.Telegram, {
+				variables: {
+					TG: TELEGRAM_TOKEN,
+				},
+				secrets: {},
+			}),
+		).toEqual({
+			key: "TG",
+			value: TELEGRAM_TOKEN,
+		});
+	});
+
+	test("ignores a named key whose value is not the platform's token", () => {
+		expect(
+			findBotToken(BotPlatform.Telegram, {
+				variables: {},
+				secrets: {
+					TELEGRAM_TOKEN: "not-a-token",
+				},
+			}),
+		).toBeNull();
+	});
+});