spooder 3.2.7 → 4.0.0

package/src/cli.ts

@@ -36,35 +36,56 @@ async function start_server() {
 		}
 	}
 
+	const crash_console_history = config.canary.crash_console_history;
+	const include_crash_history = crash_console_history > 0;
+
+	const std_mode = include_crash_history ? 'pipe' : 'inherit';
 	const proc = Bun.spawn(parse_command_line(config.run), {
 		cwd: process.cwd(),
-		stdout: 'inherit',
-		stderr: 'pipe'
+		stdout: std_mode,
+		stderr: std_mode
 	});
 
-	await proc.exited;
+	const stream_history = new Array<string>();
+	if (include_crash_history) {
+		const text_decoder = new TextDecoder();
 
-	const proc_exit_code = proc.exitCode;
-	log('server exited with code %s', proc_exit_code);
+		function capture_stream(stream: ReadableStream, output: NodeJS.WritableStream) {
+			const reader = stream.getReader();
 
-	if (proc_exit_code !== 0) {
-		if (proc.stderr !== undefined) {
-			const res = new Response(proc.stderr as ReadableStream);
-
-			res.text().then(async stderr => {
-				await dispatch_report('crash: server exited unexpectedly', [{
-					proc_exit_code,
-					stderr: strip_color_codes(stderr).split(/\r?\n/)
-				}]);
+			reader.read().then(function read_chunk(chunk: ReadableStreamDefaultReadResult<Uint8Array>) {
+				if (chunk.done)
+					return;
+
+				const chunk_str = text_decoder.decode(chunk.value);
+				stream_history.push(...chunk_str.split(/\r?\n/));
+
+				if (stream_history.length > crash_console_history)
+					stream_history.splice(0, stream_history.length - crash_console_history);
+
+				output.write(chunk.value);
+				reader.read().then(read_chunk);
 			});
-		} else {
-			dispatch_report('crash: service exited unexpectedly', [{
-				proc_exit_code
-			}]);
 		}
+
+		capture_stream(proc.stdout as ReadableStream, process.stdout);
+		capture_stream(proc.stderr as ReadableStream, process.stderr);
+	}
+	
+	await proc.exited;
+	
+	const proc_exit_code = proc.exitCode;
+	log('server exited with code %s', proc_exit_code);
+	
+	if (proc_exit_code !== 0) {
+		const console_output = include_crash_history ? strip_color_codes(stream_history.join('\n')) : undefined;
+		dispatch_report('crash: server exited unexpectedly', [{
+			proc_exit_code, console_output
+		}]);
 	}
+	  
 
-	const auto_restart_ms = config.autoRestart;
+	const auto_restart_ms = config.auto_restart;
 	if (auto_restart_ms > -1) {
 		log('restarting server in %dms', auto_restart_ms);
 		setTimeout(start_server, auto_restart_ms);

package/src/config.d.ts

@@ -1,11 +1,12 @@
 declare const internal_config: {
     run: string;
-    autoRestart: number;
+    auto_restart: number;
     update: never[];
     canary: {
         account: string;
         repository: string;
         labels: never[];
+        crash_console_history: number;
         throttle: number;
         sanitize: boolean;
     };

package/src/config.ts

@@ -3,12 +3,13 @@ import { log } from './utils';
 
 const internal_config = {
 	run: 'bun run index.ts',
-	autoRestart: -1,
+	auto_restart: -1,
 	update: [],
 	canary: {
 		account: '',
 		repository: '',
 		labels: [],
+		crash_console_history: 64,
 		throttle: 86400,
 		sanitize: true
 	}
@@ -17,6 +18,8 @@ const internal_config = {
 type Config = typeof internal_config;
 type ConfigObject = Record<string, unknown>;
 
+let cached_config: Config | null = null;
+
 function validate_config_option(source: ConfigObject, target: ConfigObject, root_name: string) {
 	for (const [key, value] of Object.entries(target)) {
 		const key_name = `${root_name}.${key}`;
@@ -59,7 +62,7 @@ function validate_config_option(source: ConfigObject, target: ConfigObject, root
 	}
 }
 
-export async function get_config(): Promise<Config> {
+async function load_config(): Promise<Config> {
 	try {
 		const config_file = Bun.file(path.join(process.cwd(), 'package.json'));
 		const json = await config_file.json();
@@ -75,4 +78,11 @@ export async function get_config(): Promise<Config> {
 	}
 
 	return internal_config;
+}
+
+export async function get_config(): Promise<Config> {
+	if (cached_config === null)
+		cached_config = await load_config();
+
+	return cached_config;
 }

package/src/dispatch.ts

@@ -1,5 +1,5 @@
-import { App } from '@octokit/app';
 import { get_config } from './config';
+import { create_github_issue } from './github';
 import { log } from './utils';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -93,9 +93,9 @@ async function check_cache_table(key: string, repository: string, expiry: number
 			}
 		}
 	} catch (e) {
-		log('Failed to read canary cache file ' + cache_file_path);
-		log('Error: ' + (e as Error).message);
-		log('You should resolve this issue to prevent spamming GitHub with canary reports.');
+		log('failed to read canary cache file ' + cache_file_path);
+		log('error: ' + (e as Error).message);
+		log('you should resolve this issue to prevent spamming GitHub with canary reports');
 	}
 
 	if (cache_table.has(key_hash)) {
@@ -142,6 +142,12 @@ function generate_diagnostics(): object {
 		'platform': os.platform(),
 		'uptime': os.uptime(),
 		'versions': process.versions,
+		'bun': {
+			'version': Bun.version,
+			'rev': Bun.revision,
+			'memory_usage': process.memoryUsage(),
+			'cpu_usage': process.cpuUsage()
+		}
 	}
 }
 
@@ -149,16 +155,17 @@ export async function dispatch_report(report_title: string, report_body: Array<u
 	try {
 		const config = await get_config();
 
-		const canary_account = config.canary.account.toLowerCase();
-		const canary_repostiory = config.canary.repository.toLowerCase();
-		const canary_labels = config.canary.labels;
+		const canary_account = config.canary.account;
+		const canary_repostiory = config.canary.repository;
 
-		if (canary_account.length === 0|| canary_repostiory.length === 0)
+		if (canary_account.length === 0|| canary_repostiory.length === 0) {
+			log('[canary] report dispatch failed; no account/repository configured');
 			return;
+		}
 
 		const is_cached = await check_cache_table(report_title, canary_repostiory, config.canary.throttle);
 		if (is_cached) {
-			log('Throttled canary report: ' + report_title);
+			log('[canary] throttled canary report: ' + report_title);
 			return;
 		}
 
@@ -166,58 +173,44 @@ export async function dispatch_report(report_title: string, report_body: Array<u
 		const canary_app_key = process.env.SPOODER_CANARY_KEY as string;
 
 		if (canary_app_id === undefined)
-			throw new Error('dispatch_report() called without SPOODER_CANARY_APP_ID environment variable set');
+			throw new Error('SPOODER_CANARY_APP_ID environment variable is not set');
 
 		if (canary_app_key === undefined)
-			throw new Error('dispatch_report() called without SPOODER_CANARY_KEY environment variable set');
+			throw new Error('SPOODER_CANARY_KEY environment variable is not set');
 
 		const key_file = Bun.file(canary_app_key);
 		if (key_file.size === 0)
-			throw new Error('dispatch_report() failed to read canary private key file');
+			throw new Error('Unable to read private key file defined by SPOODER_CANARY_KEY environment variable');
 
 		const app_id = parseInt(canary_app_id, 10);
 		if (isNaN(app_id))
-			throw new Error('dispatch_report() failed to parse SPOODER_CANARY_APP_ID environment variable as integer');
-
-		const app = new App({
-			appId: app_id,
-			privateKey: await key_file.text(),
-		});
-
-		await app.octokit.request('GET /app');
+			throw new Error('Invalid app ID defined by SPOODER_CANARY_APP_ID environment variable');
 
-		const post_object = {
-			title: report_title,
-			body: '',
-			labels: canary_labels
-		};
+		let issue_title = report_title;
+		let issue_body = '';
 
 		report_body.push(generate_diagnostics());
 
 		if (config.canary.sanitize) {
 			const local_env = await load_local_env();
-			post_object.body = sanitize_string(JSON.stringify(report_body, null, 4), local_env);
-			post_object.title = sanitize_string(report_title, local_env);
+			issue_body = sanitize_string(JSON.stringify(report_body, null, 4), local_env);
+			issue_title = sanitize_string(report_title, local_env);
 		} else {
-			post_object.body = JSON.stringify(report_body, null, 4);
+			issue_body = JSON.stringify(report_body, null, 4);
 		}
 
-		post_object.body = '```json\n' + post_object.body + '\n```\n\nℹ️ *This issue has been created automatically in response to a server panic, caution or crash.*';
+		issue_body = '```json\n' + issue_body + '\n```\n\nℹ️ *This issue has been created automatically in response to a server panic, caution or crash.*';
 
-		for await (const { installation } of app.eachInstallation.iterator()) {
-			const login = (installation?.account as { login: string })?.login;
-			if (login?.toLowerCase() !== canary_account)
-				continue;
-
-			for await (const { octokit, repository } of app.eachRepository.iterator({ installationId: installation.id })) {
-				if (repository.full_name.toLowerCase() !== canary_repostiory)
-					continue;
-
-				await octokit.request('POST /repos/' + canary_repostiory + '/issues', post_object);
-				log('Dispatched canary report to %s: %s', canary_repostiory, report_title);
-			}
-		}
+		await create_github_issue({
+			app_id,
+			private_key: await key_file.text(),
+			repository_name: canary_repostiory,
+			login_name: canary_account,
+			issue_title,
+			issue_body,
+			issue_labels: config.canary.labels
+		});
 	} catch (e) {
-		log('Failed to dispatch canary report: ' + (e as Error)?.message ?? 'unspecified error');
+		log('[canary error] ' + (e as Error)?.message ?? 'unspecified error');
 	}
 }

package/src/github.d.ts

@@ -0,0 +1,11 @@
+type Issue = {
+    app_id: number;
+    private_key: string;
+    login_name: string;
+    repository_name: string;
+    issue_title: string;
+    issue_body: string;
+    issue_labels?: Array<string>;
+};
+export declare function create_github_issue(issue: Issue): Promise<void>;
+export {};

package/src/github.ts

@@ -0,0 +1,121 @@
+import crypto from 'node:crypto';
+import { log } from './utils';
+
+type InstallationResponse = Array<{
+	id: number,
+	account: {
+		login: string
+	},
+	access_tokens_url: string,
+	repositories_url: string
+}>;
+
+type AccessTokenResponse = {
+	token: string;
+};
+
+type RepositoryResponse = {
+	repositories: Array<{
+		full_name: string,
+		name: string,
+		url: string,
+		owner: {
+			login: string
+		}
+	}>
+};
+
+type IssueResponse = {
+	number: number,
+	url: string
+};
+
+type Issue = {
+	app_id: number,
+	private_key: string,
+	login_name: string,
+	repository_name: string,
+	issue_title: string,
+	issue_body: string
+	issue_labels?: Array<string>
+};
+
+function generate_jwt(app_id: number, private_key: string): string {
+	const encoded_header = Buffer.from(JSON.stringify({
+		alg: 'RS256',
+		typ: 'JWT'
+	})).toString('base64');
+
+	const encoded_payload = Buffer.from(JSON.stringify({
+		iat: Math.floor(Date.now() / 1000),
+		exp: Math.floor(Date.now() / 1000) + 60,
+		iss: app_id
+	})).toString('base64');
+
+	const sign = crypto.createSign('RSA-SHA256');
+	sign.update(encoded_header + '.' + encoded_payload);
+
+	return encoded_header + '.' + encoded_payload + '.' + sign.sign(private_key, 'base64');
+}
+
+async function request_endpoint(url: string, bearer: string, method: string = 'GET', body?: object): Promise<Response> {
+	return fetch(url, {
+		method,
+		body: body ? JSON.stringify(body) : undefined,
+		headers: {
+			Authorization: 'Bearer ' + bearer,
+			Accept: 'application/vnd.github.v3+json'
+		}
+	});
+}
+
+function check_response_is_ok(res: Response, message: string): void {
+	if (!res.ok)
+		throw new Error(message + ' (' + res.status + ' ' + res.statusText + ')');
+}
+
+export async function create_github_issue(issue: Issue): Promise<void> {
+	const jwt = generate_jwt(issue.app_id, issue.private_key);
+	const app_res = await request_endpoint('https://api.github.com/app', jwt);
+
+	check_response_is_ok(app_res, 'cannot authenticate GitHub app ' + issue.app_id);
+
+	const res_installs = await request_endpoint('https://api.github.com/app/installations', jwt);
+	check_response_is_ok(res_installs, 'cannot fetch GitHub app installations');
+
+	const json_installs = await res_installs.json() as InstallationResponse;
+
+	const login_name = issue.login_name.toLowerCase();
+	const install = json_installs.find((install) => install.account.login.toLowerCase() === login_name);
+
+	if (!install)
+		throw new Error('spooder-bot is not installed on account ' + login_name);
+
+	const res_access_token = await request_endpoint(install.access_tokens_url, jwt, 'POST');
+	check_response_is_ok(res_access_token, 'cannot fetch GitHub app access token');
+
+	const json_access_token = await res_access_token.json() as AccessTokenResponse;
+	const access_token = json_access_token.token;
+
+	const repositories = await request_endpoint(install.repositories_url, access_token);
+	check_response_is_ok(repositories, 'cannot fetch GitHub app repositories');
+
+	const repositories_json = await repositories.json() as RepositoryResponse;
+
+	const repository_name = issue.repository_name.toLowerCase();
+	const repository = repositories_json.repositories.find((repository) => repository.full_name.toLowerCase() === repository_name);
+
+	if (!repository)
+		throw new Error('spooder-bot is not installed on repository ' + repository_name);
+
+	const issue_res = await request_endpoint(repository.url + '/issues', access_token, 'POST', {
+		title: issue.issue_title,
+		body: issue.issue_body,
+		labels: issue.issue_labels
+	});
+
+	check_response_is_ok(issue_res, 'cannot create GitHub issue');
+
+	const json_issue = await issue_res.json() as IssueResponse;
+	log('raised canary issue #%d in %s: %s', json_issue.number, repository.full_name, json_issue.url);
+}