@serverkgg/bridge 0.1.10 → 0.1.12

package/src/bot/detect/detect.ts

@@ -2,15 +2,16 @@ import type { BotFramework } from "./botFramework";
 import { BOT_FRAMEWORKS, type BotFrameworkSpec, botFrameworkSpec } from "./botFrameworks";
 import { BotInspectWarning } from "./botInspectWarning";
 import { BotPackageManager } from "./botPackageManager";
-import type { BotPlatform } from "./botPlatform";
+import { BotPlatform } from "./botPlatform";
 import { BOT_RUNTIME_PACKAGES, BotRuntime } from "./botRuntime";
 import { BOT_TOKEN_KEYS, platformOfKey } from "./botToken";
+import { nodeLtsMajorOf } from "./detectedVersion";
 import type { DetectEntry, DetectedCommand, DetectedEnvKey, DetectInput, DetectResult } from "./detectResult";
 import { DETECT_TABLE, type DetectVersionFile } from "./detectTable";
 import { ENV_EXAMPLE_FILES, ENV_FILE, isSecretEnvFile, parseEnvExample } from "./envExample";
 import { isEnvKey } from "./envKey";
 import { isNodeSource, isPythonSource, scanEnvKeys } from "./envScan";
-import { BOT_PROTECTED_KEYS, BOT_PROVIDED_KEYS, isReservedBotKey } from "./keys";
+import { BOT_PROTECTED_KEYS, BOT_PROVIDED_KEYS, isReservedBotKey, PORT } from "./keys";
 import { isSensitiveKey } from "./sensitiveKey";
 import { parseServerkJson, SERVERK_JSON, type ServerkJson } from "./serverkJson";
 
@@ -79,6 +80,8 @@ const TOKEN_KEY = /TOKEN/i;
 
 const BOT_KEY = /BOT/i;
 
