@serverkgg/bridge 0.0.21 → 0.1.1

package/src/bot/detect/detect.ts

@@ -0,0 +1,842 @@
+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 { 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 { isEnvKey } from "./envKey";
+import { isNodeSource, isPythonSource, scanEnvKeys } from "./envScan";
+import { BOT_PROTECTED_KEYS, BOT_PROVIDED_KEYS, isReservedBotKey } from "./keys";
+import { isSensitiveKey } from "./sensitiveKey";
+import { parseServerkJson, SERVERK_JSON, type ServerkJson } from "./serverkJson";
+
+export const DETECT_SOURCE_FILE_LIMIT = 40;
+
+export const DETECT_SOURCE_MAX_BYTES = 65_536;
+
+export const DETECT_FILE_MAX_BYTES = 262_144;
+
+export const DETECT_ENV_LIMIT = 100;
+
+export const REQUIREMENTS_FILE = "requirements.txt";
+
+export const PYPROJECT_FILE = "pyproject.toml";
+
+const SKIPPED_SEGMENTS: ReadonlySet<string> = new Set([
+	"node_modules",
+	".venv",
+	"venv",
+	"__pycache__",
+	".git",
+	".serverk",
+	"site-packages",
+]);
+
+const VENV_SEGMENTS: ReadonlySet<string> = new Set([
+	".venv",
+	"venv",
+]);
+
+const ENV_FILE = /^\.env(?:\..+)?$/;
+
+const ENV_TEMPLATE_FILES: ReadonlySet<string> = new Set([
+	...ENV_EXAMPLE_FILES,
+	".env.dist",
+	".env.defaults",
+]);
+
+const TYPESCRIPT_ENTRY = /(?:^|\s)node\s+(?:-\S+\s+)*\S+\.(?:ts|mts|cts)(?:\s|$)/;
+
+const TOKEN_KEY = /TOKEN/i;
+
+const BOT_KEY = /BOT/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;
+
+const REQUIREMENT_NAME = /^([A-Za-z0-9][A-Za-z0-9._-]*)\s*(?:\[[^\]]*\])?\s*(.*)$/;
+
+const REQUIREMENT_SPECIFIER = /[=<>~!@]/;
+
+const TOML_HEADER = /^\s*\[/;
+
+const TOML_KEY = /^\s*([A-Za-z0-9_.-]+|"[^"]+")\s*=\s*(.*)$/;
+
+const MANAGERS: Readonly<Record<string, BotPackageManager>> = {
+	npm: BotPackageManager.Npm,
+	pnpm: BotPackageManager.Pnpm,
+	yarn: BotPackageManager.Yarn,
+};
+
+export interface PythonRequirement {
+	name: string;
+	pinned: boolean;
+}
+
+type PackageJson = Record<string, unknown>;
+
+const normalizePath = (path: string) => {
+	return path
+		.replaceAll("\\", "/")
+		.replace(/^(?:\.\/)+/, "")
+		.replace(/^\/+/, "")
+		.replace(/\/+$/, "");
+};
+
+const segmentsOf = (path: string) => {
+	return path.split("/");
+};
+
+const skipped = (path: string) => {
+	return segmentsOf(path).some((segment) => SKIPPED_SEGMENTS.has(segment));
+};
+
+const depthOf = (path: string) => {
+	return segmentsOf(path).length;
+};
+
+export const compareCodePoints = (left: string, right: string): number => {
+	const leftPoints = left[Symbol.iterator]();
+	const rightPoints = right[Symbol.iterator]();
+
+	for (;;) {
+		const a = leftPoints.next();
+		const b = rightPoints.next();
+
+		if (a.done || b.done) {
+			return a.done === b.done ? 0 : a.done ? -1 : 1;
+		}
+
+		const difference = (a.value.codePointAt(0) ?? 0) - (b.value.codePointAt(0) ?? 0);
+
+		if (difference !== 0) {
+			return difference;
+		}
+	}
+};
+
+const relativeFile = (path: string) => {
+	const trimmed = path.trim();
+
+	if (trimmed.startsWith("/")) {
+		return null;
+	}
+
+	const parts: string[] = [];
+
+	for (const part of trimmed.split("/")) {
+		if (part === "" || part === ".") {
+			continue;
+		}
+
+		if (part === "..") {
+			if (parts.length === 0) {
+				return null;
+			}
+
+			parts.pop();
+
+			continue;
+		}
+
+		parts.push(part);
+	}
+
+	return parts.length === 0 ? null : parts.join("/");
+};
+
+const fitsSize = (size: number | undefined, limit: number) => {
+	return size === undefined || size <= limit;
+};
+
+const START_FILES: readonly string[] = [
+	...DETECT_TABLE.node.startFiles,
+	...DETECT_TABLE.python.startFiles,
+];
+
+const FIXED_FILES: readonly string[] = [
+	DETECT_TABLE.node.manifest,
+	REQUIREMENTS_FILE,
+	PYPROJECT_FILE,
+	DETECT_TABLE.procfile.file,
+	SERVERK_JSON,
+	...ENV_EXAMPLE_FILES,
+];
+
+const sourceRank = (path: string) => {
+	const start = START_FILES.indexOf(path);
+
+	return start === -1 ? START_FILES.length : start;
+};
+
+export const detectWantedFiles = (files: readonly DetectEntry[]): string[] => {
+	const sizes = new Map<string, number | undefined>();
+
+	for (const entry of files) {
+		const path = normalizePath(entry.path);
+
+		if (path.length > 0) {
+			sizes.set(path, entry.size);
+		}
+	}
+
+	const fixed = FIXED_FILES.filter((path) => sizes.has(path) && fitsSize(sizes.get(path), DETECT_FILE_MAX_BYTES));
+
+	const sources = [
+		...sizes,
+	]
+		.filter(([path, size]) => {
+			return (isNodeSource(path) || isPythonSource(path)) && !skipped(path) && fitsSize(size, DETECT_SOURCE_MAX_BYTES);
+		})
+		.map(([path]) => path)
+		.sort((a, b) => sourceRank(a) - sourceRank(b) || depthOf(a) - depthOf(b) || compareCodePoints(a, b))
+		.slice(0, DETECT_SOURCE_FILE_LIMIT);
+
+	return [
+		...fixed,
+		...sources,
+	];
+};
+
+const parseObject = (text: string): PackageJson | null => {
+	try {
+		const parsed: unknown = JSON.parse(text);
+
+		return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? (parsed as PackageJson) : null;
+	} catch {
+		return null;
+	}
+};
+
+const recordOf = (value: unknown): Record<string, unknown> => {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+};
+
+const nodeDependencies = (packageJson: PackageJson | null) => {
+	return new Set(
+		[
+			"dependencies",
+			"devDependencies",
+			"optionalDependencies",
+		].flatMap((field) => Object.keys(recordOf(packageJson?.[field]))),
+	);
+};
+
+const normalizePythonName = (name: string) => {
+	return name.toLowerCase().replace(/[-_.]+/g, "-");
+};
+
+const requirementOf = (line: string): PythonRequirement | null => {
+	const text = line.split(";")[0]?.trim() ?? "";
+
+	if (
+		text.length === 0
+		|| text.startsWith("-")
+		|| text.includes("://")
+		|| text.startsWith(".")
+		|| text.startsWith("/")
+	) {
+		return null;
+	}
+
+	const match = REQUIREMENT_NAME.exec(text);
+
+	if (!match?.[1]) {
+		return null;
+	}
+
+	return {
+		name: normalizePythonName(match[1]),
+		pinned: REQUIREMENT_SPECIFIER.test(match[2] ?? ""),
+	};
+};
+
+export const parseRequirements = (text: string): PythonRequirement[] => {
+	return text
+		.split(/\r?\n/)
+		.map((line) => line.replace(/(?:^|\s)#.*$/, ""))
+		.map(requirementOf)
+		.filter((requirement) => requirement !== null);
+};
+
+const tomlSection = (text: string, name: string) => {
+	const lines = text.split(/\r?\n/);
+	const start = lines.findIndex((line) => line.trim() === `[${name}]`);
+
+	if (start === -1) {
+		return "";
+	}
+
+	const rest = lines.slice(start + 1);
+	const end = rest.findIndex((line) => TOML_HEADER.test(line));
+
+	return (end === -1 ? rest : rest.slice(0, end)).join("\n");
+};
+
+export const parsePyprojectDependencies = (text: string): PythonRequirement[] => {
+	const project = tomlSection(text, "project");
+	const listed = /(?:^|\n)\s*dependencies\s*=\s*\[([\s\S]*?)\]/.exec(project)?.[1] ?? "";
+	const declared = [
+		...listed.matchAll(/"([^"]+)"|'([^']+)'/g),
+	]
+		.map((match) => requirementOf(match[1] ?? match[2] ?? ""))
+		.filter((requirement) => requirement !== null);
+
+	const poetry = tomlSection(text, "tool.poetry.dependencies")
+		.split(/\r?\n/)
+		.map((line) => TOML_KEY.exec(line))
+		.filter((match) => match !== null)
+		.map((match) => {
+			const name = normalizePythonName((match[1] ?? "").replaceAll('"', ""));
+
+			return {
+				name,
+				pinned: !/^["']\*["']$/.test((match[2] ?? "").trim()),
+			};
+		})
+		.filter((requirement) => requirement.name !== "python");
+
+	return [
+		...declared,
+		...poetry,
+	];
+};
+
+const packageNameOf = (specifier: string) => {
+	if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("node:")) {
+		return null;
+	}
+
+	const parts = specifier.split("/");
+
+	return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : (parts[0] ?? null);
+};
+
+const importedModules = (
+	sources: readonly [
+		string,
+		string,
+	][],
+) => {
+	const node = new Set<string>();
+	const python = new Set<string>();
+
+	for (const [path, text] of sources) {
+		if (isNodeSource(path)) {
+			for (const match of text.matchAll(NODE_IMPORT)) {
+				const name = packageNameOf(match[2] ?? "");
+
+				if (name) {
+					node.add(name);
+				}
+			}
+		}
+
+		if (isPythonSource(path)) {
+			for (const match of text.matchAll(PYTHON_IMPORT)) {
+				const name = match[1] ?? match[2];
+
+				if (name) {
+					python.add(name);
+				}
+			}
+		}
+	}
+
+	return {
+		node,
+		python,
+	};
+};
+
+const frameworksOf = (
+	runtime: BotRuntime,
+	dependencies: ReadonlySet<string>,
+	imports: ReadonlySet<string>,
+	normalize: (name: string) => string,
+) => {
+	const specs = BOT_FRAMEWORKS.filter((spec) => spec.runtime === runtime);
+	const declared = specs.filter((spec) => spec.packages.some((name) => dependencies.has(normalize(name))));
+
+	return declared.length > 0 ? declared : specs.filter((spec) => spec.modules.some((name) => imports.has(name)));
+};
+
+const procfileCommand = (text: string | null): DetectedCommand | null => {
+	if (text === null) {
+		return null;
+	}
+
+	const line = new RegExp(DETECT_TABLE.procfile.line);
+	const entries = new Map<string, string>();
+
+	for (const raw of text.split(/\r?\n/)) {
+		const match = line.exec(raw.trim());
+
+		if (match?.[1] && match[2] && !entries.has(match[1])) {
+			entries.set(match[1], match[2].trim());
+		}
+	}
+
+	for (const process of DETECT_TABLE.procfile.processes) {
+		const command = entries.get(process);
+
+		if (command) {
+			return {
+				command,
+				source: DETECT_TABLE.procfile.file,
+			};
+		}
+	}
+
+	return null;
+};
+
+const nodeStartOf = (packageJson: PackageJson | null, has: (path: string) => boolean): DetectedCommand | null => {
+	const script = recordOf(packageJson?.scripts).start;
+
+	if (typeof script === "string" && script.trim().length > 0) {
+		return {
+			command: script.trim(),
+			source: DETECT_TABLE.node.manifest,
+		};
+	}
+
+	const main = typeof packageJson?.main === "string" ? relativeFile(packageJson.main) : null;
+
+	if (main && has(main)) {
+		return {
+			command: `node ${main}`,
+			source: DETECT_TABLE.node.manifest,
+		};
+	}
+
+	const file = DETECT_TABLE.node.startFiles.find(has);
+
+	return file
+		? {
+				command: `node ${file}`,
+				source: file,
+			}
+		: null;
+};
+
+const pythonStartOf = (has: (path: string) => boolean): DetectedCommand | null => {
+	const file = DETECT_TABLE.python.startFiles.find(has);
+
+	return file
+		? {
+				command: `python ${file}`,
+				source: file,
+			}
+		: null;
+};
+
+const nodeStartFileOf = (packageJson: PackageJson | null, has: (path: string) => boolean) => {
+	const main = typeof packageJson?.main === "string" ? relativeFile(packageJson.main) : null;
+
+	return (main !== null && has(main)) || DETECT_TABLE.node.startFiles.some(has);
+};
+
+const decideRuntime = (
+	node: {
+		manifest: boolean;
+		frameworks: number;
+		startFile: boolean;
+	},
+	python: {
+		manifest: boolean;
+		frameworks: number;
+		startFile: boolean;
+	},
+) => {
+	const nodeSignal = node.manifest || node.frameworks > 0 || node.startFile;
+	const pythonSignal = python.manifest || python.frameworks > 0 || python.startFile;
+
+	if (!(nodeSignal && pythonSignal)) {
+		return nodeSignal ? BotRuntime.Node : pythonSignal ? BotRuntime.Python : null;
+	}
+
+	const tiebreaks: [
+		boolean,
+		boolean,
+	][] = [
+		[
+			node.frameworks > 0,
+			python.frameworks > 0,
+		],
+		[
+			node.manifest,
+			python.manifest,
+		],
+		[
+			node.startFile,
+			python.startFile,
+		],
+	];
+
+	for (const [nodeWins, pythonWins] of tiebreaks) {
+		if (nodeWins !== pythonWins) {
+			return nodeWins ? BotRuntime.Node : BotRuntime.Python;
+		}
+	}
+
+	return null;
+};
+
+const uniquePlatforms = (specs: readonly BotFrameworkSpec[]) => {
+	return new Set(specs.map((spec) => spec.platform));
+};
+
+const onlyOf = <Value>(values: ReadonlySet<Value>) => {
+	return values.size === 1
+		? ([
+				...values,
+			][0] ?? null)
+		: null;
+};
+
+const tokenKeyOf = (platform: BotPlatform | null, env: readonly DetectedEnvKey[]) => {
+	const keys = env.map((entry) => entry.key);
+	const names = platform ? BOT_TOKEN_KEYS[platform] : Object.values(BOT_TOKEN_KEYS).flat();
+	const named = names.find((name) => keys.includes(name));
+
+	if (named) {
+		return named;
+	}
+
+	const tokens = env.filter((entry) => entry.sensitive && TOKEN_KEY.test(entry.key));
+
+	return (
+		tokens.find((entry) => platform !== null && platformOfKey(entry.key) === platform)?.key
+		?? tokens.find((entry) => platformOfKey(entry.key) === null && BOT_KEY.test(entry.key))?.key
+		?? null
+	);
+};
+
+const warningsInOrder = (found: ReadonlySet<BotInspectWarning>) => {
+	return Object.values(BotInspectWarning).filter((warning) => found.has(warning));
+};
+
+const committedWarnings = (paths: ReadonlySet<string>, warnings: Set<BotInspectWarning>) => {
+	for (const path of paths) {
+		const segments = segmentsOf(path);
+
+		if (segments.includes("node_modules")) {
+			warnings.add(BotInspectWarning.NodeModulesCommitted);
+		}
+
+		if (segments.some((segment) => VENV_SEGMENTS.has(segment))) {
+			warnings.add(BotInspectWarning.VenvCommitted);
+		}
+
+		const name = segments.at(-1) ?? "";
+
+		if (!skipped(path) && ENV_FILE.test(name) && !ENV_TEMPLATE_FILES.has(name)) {
+			warnings.add(BotInspectWarning.EnvCommitted);
+		}
+	}
+};
+
+interface EnvCollector {
+	add(key: string, source: string, sensitive: boolean | null, example: string | null): void;
+	entries: DetectedEnvKey[];
+}
+
+const envCollector = (warnings: Set<BotInspectWarning>): EnvCollector => {
+	const seen = new Set<string>();
+	const entries: DetectedEnvKey[] = [];
+
+	return {
+		entries,
+		add(key, source, sensitive, example) {
+			if (seen.has(key) || !isEnvKey(key) || entries.length >= DETECT_ENV_LIMIT) {
+				return;
+			}
+
+			seen.add(key);
+
+			if (isReservedBotKey(key)) {
+				if (!BOT_PROTECTED_KEYS.includes(key) && !BOT_PROVIDED_KEYS.includes(key)) {
+					warnings.add(BotInspectWarning.ReservedEnvKey);
+				}
+
+				return;
+			}
+
+			const secret = sensitive ?? isSensitiveKey(key);
+			const shown = example?.trim() ?? "";
+
+			entries.push({
+				key,
+				sensitive: secret,
+				source,
+				example: secret || shown.length === 0 ? null : shown,
+			});
+		},
+	};
+};
+
+const frameworkOf = (
+	serverk: ServerkJson | null,
+	candidates: readonly BotFrameworkSpec[],
+	runtime: BotRuntime | null,
+	warnings: Set<BotInspectWarning>,
+): BotFramework | null => {
+	if (serverk?.framework) {
+		const spec = botFrameworkSpec(serverk.framework);
+		const detected =
+			candidates.length > 0 && !candidates.some((candidate) => candidate.framework === serverk.framework);
+
+		if (detected || (runtime !== null && spec?.runtime !== runtime)) {
+			warnings.add(BotInspectWarning.ManifestDisagrees);
+		}
+
+		return serverk.framework;
+	}
+
+	return uniquePlatforms(candidates).size === 1 ? (candidates[0]?.framework ?? null) : null;
+};
+
+const platformOf = (
+	serverk: ServerkJson | null,
+	framework: BotFramework | null,
+	candidates: readonly BotFrameworkSpec[],
+	keyPlatforms: ReadonlySet<BotPlatform>,
+	warnings: Set<BotInspectWarning>,
+): BotPlatform | null => {
+	const frameworkPlatforms = uniquePlatforms(candidates);
+
+	if (serverk?.platform) {
+		if (frameworkPlatforms.size > 0 && !frameworkPlatforms.has(serverk.platform)) {
+			warnings.add(BotInspectWarning.ManifestDisagrees);
+		}
+
+		return serverk.platform;
+	}
+
+	if (framework) {
+		return botFrameworkSpec(framework)?.platform ?? null;
+	}
+
+	if (frameworkPlatforms.size > 1 || (frameworkPlatforms.size === 0 && keyPlatforms.size > 1)) {
+		warnings.add(BotInspectWarning.TwoPlatforms);
+
+		return null;
+	}
+
+	return onlyOf(frameworkPlatforms) ?? onlyOf(keyPlatforms);
+};
+
+export const detect = (input: DetectInput): DetectResult => {
+	const contents = new Map<string, string>();
+
+	for (const [path, text] of Object.entries(input.contents)) {
+		contents.set(normalizePath(path), text);
+	}
+
+	const paths = new Set<string>([
+		...input.files.map((entry) => normalizePath(entry.path)).filter((path) => path.length > 0),
+		...contents.keys(),
+	]);
+	const has = (path: string) => paths.has(path);
+	const read = (path: string) => contents.get(path) ?? null;
+	const warnings = new Set<BotInspectWarning>();
+
+	const serverkText = read(SERVERK_JSON);
+	const serverk = serverkText === null ? null : parseServerkJson(serverkText);
+
+	if (serverkText !== null && serverk === null) {
+		warnings.add(BotInspectWarning.ManifestInvalid);
+	}
+
+	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);
+	const requirements = requirementsText === null ? [] : parseRequirements(requirementsText);
+	const pyproject = pyprojectText === null ? [] : parsePyprojectDependencies(pyprojectText);
+	const sources = [
+		...contents,
+	]
+		.filter(([path]) => !skipped(path) && (isNodeSource(path) || isPythonSource(path)))
+		.sort(([a], [b]) => compareCodePoints(a, b));
+	const imports = importedModules(sources);
+
+	const nodeFrameworks = frameworksOf(BotRuntime.Node, nodeDependencies(packageJson), imports.node, (name) => name);
+	const pythonFrameworks = frameworksOf(
+		BotRuntime.Python,
+		new Set(
+			[
+				...requirements,
+				...pyproject,
+			].map((requirement) => requirement.name),
+		),
+		imports.python,
+		normalizePythonName,
+	);
+
+	if (hasPackage && pythonManifest) {
+		warnings.add(BotInspectWarning.TwoRuntimes);
+	}
+
+	const codeRuntime = decideRuntime(
+		{
+			manifest: hasPackage,
+			frameworks: nodeFrameworks.length,
+			startFile: nodeStartFileOf(packageJson, has),
+		},
+		{
+			manifest: pythonManifest !== null,
+			frameworks: pythonFrameworks.length,
+			startFile: DETECT_TABLE.python.startFiles.some(has),
+		},
+	);
+
+	if (
+		codeRuntime === null
+		&& (hasPackage || nodeFrameworks.length > 0)
+		&& (pythonManifest || pythonFrameworks.length > 0)
+	) {
+		warnings.add(BotInspectWarning.TwoRuntimes);
+	}
+
+	const runtime = serverk?.runtime ?? codeRuntime;
+
+	if (serverk?.runtime && codeRuntime && serverk.runtime !== codeRuntime) {
+		warnings.add(BotInspectWarning.ManifestDisagrees);
+	}
+
+	let packageManager: BotPackageManager | null = null;
+	let install: DetectedCommand | 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;
+			install = {
+				command: (DETECT_TABLE.node.installCommands[DETECT_TABLE.node.unlockedManager] ?? []).join(" "),
+				source: DETECT_TABLE.node.manifest,
+			};
+			warnings.add(BotInspectWarning.NoLockfile);
+		} else {
+			warnings.add(BotInspectWarning.NoManifest);
+		}
+	}
+
+	if (runtime === BotRuntime.Python) {
+		if (pythonManifest) {
+			packageManager = BotPackageManager.Pip;
+			install = {
+				command: [
+					"pip",
+					...(DETECT_TABLE.python.installArguments[pythonManifest.manager] ?? []),
+				].join(" "),
+				source: pythonManifest.file,
+			};
+
+			const declared = pythonManifest.file === REQUIREMENTS_FILE ? requirements : pyproject;
+
+			if (declared.some((requirement) => !requirement.pinned)) {
+				warnings.add(BotInspectWarning.UnpinnedRequirements);
+			}
+		} else {
+			warnings.add(BotInspectWarning.NoManifest);
+		}
+	}
+
+	if (runtime === null) {
+		warnings.add(BotInspectWarning.NoManifest);
+	}
+
+	if (serverk?.install) {
+		install = {
+			command: serverk.install,
+			source: SERVERK_JSON,
+		};
+	}
+
+	const procfile = procfileCommand(read(DETECT_TABLE.procfile.file));
+	const detectedStart =
+		runtime === BotRuntime.Node
+			? nodeStartOf(packageJson, has)
+			: runtime === BotRuntime.Python
+				? pythonStartOf(has)
+				: null;
+	const start: DetectedCommand | null = serverk?.start
+		? {
+				command: serverk.start,
+				source: SERVERK_JSON,
+			}
+		: (detectedStart ?? procfile);
+
+	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);
+
+	for (const entry of serverk?.env ?? []) {
+		env.add(entry.key, SERVERK_JSON, entry.sensitive, entry.example);
+	}
+
+	for (const file of ENV_EXAMPLE_FILES) {
+		const text = read(file);
+
+		for (const entry of text === null ? [] : parseEnvExample(text)) {
+			env.add(entry.key, file, null, entry.value);
+		}
+	}
+
+	for (const [path, text] of sources) {
+		for (const key of scanEnvKeys(path, text)) {
+			env.add(key, path, null, null);
+		}
+	}
+
+	const candidates =
+		runtime === BotRuntime.Node
+			? nodeFrameworks
+			: runtime === BotRuntime.Python
+				? pythonFrameworks
+				: [
+						...nodeFrameworks,
+						...pythonFrameworks,
+					];
+	const framework = frameworkOf(serverk, candidates, runtime, warnings);
+	const keyPlatforms = new Set(
+		env.entries.map((entry) => platformOfKey(entry.key)).filter((platform) => platform !== null),
+	);
+	const platform = platformOf(serverk, framework, candidates, keyPlatforms, warnings);
+
+	return {
+		runtime,
+		package: runtime ? BOT_RUNTIME_PACKAGES[runtime] : null,
+		packageManager,
+		framework,
+		platform,
+		install,
+		start,
+		env: env.entries,
+		tokenKey: tokenKeyOf(platform, env.entries),
+		warnings: warningsInOrder(warnings),
+	};
+};