@serverkgg/bridge 0.1.4 → 0.1.5

package/src/bot/detect/detect.ts

@@ -6,8 +6,8 @@ import type { BotPlatform } from "./botPlatform";
 import { BOT_RUNTIME_PACKAGES, BotRuntime } from "./botRuntime";
 import { BOT_TOKEN_KEYS, platformOfKey } from "./botToken";
 import type { DetectEntry, DetectedCommand, DetectedEnvKey, DetectInput, DetectResult } from "./detectResult";
-import { DETECT_TABLE } from "./detectTable";
-import { ENV_EXAMPLE_FILES, parseEnvExample } from "./envExample";
+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";
@@ -41,15 +41,33 @@ const VENV_SEGMENTS: ReadonlySet<string> = new Set([
 	"venv",
 ]);
 
-const ENV_FILE = /^\.env(?:\..+)?$/;
+const DATABASE_FILE = /\.(?:sqlite3?|db)$/i;
 
-const ENV_TEMPLATE_FILES: ReadonlySet<string> = new Set([
-	...ENV_EXAMPLE_FILES,
-	".env.dist",
-	".env.defaults",
+const PYTHON_PACKAGE_MAIN = /^([A-Za-z_]\w*)\/__main__\.py$/;
+
+const NOT_A_BOT_PACKAGE: ReadonlySet<string> = new Set([
+	"tests",
+	"test",
+	"docs",
+	"examples",
+	"scripts",
 ]);
 
-const TYPESCRIPT_ENTRY = /(?:^|\s)node\s+(?:-\S+\s+)*\S+\.(?:ts|mts|cts)(?:\s|$)/;
+const MANAGER_FIELD = /^(npm|pnpm|yarn|bun)@(\d+)/;
+
+const ENGINE_MANAGERS: readonly string[] = [
+	"pnpm",
+	"bun",
+	"yarn",
+];
+
+const YARN_BERRY = "yarn-berry";
+
+const VERSION_NUMBER = /^v?(\d+(?:\.\d+)*)/;
+
+const RANGE_COMPARATOR = /^(>=|<=|>|<|=|\^|~)?v?(\d+)(?:\.(\d+|x|\*))?(?:\.(\d+|x|\*))?$/;
+
+const HYPHEN_RANGE = /(\S+)\s+-\s+(\S+)/g;
 
 const TOKEN_KEY = /TOKEN/i;
 
@@ -71,6 +89,14 @@ const MANAGERS: Readonly<Record<string, BotPackageManager>> = {
 	npm: BotPackageManager.Npm,
 	pnpm: BotPackageManager.Pnpm,
 	yarn: BotPackageManager.Yarn,
+	[YARN_BERRY]: BotPackageManager.Yarn,
+	bun: BotPackageManager.Bun,
+	requirements: BotPackageManager.Pip,
+	uv: BotPackageManager.Uv,
+	poetry: BotPackageManager.Pip,
+	pdm: BotPackageManager.Pip,
+	pipenv: BotPackageManager.Pipenv,
+	project: BotPackageManager.Pip,
 };
 
 export interface PythonRequirement {
@@ -166,6 +192,8 @@ const FIXED_FILES: readonly string[] = [
 	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) => {
@@ -425,13 +453,29 @@ const nodeStartOf = (packageJson: PackageJson | null, has: (path: string) => boo
 		: null;
 };
 
-const pythonStartOf = (has: (path: string) => boolean): DetectedCommand | null => {
+const pythonStartOf = (has: (path: string) => boolean, paths: ReadonlySet<string>): DetectedCommand | null => {
 	const file = DETECT_TABLE.python.startFiles.find(has);
 
-	return file
+	if (file) {
+		return {
+			command: `python ${file}`,
+			source: file,
+		};
+	}
+
+	const packages = [
+		...paths,
+	]
+		.map((path) => PYTHON_PACKAGE_MAIN.exec(path)?.[1])
+		.filter((name): name is string => name !== undefined && !skipped(name) && !NOT_A_BOT_PACKAGE.has(name))
+		.sort(compareCodePoints);
+
+	const name = packages.length === 1 ? packages[0] : null;
+
+	return name
 		? {
-				command: `python ${file}`,
-				source: file,
+				command: `python -m ${name}`,
+				source: `${name}/__main__.py`,
 			}
 		: null;
 };
@@ -442,6 +486,243 @@ const nodeStartFileOf = (packageJson: PackageJson | null, has: (path: string) =>
 	return (main !== null && has(main)) || DETECT_TABLE.node.startFiles.some(has);
 };
 
+interface NodeManager {
+	key: string;
+	locked: boolean;
+	source: string;
+}
+
+const lockfileOf = (manager: string, has: (path: string) => boolean) => {
+	const lockManager = manager === YARN_BERRY ? "yarn" : manager;
+
+	return DETECT_TABLE.node.lockfiles.find((entry) => entry.manager === lockManager && has(entry.file)) ?? null;
+};
+
+const nodeManagerOf = (packageJson: PackageJson | null, has: (path: string) => boolean): NodeManager => {
+	const declared = packageJson?.[DETECT_TABLE.node.managerField];
+	const field = typeof declared === "string" ? MANAGER_FIELD.exec(declared.trim()) : null;
+
+	if (field) {
+		const key = field[1] === "yarn" && Number(field[2]) >= 2 ? YARN_BERRY : (field[1] ?? "npm");
+		const lock = lockfileOf(key, has);
+
+		return {
+			key,
+			locked: lock !== null,
+			source: lock?.file ?? DETECT_TABLE.node.manifest,
+		};
+	}
+
+	for (const entry of DETECT_TABLE.node.lockfiles) {
+		if (entry.manager !== "npm" && has(entry.file)) {
+			return {
+				key: entry.manager === "yarn" && has(DETECT_TABLE.node.berryFile) ? YARN_BERRY : entry.manager,
+				locked: true,
+				source: entry.file,
+			};
+		}
+	}
+
+	if (has(DETECT_TABLE.node.berryFile)) {
+		return {
+			key: YARN_BERRY,
+			locked: false,
+			source: DETECT_TABLE.node.berryFile,
+		};
+	}
+
+	const engines = recordOf(packageJson?.engines);
+	const engine = ENGINE_MANAGERS.find((manager) => typeof engines[manager] === "string") ?? null;
+
+	if (engine) {
+		return {
+			key: engine,
+			locked: false,
+			source: DETECT_TABLE.node.manifest,
+		};
+	}
+
+	const npmLock = lockfileOf("npm", has);
+
+	return {
+		key: "npm",
+		locked: npmLock !== null,
+		source: npmLock?.file ?? DETECT_TABLE.node.manifest,
+	};
+};
+
+const nodeBuildOf = (packageJson: PackageJson | null, manager: string): DetectedCommand | null => {
+	const script = recordOf(packageJson?.scripts)[DETECT_TABLE.node.buildScript];
+
+	if (typeof script !== "string" || script.trim().length === 0) {
+		return null;
+	}
+
+	const run = DETECT_TABLE.node.runCommands[manager] ?? DETECT_TABLE.node.runCommands.npm ?? [];
+
+	return {
+		command: [
+			...run,
+			DETECT_TABLE.node.buildScript,
+		].join(" "),
+		source: DETECT_TABLE.node.manifest,
+	};
+};
+
+const versionFromFile = (text: string, spec: DetectVersionFile): string | null => {
+	for (const raw of text.split("\n")) {
+		let line = raw.trim();
+
+		if (line.length === 0 || line.startsWith("#")) {
+			continue;
+		}
+
+		if (spec.tool !== undefined) {
+			const [tool, ...rest] = line.split(/\s+/);
+
+			if (tool !== spec.tool) {
+				continue;
+			}
+
+			line = rest[0] ?? "";
+		}
+
+		if (spec.key !== undefined) {
+			const match = new RegExp(`^${spec.key}\\s*=\\s*"?([^"\\s]+)`).exec(line);
+
+			if (!match) {
+				continue;
+			}
+
+			line = match[1] ?? "";
+		}
+
+		if (spec.prefix !== undefined) {
+			if (!line.startsWith(spec.prefix)) {
+				return null;
+			}
+
+			line = line.slice(spec.prefix.length);
+		}
+
+		return VERSION_NUMBER.exec(line)?.[1] ?? null;
+	}
+
+	return null;
+};
+
+const versionFromFiles = (
+	specs: readonly DetectVersionFile[],
+	read: (path: string) => string | null,
+	parts: number,
+): string | null => {
+	for (const spec of specs) {
+		const text = read(spec.file);
+
+		if (text === null) {
+			continue;
+		}
+
+		const version = versionFromFile(text, spec);
+
+		if (version !== null) {
+			return version.split(".").slice(0, parts).join(".");
+		}
+	}
+
+	return null;
+};
+
+const comparatorAdmits = (comparator: string, major: number): boolean | null => {
+	const match = RANGE_COMPARATOR.exec(comparator);
+
+	if (!match) {
+		return null;
+	}
+
+	const base = Number(match[2]);
+	const minor = match[3];
+
+	switch (match[1] ?? "") {
+		case ">=":
+			return major >= base;
+		case ">":
+			return minor === undefined ? major > base : major >= base;
+		case "<":
+			return major < base || (major === base && minor !== undefined && minor !== "0");
+		case "<=":
+			return major <= base;
+		default:
+			return major === base;
+	}
+};
+
+const comparatorsOf = (clause: string) => {
+	return clause
+		.replace(HYPHEN_RANGE, ">=$1 <=$2")
+		.trim()
+		.split(/\s+/)
+		.filter((token) => token.length > 0);
+};
+
+const rangeAdmits = (range: string, major: number) => {
+	return range.split("||").some((clause) => {
+		const verdicts = comparatorsOf(clause).map((token) => comparatorAdmits(token, major));
+
+		return verdicts.length === 0 || verdicts.some((verdict) => verdict === null) || verdicts.every(Boolean);
+	});
+};
+
+const requestedMajorOf = (range: string): string | null => {
+	const comparators = range
+		.split("||")
+		.flatMap(comparatorsOf)
+		.map((token) => RANGE_COMPARATOR.exec(token))
+		.filter((match) => match !== null);
+	const lower = comparators.filter((match) => match[1] !== "<" && match[1] !== "<=").map((match) => Number(match[2]));
+
+	if (lower.length > 0) {
+		return String(Math.min(...lower));
+	}
+
+	const upper = comparators.map((match) => (match[1] === "<" ? Number(match[2]) - 1 : Number(match[2])));
+
+	return upper.length === 0 ? null : String(Math.max(...upper));
+};
+
+interface NodeRequirement {
+	version: string;
+	unmet: boolean;
+}
+
+const nodeRequirementOf = (
+	packageJson: PackageJson | null,
+	read: (path: string) => string | null,
+): NodeRequirement | null => {
+	const image = Number(DETECT_TABLE.node.defaultVersion);
+	const engine = recordOf(packageJson?.engines)[DETECT_TABLE.node.enginesKey];
+
+	if (typeof engine === "string" && engine.trim().length > 0) {
+		const version = requestedMajorOf(engine);
+
+		if (version !== null) {
+			return {
+				version,
+				unmet: !rangeAdmits(engine, image),
+			};
+		}
+	}
+
+	const version = versionFromFiles(DETECT_TABLE.node.versionFiles, read, 1);
+
+	return version === null
+		? null
+		: {
+				version,
+				unmet: Number(version) !== image,
+			};
+};
+
 const decideRuntime = (
 	node: {
 		manifest: boolean;
@@ -536,9 +817,13 @@ const committedWarnings = (paths: ReadonlySet<string>, warnings: Set<BotInspectW
 
 		const name = segments.at(-1) ?? "";
 
-		if (!skipped(path) && ENV_FILE.test(name) && !ENV_TEMPLATE_FILES.has(name)) {
+		if (!skipped(path) && isSecretEnvFile(name)) {
 			warnings.add(BotInspectWarning.EnvCommitted);
 		}
+
+		if (!skipped(path) && DATABASE_FILE.test(name)) {
+			warnings.add(BotInspectWarning.DatabaseCommitted);
+		}
 	}
 };
 
@@ -657,7 +942,6 @@ export const detect = (input: DetectInput): DetectResult => {
 	const packageText = read(DETECT_TABLE.node.manifest);
 	const packageJson = packageText === null ? null : parseObject(packageText);
 	const hasPackage = has(DETECT_TABLE.node.manifest);
-	const nodeLock = DETECT_TABLE.node.lockfiles.find((entry) => has(entry.file)) ?? null;
 	const pythonManifest = DETECT_TABLE.python.manifests.find((entry) => has(entry.file)) ?? null;
 	const requirementsText = read(REQUIREMENTS_FILE);
 	const pyprojectText = read(PYPROJECT_FILE);
@@ -716,37 +1000,54 @@ export const detect = (input: DetectInput): DetectResult => {
 
 	let packageManager: BotPackageManager | null = null;
 	let install: DetectedCommand | null = null;
+	let build: DetectedCommand | null = null;
+	let nodeVersion: string | null = null;
+	let pythonVersion: string | null = null;
 
 	if (runtime === BotRuntime.Node) {
-		if (nodeLock) {
-			packageManager = MANAGERS[nodeLock.manager] ?? null;
-			install = {
-				command: (DETECT_TABLE.node.installCommands[nodeLock.manager] ?? []).join(" "),
-				source: nodeLock.file,
-			};
-		} else if (hasPackage) {
-			packageManager = BotPackageManager.Npm;
+		if (hasPackage) {
+			const manager = nodeManagerOf(packageJson, has);
+			const commands = manager.locked
+				? DETECT_TABLE.node.installCommands.locked
+				: DETECT_TABLE.node.installCommands.unlocked;
+
+			packageManager = MANAGERS[manager.key] ?? null;
 			install = {
-				command: (DETECT_TABLE.node.installCommands[DETECT_TABLE.node.unlockedManager] ?? []).join(" "),
-				source: DETECT_TABLE.node.manifest,
+				command: (commands[manager.key] ?? []).join(" "),
+				source: manager.source,
 			};
-			warnings.add(BotInspectWarning.NoLockfile);
+			build = nodeBuildOf(packageJson, manager.key);
+
+			if (!manager.locked) {
+				warnings.add(BotInspectWarning.NoLockfile);
+			}
+
+			const requirement = nodeRequirementOf(packageJson, read);
+
+			nodeVersion = requirement?.version ?? null;
+
+			if (requirement?.unmet) {
+				warnings.add(BotInspectWarning.NodeVersionUnmet);
+			}
 		} else {
 			warnings.add(BotInspectWarning.NoManifest);
 		}
 	}
 
 	if (runtime === BotRuntime.Python) {
+		pythonVersion = versionFromFiles(DETECT_TABLE.python.versionFiles, read, 2);
+
 		if (pythonManifest) {
-			packageManager = BotPackageManager.Pip;
+			packageManager = MANAGERS[pythonManifest.manager] ?? null;
 			install = {
-				command: [
-					"pip",
-					...(DETECT_TABLE.python.installArguments[pythonManifest.manager] ?? []),
-				].join(" "),
+				command: (DETECT_TABLE.python.installCommands[pythonManifest.manager] ?? []).join(" "),
 				source: pythonManifest.file,
 			};
 
+			if (DETECT_TABLE.python.unhonouredManagers.includes(pythonManifest.manager)) {
+				warnings.add(BotInspectWarning.LockfileNotHonoured);
+			}
+
 			const declared = pythonManifest.file === REQUIREMENTS_FILE ? requirements : pyproject;
 
 			if (declared.some((requirement) => !requirement.pinned)) {
@@ -768,28 +1069,31 @@ export const detect = (input: DetectInput): DetectResult => {
 		};
 	}
 
+	if (serverk?.build) {
+		build = {
+			command: serverk.build,
+			source: SERVERK_JSON,
+		};
+	}
+
 	const procfile = procfileCommand(read(DETECT_TABLE.procfile.file));
 	const detectedStart =
 		runtime === BotRuntime.Node
 			? nodeStartOf(packageJson, has)
 			: runtime === BotRuntime.Python
-				? pythonStartOf(has)
+				? pythonStartOf(has, paths)
 				: null;
 	const start: DetectedCommand | null = serverk?.start
 		? {
 				command: serverk.start,
 				source: SERVERK_JSON,
 			}
-		: (detectedStart ?? procfile);
+		: (procfile ?? detectedStart);
 
 	if (!start) {
 		warnings.add(BotInspectWarning.NoStart);
 	}
 
-	if (runtime === BotRuntime.Node && start && TYPESCRIPT_ENTRY.test(start.command)) {
-		warnings.add(BotInspectWarning.TypescriptEntry);
-	}
-
 	committedWarnings(paths, warnings);
 
 	const env = envCollector(warnings);
@@ -806,6 +1110,10 @@ export const detect = (input: DetectInput): DetectResult => {
 		}
 	}
 
+	for (const entry of input.skippedEnv === undefined ? [] : parseEnvExample(input.skippedEnv)) {
+		env.add(entry.key, ENV_FILE, null, null);
+	}
+
 	for (const [path, text] of sources) {
 		for (const key of scanEnvKeys(path, text)) {
 			env.add(key, path, null, null);
@@ -834,7 +1142,10 @@ export const detect = (input: DetectInput): DetectResult => {
 		framework,
 		platform,
 		install,
+		build,
 		start,
+		nodeVersion,
+		pythonVersion,
 		env: env.entries,
 		tokenKey: tokenKeyOf(platform, env.entries),
 		warnings: warningsInOrder(warnings),

package/src/bot/detect/detectResult.ts

@@ -12,6 +12,7 @@ export interface DetectEntry {
 export interface DetectInput {
 	files: readonly DetectEntry[];
 	contents: Readonly<Record<string, string>>;
+	skippedEnv?: string;
 }
 
 export interface DetectedCommand {
@@ -33,7 +34,10 @@ export interface DetectResult {
 	framework: BotFramework | null;
 	platform: BotPlatform | null;
 	install: DetectedCommand | null;
+	build: DetectedCommand | null;
 	start: DetectedCommand | null;
+	nodeVersion: string | null;
+	pythonVersion: string | null;
 	env: DetectedEnvKey[];
 	tokenKey: string | null;
 	warnings: BotInspectWarning[];

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

@@ -9,20 +9,36 @@ describe("renderDetectTable", () => {
 		const rendered = renderDetectTable();
 
 		expect(rendered.endsWith("}\n")).toBe(true);
-		expect(rendered).toContain('\t"version": 1,');
+		expect(rendered).toContain('\t"version": 2,');
 		expect(JSON.parse(rendered)).toEqual(DETECT_TABLE);
 	});
 
-	it("names an install command for every manager a lockfile or manifest points at", () => {
-		for (const lockfile of DETECT_TABLE.node.lockfiles) {
-			expect(DETECT_TABLE.node.installCommands[lockfile.manager]).toBeDefined();
+	it("names a locked and an unlocked install and a run command for every Node manager", () => {
+		const managers = new Set([
+			...DETECT_TABLE.node.lockfiles.map((lockfile) => lockfile.manager),
+			"yarn-berry",
+		]);
+
+		for (const manager of managers) {
+			expect(DETECT_TABLE.node.installCommands.locked[manager]).toBeDefined();
+			expect(DETECT_TABLE.node.installCommands.unlocked[manager]).toBeDefined();
+			expect(DETECT_TABLE.node.runCommands[manager]).toBeDefined();
 		}
 
-		expect(DETECT_TABLE.node.installCommands[DETECT_TABLE.node.unlockedManager]).toBeDefined();
+		expect(Number(DETECT_TABLE.node.defaultVersion)).toBeGreaterThan(0);
+	});
 
+	it("names an install command for every Python manifest and lockfile, and the ones it does not honour", () => {
 		for (const manifest of DETECT_TABLE.python.manifests) {
-			expect(DETECT_TABLE.python.installArguments[manifest.manager]).toBeDefined();
+			expect(DETECT_TABLE.python.installCommands[manifest.manager]).toBeDefined();
 		}
+
+		for (const manager of DETECT_TABLE.python.unhonouredManagers) {
+			expect(DETECT_TABLE.python.manifests.some((manifest) => manifest.manager === manager)).toBe(true);
+		}
+
+		expect(DETECT_TABLE.python.manifests[0]?.file).toBe("requirements.txt");
+		expect(DETECT_TABLE.python.defaultVersion).toMatch(/^\d+\.\d+$/);
 	});
 
 	it("carries the serverk.json rules the launchers need to agree with the parser", () => {