+const WEBHOOK_KEY = /WEBHOOK/i;
+
 const NODE_IMPORT = /(?:\brequire\s*\(\s*|\bfrom\s+|\bimport\s*\(\s*|\bimport\s+)(["'])([^"'\n]+)\1/g;
 
 const PYTHON_IMPORT = /^[ \t]*(?:from[ \t]+([A-Za-z_]\w*)|import[ \t]+([A-Za-z_]\w*))/gm;
@@ -192,14 +195,16 @@ const START_FILES: readonly string[] = [
 ];
 
 const FIXED_FILES: readonly string[] = [
-	DETECT_TABLE.node.manifest,
-	REQUIREMENTS_FILE,
-	PYPROJECT_FILE,
-	DETECT_TABLE.procfile.file,
-	SERVERK_JSON,
-	...ENV_EXAMPLE_FILES,
-	...DETECT_TABLE.node.versionFiles.map((entry) => entry.file),
-	...DETECT_TABLE.python.versionFiles.map((entry) => entry.file),
+	...new Set([
+		DETECT_TABLE.node.manifest,
+		REQUIREMENTS_FILE,
+		PYPROJECT_FILE,
+		DETECT_TABLE.procfile.file,
+		SERVERK_JSON,
+		...ENV_EXAMPLE_FILES,
+		...DETECT_TABLE.node.versionFiles.map((entry) => entry.file),
+		...DETECT_TABLE.python.versionFiles.map((entry) => entry.file),
+	]),
 ];
 
 const sourceRank = (path: string) => {
@@ -587,7 +592,11 @@ const nodeBuildOf = (packageJson: PackageJson | null, manager: string): Detected
 	};
 };
 
-const versionFromFile = (text: string, spec: DetectVersionFile): string | null => {
+const versionFromFile = (
+	text: string,
+	spec: DetectVersionFile,
+	aliasOf: (value: string) => string | null,
+): string | null => {
 	for (const raw of text.split("\n")) {
 		let line = raw.trim();
 
@@ -623,7 +632,7 @@ const versionFromFile = (text: string, spec: DetectVersionFile): string | null =
 			line = line.slice(spec.prefix.length);
 		}
 
-		return VERSION_NUMBER.exec(line)?.[1] ?? null;
+		return VERSION_NUMBER.exec(line)?.[1] ?? aliasOf(line);
 	}
 
 	return null;
@@ -633,6 +642,7 @@ const versionFromFiles = (
 	specs: readonly DetectVersionFile[],
 	read: (path: string) => string | null,
 	parts: number,
+	aliasOf: (value: string) => string | null = () => null,
 ): string | null => {
 	for (const spec of specs) {
 		const text = read(spec.file);
@@ -641,7 +651,7 @@ const versionFromFiles = (
 			continue;
 		}
 
-		const version = versionFromFile(text, spec);
+		const version = versionFromFile(text, spec, aliasOf);
 
 		if (version !== null) {
 			return version.split(".").slice(0, parts).join(".");
@@ -731,7 +741,7 @@ const nodeRequirementOf = (
 		}
 	}
 
-	const version = versionFromFiles(DETECT_TABLE.node.versionFiles, read, 1);
+	const version = versionFromFiles(DETECT_TABLE.node.versionFiles, read, 1, nodeLtsMajorOf);
 
 	return version === null
 		? null
@@ -845,6 +855,19 @@ const committedWarnings = (paths: ReadonlySet<string>, warnings: Set<BotInspectW
 	}
 };
 
+const webPortWarning = (
+	platform: BotPlatform | null,
+	env: readonly DetectedEnvKey[],
+	warnings: Set<BotInspectWarning>,
+) => {
+	const keys = env.map((entry) => entry.key);
+	const webhook = platform !== BotPlatform.Discord && keys.some((key) => WEBHOOK_KEY.test(key));
+
+	if (keys.includes(PORT) || webhook) {
+		warnings.add(BotInspectWarning.WebPort);
+	}
+};
+
 interface EnvCollector {
 	add(key: string, source: string, sensitive: boolean | null, example: string | null): void;
 	entries: DetectedEnvKey[];
@@ -1165,6 +1188,8 @@ export const detect = (input: DetectInput): DetectResult => {
 	);
 	const platform = platformOf(serverk, framework, candidates, keyPlatforms, warnings);
 
+	webPortWarning(platform, env.entries, warnings);
+
 	return {
 		runtime,
 		package: runtime ? BOT_RUNTIME_PACKAGES[runtime] : null,

package/src/bot/detect/detectTable.ts

@@ -230,6 +230,10 @@ export const DETECT_TABLE: DetectTable = {
 				file: ".tool-versions",
 				tool: "nodejs",
 			},
+			{
+				file: ".tool-versions",
+				tool: "node",
+			},
 		],
 		defaultVersion: "24",
 	},

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

@@ -0,0 +1,160 @@
+import { describe, expect, it } from "bun:test";
+import { BotInspectWarning } from "./botInspectWarning";
+import { BotRuntime } from "./botRuntime";
+import { detect } from "./detect";
+import { nodeLtsMajorOf } from "./detectedVersion";
+import { DETECT_TABLE } from "./detectTable";
+
+const DISCORD_NODE = {
+	"package.json": JSON.stringify({
+		name: "discord-bot",
+		main: "index.js",
+		dependencies: {
+			"discord.js": "^14.27.0",
+		},
+	}),
+	"index.js": 'import { Client } from "discord.js";\nawait client.login(process.env.DISCORD_TOKEN);\n',
+};
+
+const resultOf = (files: Record<string, string>) => {
+	const contents = {
+		...DISCORD_NODE,
+		...files,
+	};
+
+	return detect({
+		files: Object.keys(contents).map((path) => ({
+			path,
+		})),
+		contents,
+	});
+};
+
+const LTS_CASES: readonly {
+	alias: string;
+	major: string | null;
+}[] = [
+	{
+		alias: "lts/iron",
+		major: "20",
+	},
+	{
+		alias: "LTS/Hydrogen",
+		major: "18",
+	},
+	{
+		alias: "lts/jod",
+		major: "22",
+	},
+	{
+		alias: "lts-krypton",
+		major: "24",
+	},
+	{
+		alias: " lts/argon ",
+		major: "4",
+	},
+	{
+		alias: "lts/*",
+		major: null,
+	},
+	{
+		alias: "lts/-1",
+		major: null,
+	},
+	{
+		alias: "lts",
+		major: null,
+	},
+	{
+		alias: "lts/unknown",
+		major: null,
+	},
+	{
+		alias: "lts/constructor",
+		major: null,
+	},
+	{
+		alias: "node",
+		major: null,
+	},
+];
+
+describe("nodeLtsMajorOf", () => {
+	for (const item of LTS_CASES) {
+		it(`reads ${item.alias} as ${item.major ?? "no fixed major"}`, () => {
+			expect(nodeLtsMajorOf(item.alias)).toBe(item.major);
+		});
+	}
+});
+
+describe("detect", () => {
+	it("reads the Node major an .nvmrc names by its LTS codename", () => {
+		expect(
+			resultOf({
+				".nvmrc": "lts/iron\n",
+			}).nodeVersion,
+		).toBe("20");
+		expect(
+			resultOf({
+				".nvmrc": "LTS/Hydrogen\n",
+			}).nodeVersion,
+		).toBe("18");
+		expect(
+			resultOf({
+				".nvmrc": "lts/*\n",
+			}).nodeVersion,
+		).toBeNull();
+	});
+
+	it("warns when an LTS codename names a major the image does not run", () => {
+		const result = resultOf({
+			".nvmrc": "lts/hydrogen\n",
+		});
+
+		expect(DETECT_TABLE.node.defaultVersion).not.toBe("18");
+		expect(result.warnings).toContain(BotInspectWarning.NodeVersionUnmet);
+	});
+
+	it("reads the Node version from .tool-versions under mise's node and asdf's nodejs", () => {
+		expect(
+			resultOf({
+				".tool-versions": "node 20.11.0\n",
+			}).nodeVersion,
+		).toBe("20");
+		expect(
+			resultOf({
+				".tool-versions": "nodejs 20.11.0\n",
+			}).nodeVersion,
+		).toBe("20");
+		expect(
+			resultOf({
+				".tool-versions": "python 3.12.1\nnode lts/jod\n",
+			}).nodeVersion,
+		).toBe("22");
+	});
+
+	it("leaves the Python version untouched by a Node LTS codename", () => {
+		const result = detect({
+			files: [
+				{
+					path: "requirements.txt",
+				},
+				{
+					path: "main.py",
+				},
+				{
+					path: ".python-version",
+				},
+			],
+			contents: {
+				"requirements.txt": "python-telegram-bot==21.11.1\n",
+				"main.py": "from telegram.ext import Application\n",
+				".python-version": "lts/iron\n",
+			},
+		});
+
+		expect(result.runtime).toBe(BotRuntime.Python);
+		expect(result.pythonVersion).toBeNull();
+	});
+});

package/src/bot/detect/detectedVersion.ts

@@ -1,5 +1,60 @@
 export const DETECTED_VERSION_PATTERN = /^\d+(?:\.\d+)?$/;
 
+const NODE_LTS_MAJORS: ReadonlyMap<string, string> = new Map([
+	[
+		"argon",
+		"4",
+	],
+	[
+		"boron",
+		"6",
+	],
+	[
+		"carbon",
+		"8",
+	],
+	[
+		"dubnium",
+		"10",
+	],
+	[
+		"erbium",
+		"12",
+	],
+	[
+		"fermium",
+		"14",
+	],
+	[
+		"gallium",
+		"16",
+	],
+	[
+		"hydrogen",
+		"18",
+	],
+	[
+		"iron",
+		"20",
+	],
+	[
+		"jod",
+		"22",
+	],
+	[
+		"krypton",
+		"24",
+	],
+]);
+
+const NODE_LTS_ALIAS = /^lts[/-]([a-z]+)$/i;
+
 export const isDetectedVersion = (value: string | null): value is string => {
 	return value !== null && DETECTED_VERSION_PATTERN.test(value);
 };
+
+export const nodeLtsMajorOf = (alias: string): string | null => {
+	const codename = NODE_LTS_ALIAS.exec(alias.trim())?.[1];
+
+	return codename === undefined ? null : (NODE_LTS_MAJORS.get(codename.toLowerCase()) ?? null);
+};

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

@@ -69,6 +69,10 @@ describe("isSecretEnvFile", () => {
 			name: ".env.dist",
 			secret: false,
 		},
+		{
+			name: "sample.env",
+			secret: false,
+		},
 		{
 			name: ".env.defaults",
 			secret: false,

package/src/bot/detect/envExample.ts

@@ -7,6 +7,7 @@ export const ENV_EXAMPLE_FILES: readonly string[] = [
 	".env-example",
 	".env-sample",
 	".env.dist",
+	"sample.env",
 ];
 
 const ENV_TEMPLATE_FILES: ReadonlySet<string> = new Set([

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

@@ -33,6 +33,116 @@ describe("scanEnvKeys", () => {
 		]);
 	});
 
+	it("finds a Bun.env property read", () => {
+		expect(scanEnvKeys("src/index.ts", "const token = Bun.env.DISCORD_TOKEN;")).toEqual([
+			"DISCORD_TOKEN",
+		]);
+	});
+
+	it("finds a Bun.env bracket read", () => {
+		expect(scanEnvKeys("src/index.ts", 'const guildId = Bun.env["GUILD_ID"] ?? "";')).toEqual([
+			"GUILD_ID",
+		]);
+	});
+
+	it("finds names destructured from Bun.env", () => {
+		expect(scanEnvKeys("src/config.ts", "const { DISCORD_TOKEN, CLIENT_ID } = Bun.env;")).toEqual([
+			"DISCORD_TOKEN",
+			"CLIENT_ID",
+		]);
+	});
+
+	it("finds environs reads, bare and typed", () => {
+		expect(
+			scanEnvKeys(
+				"tgbot/config.py",
+				[
+					"from environs import Env",
+					"",
+					"env = Env()",
+					"env.read_env(path)",
+					'BOT_TOKEN = env.str("BOT_TOKEN")',
+					'ADMIN_ID = env.int("ADMIN_ID")',
+					'admin_ids = env.list("ADMINS", subcast=int)',
+					'use_redis = env.bool("USE_REDIS")',
+					'rate = env.float("RATE_LIMIT", 1.5)',
+					'webhook = env.url("WEBHOOK_URL")',
+					'extra = env.json("EXTRA_OPTIONS")',
+					"SECRET_KEY = env('SECRET_KEY')",
+				].join("\n"),
+			),
+		).toEqual([
+			"BOT_TOKEN",
+			"ADMIN_ID",
+			"ADMINS",
+			"USE_REDIS",
+			"RATE_LIMIT",
+			"WEBHOOK_URL",
+			"EXTRA_OPTIONS",
+			"SECRET_KEY",
+		]);
+	});
+
+	it("finds python-decouple reads", () => {
+		expect(
+			scanEnvKeys(
+				"bot/settings.py",
+				[
+					"import decouple",
+					"from decouple import config",
+					"",
+					'TOKEN = config("TOKEN")',
+					'ADMIN_ID = config("ADMIN_ID", cast=int)',
+					'DEBUG = decouple.config("DEBUG", default=False, cast=bool)',
+				].join("\n"),
+			),
+		).toEqual([
+			"TOKEN",
+			"ADMIN_ID",
+			"DEBUG",
+		]);
+	});
+
+	it("orders names by where the file reads them across os and environs", () => {
+		expect(
+			scanEnvKeys(
+				"bot/config.py",
+				[
+					"import os",
+					"from environs import Env",
+					"",
+					"env = Env()",
+					'BOT_TOKEN = env.str("BOT_TOKEN")',
+					'REDIS_URL = os.getenv("REDIS_URL")',
+					'ADMIN_ID = env.int("ADMIN_ID")',
+				].join("\n"),
+			),
+		).toEqual([
+			"BOT_TOKEN",
+			"REDIS_URL",
+			"ADMIN_ID",
+		]);
+	});
+
+	it("reads no key from calls that only look like environs or decouple", () => {
+		expect(
+			scanEnvKeys(
+				"bot/main.py",
+				[
+					"env = {}",
+					'env["x"] = 1',
+					'value = env["x"]',
+					'logger.config("level")',
+					'logger.config("LEVEL")',
+					'config("level")',
+					'self.env.str("NOPE")',
+					'client.getenv("NOPE")',
+					'cfg.environ.get("NOPE")',
+				].join("\n"),
+			),
+		).toEqual([]);
+	});
+
 	it("reads nothing from files that are not code", () => {
 		expect(scanEnvKeys("README.md", "process.env.A")).toEqual([]);
 	});

package/src/bot/detect/envScan.ts

@@ -13,12 +13,14 @@ export const PYTHON_SOURCE_EXTENSIONS: readonly string[] = [
 
 const NAME = "([A-Za-z_][A-Za-z0-9_]*)";
 
+const UPPER_NAME = "([A-Z_][A-Z0-9_]*)";
+
 const NODE_PATTERNS: readonly RegExp[] = [
-	new RegExp(`\\bprocess\\.env\\.${NAME}`, "g"),
-	new RegExp(`\\bprocess\\.env\\[\\s*["'\`]${NAME}["'\`]\\s*\\]`, "g"),
+	new RegExp(`\\b(?:process|Bun)\\.env\\.${NAME}`, "g"),
+	new RegExp(`\\b(?:process|Bun)\\.env\\[\\s*["'\`]${NAME}["'\`]\\s*\\]`, "g"),
 ];
 
-const NODE_DESTRUCTURE = /\{([^{}]{1,2000})\}\s*=\s*process\.env\b/g;
+const NODE_DESTRUCTURE = /\{([^{}]{1,2000})\}\s*=\s*(?:process|Bun)\.env\b/g;
 
 const DESTRUCTURED_NAME = /^\s*([A-Za-z_][A-Za-z0-9_]*)/;
 
@@ -26,6 +28,8 @@ const PYTHON_PATTERNS: readonly RegExp[] = [
 	new RegExp(`(?<![\\w.])(?:os\\.)?environ\\[\\s*["']${NAME}["']\\s*\\]`, "g"),
 	new RegExp(`(?<![\\w.])(?:os\\.)?environ\\.get\\(\\s*["']${NAME}["']`, "g"),
 	new RegExp(`(?<![\\w.])(?:os\\.)?getenv\\(\\s*["']${NAME}["']`, "g"),
+	new RegExp(`(?<![\\w.])env(?:\\.\\w+)?\\(\\s*["']${UPPER_NAME}["']`, "g"),
+	new RegExp(`(?<![\\w.])(?:decouple\\.)?config\\(\\s*["']${UPPER_NAME}["']`, "g"),
 ];
 
 interface Found {

package/src/protocol/bridgeCrash.ts

@@ -34,7 +34,7 @@ export interface BridgeCrashEvidence {
 
 export const BRIDGE_CRASH_EVIDENCE: readonly BridgeCrashEvidence[] = [
 	{
-		name: BridgeEventName.ServerCrashed,
+		name: BridgeEventName.OutOfMemory,
 		cause: BridgeCrashCause.OutOfMemory,
 	},
 	{
@@ -101,6 +101,10 @@ export const BRIDGE_CRASH_EVIDENCE: readonly BridgeCrashEvidence[] = [
 		name: BridgeEventName.RateLimited,
 		cause: BridgeCrashCause.RateLimited,
 	},
+	{
+		name: BridgeEventName.ServerCrashed,
+		cause: BridgeCrashCause.Unknown,
+	},
 ];
 
 const BRIDGE_CRASH_EVIDENCE_NAMES: ReadonlySet<string> = new Set(BRIDGE_CRASH_EVIDENCE.map((entry) => entry.name));

package/src/protocol/bridgeEvents.ts

@@ -23,6 +23,7 @@ export enum BridgeEventName {
 	ModpackInstalled = "ModpackInstalled",
 	ModpackRemoved = "ModpackRemoved",
 	ModpackSelected = "ModpackSelected",
+	OutOfMemory = "OutOfMemory",
 	PlayerAdvanced = "PlayerAdvanced",
 	PlayerBanned = "PlayerBanned",
 	PlayerChanged = "PlayerChanged",

package/src/runtime/bridgeEvents.test.ts

@@ -291,7 +291,7 @@ describe("the crash record the ring builds", () => {
 			detail: "class file version 65",
 		});
 
-		ring.emit(BridgeEventName.ServerCrashed, {
+		ring.emit(BridgeEventName.OutOfMemory, {
 			error: "java.lang.OutOfMemoryError",
 		});
 
@@ -303,6 +303,57 @@ describe("the crash record the ring builds", () => {
 		});
 	});
 
+	it("ends a lone fatal crash line as unknown, in one record that carries the last line", () => {
+		const ring = idleRing();
+
+		ring.emit(BridgeEventName.ServerCrashed);
+
+		ring.crash(
+			crashRecord({
+				exitCode: 139,
+				lastLine: "Segmentation fault (core dumped)",
+			}),
+		);
+
+		expect(ring.drain(0).events).toEqual([
+			{
+				seq: 1,
+				event: BridgeEventName.ServerCrashed,
+				payload: {
+					cause: "unknown",
+					phase: "running",
+					exitCode: "139",
+					restarting: "no",
+					looping: "no",
+					restarts: "0",
+					uptimeSeconds: "12",
+					lastLine: "Segmentation fault (core dumped)",
+				},
+			},
+		]);
+	});
+
+	it("names a corrupt world over the fatal crash line of the same run", () => {
+		const ring = idleRing();
+
+		ring.emit(BridgeEventName.WorldCorrupt);
+		ring.emit(BridgeEventName.ServerCrashed);
+
+		ring.crash(
+			crashRecord({
+				lastLine: "Aborted (core dumped)",
+			}),
+		);
+
+		const crashed = ring.drain(0).events;
+
+		expect(crashed).toHaveLength(1);
+		expect(crashed.at(0)?.payload).toMatchObject({
+			cause: "world-corrupt",
+		});
+		expect(crashed.at(0)?.payload).not.toHaveProperty("lastLine");
+	});
+
 	it("never lets the evidence overwrite the record keys", () => {
 		const ring = idleRing();