spooder 4.6.2 → 5.0.1

package/src/cli.ts

@@ -1,35 +1,85 @@
 #!/usr/bin/env bun
 import { get_config } from './config';
-import { parse_command_line, log, strip_color_codes } from './utils';
 import { dispatch_report } from './dispatch';
+import { log_create_logger } from './api';
+
+const log_cli = log_create_logger('spooder_cli');
+
+let restart_delay = 100;
+let restart_attempts = 0;
+let restart_success_timer: Timer | null = null;
+
+function strip_color_codes(str: string): string {
+	return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function parse_command_line(command: string): string[] {
+	const args = [];
+	let current_arg = '';
+	let in_quotes = false;
+	let in_escape = false;
+
+	for (let i = 0; i < command.length; i++) {
+		const char = command[i];
+
+		if (in_escape) {
+			current_arg += char;
+			in_escape = false;
+			continue;
+		}
+
+		if (char === '\\') {
+			in_escape = true;
+			continue;
+		}
+
+		if (char === '"') {
+			in_quotes = !in_quotes;
+			continue;
+		}
+
+		if (char === ' ' && !in_quotes) {
+			args.push(current_arg);
+			current_arg = '';
+			continue;
+		}
+
+		current_arg += char;
+	}
+
+	if (current_arg.length > 0)
+		args.push(current_arg);
+
+	return args;
+}
 
 async function start_server() {
-	log('start_server');
+	log_cli('start_server');
 
 	const argv = process.argv.slice(2);
 	const is_dev_mode = argv.includes('--dev');
 	const skip_updates = argv.includes('--no-update');
 
 	if (is_dev_mode)
-		log('[{dev}] spooder has been started in {dev mode}');
+		log_cli('[{dev}] spooder has been started in {dev mode}');
 
 	const config = await get_config();
 
 	if (is_dev_mode) {
-		log('[{update}] skipping update commands in {dev mode}');
+		log_cli('[{update}] skipping update commands in {dev mode}');
 	} else if (skip_updates) {
-		log('[{update}] skipping update commands due to {--no-update} flag');
+		log_cli('[{update}] skipping update commands due to {--no-update} flag');
 	} else {
 		const update_commands = config.update;
 		const n_update_commands = update_commands.length;
 
 		if (n_update_commands > 0) {
-			log('running {%d} update commands', n_update_commands);
+			log_cli(`running {${n_update_commands}} updated commands`);
 
 			for (let i = 0; i < n_update_commands; i++) {
 				const config_update_command = update_commands[i];
 
-				log('[{%d}] %s', i, config_update_command);
+				log_cli(`[{${i}}] ${config_update_command}`);
 
 				const update_proc = Bun.spawn(parse_command_line(config_update_command), {
 					cwd: process.cwd(),
@@ -39,10 +89,10 @@ async function start_server() {
 
 				await update_proc.exited;
 
-				log('[{%d}] exited with code {%d}', i, update_proc.exitCode);
+				log_cli(`[{${i}}] exited with code {${update_proc.exitCode}}`);
 
 				if (update_proc.exitCode !== 0) {
-					log('aborting update due to non-zero exit code from [%d]', i);
+					log_cli(`aborting update due to non-zero exit code from [${i}]`);
 					break;
 				}
 			}
@@ -88,15 +138,15 @@ async function start_server() {
 	}
 	
 	const proc_exit_code = await proc.exited;
-	log('server exited with code {%s}', proc_exit_code);
+	log_cli(`server exited with code {${proc_exit_code}}`);
 	
 	if (proc_exit_code !== 0) {
 		const console_output = include_crash_history ? strip_color_codes(stream_history.join('\n')) : undefined;
 
 		if (is_dev_mode) {
-			log('[{dev}] crash: server exited unexpectedly (exit code {%d})', proc_exit_code);
-			log('[{dev}] without {--dev}, this would raise a canary report');
-			log('[{dev}] console output:\n%s', console_output);
+			log_cli(`[{dev}] crash: server exited unexpectedly (exit code {${proc_exit_code}}`);
+			log_cli(`[{dev}] without {--dev}, this would raise a canary report`);
+			log_cli(`[{dev}] console output:\n${console_output}`);
 		} else {
 			dispatch_report('crash: server exited unexpectedly', [{
 				proc_exit_code, console_output
@@ -104,15 +154,39 @@ async function start_server() {
 		}
 	}
 
-	const auto_restart_ms = config.auto_restart;
-	if (auto_restart_ms > -1) {
+	if (config.auto_restart) {
 		if (is_dev_mode) {
-			log('[{dev}] auto-restart is {disabled} in {dev mode}');
+			log_cli(`[{dev}] auto-restart is {disabled} in {dev mode}`);
 			process.exit(proc_exit_code ?? 0);
-		} else {
-			log('restarting server in {%dms}', auto_restart_ms);
-			setTimeout(start_server, auto_restart_ms);
+		} else if (proc_exit_code !== 0) {
+			if (restart_success_timer) {
+				clearTimeout(restart_success_timer);
+				restart_success_timer = null;
+			}
+			
+			if (config.auto_restart_attempts !== -1 && restart_attempts >= config.auto_restart_attempts) {
+				log_cli(`maximum restart attempts ({${config.auto_restart_attempts}}) reached, stopping auto-restart`);
+				process.exit(proc_exit_code ?? 0);
+			}
+			
+			restart_attempts++;
+			const current_delay = Math.min(restart_delay, config.auto_restart_max);
+			
+			const max_attempt_str = config.auto_restart_attempts === -1 ? '∞' : config.auto_restart_attempts;
+			log_cli(`restarting server in {${current_delay}ms} (attempt {${restart_attempts}}/{${max_attempt_str}}, delay capped at {${config.auto_restart_max}ms})`);
+			
+			setTimeout(() => {
+				restart_delay = Math.min(restart_delay * 2, config.auto_restart_max);
+				restart_success_timer = setTimeout(() => {
+					restart_delay = 100;
+					restart_attempts = 0;
+					restart_success_timer = null;
+				}, config.auto_restart_grace);
+				start_server();
+			}, current_delay);
 		}
+	} else {
+		log_cli(`auto-restart is {disabled}, exiting`);
 	}
 }
 

package/src/config.ts

@@ -1,9 +1,14 @@
 import path from 'node:path';
-import { log } from './utils';
+import { log_create_logger } from './api';
+
+const log_config = log_create_logger('config', 'spooder');
 
 const internal_config = {
 	run: 'bun run index.ts',
-	auto_restart: -1,
+	auto_restart: false,
+	auto_restart_max: 30000,
+	auto_restart_attempts: -1,
+	auto_restart_grace: 30000,
 	update: [],
 	canary: {
 		account: '',
@@ -30,7 +35,7 @@ function validate_config_option(source: ConfigObject, target: ConfigObject, root
 			const actual_type = typeof value;
 
 			if (actual_type !== expected_type) {
-				log('ignoring invalid configuration value {%s} (expected {%s}, got {%s})', key_name, expected_type, actual_type);
+				log_config(`ignoring invalid configuration value {${key_name}} (expected {${expected_type}}, got {${actual_type}})`);
 				continue;
 			}
 
@@ -40,14 +45,14 @@ function validate_config_option(source: ConfigObject, target: ConfigObject, root
 
 				if (is_default_array) {
 					if (!is_actual_array) {
-						log('ignoring invalid configuration value {%s} (expected array)', key_name);
+						log_config(`ignoring invalid configuration value {${key_name}} (expected array)`);
 						continue;
 					}
 
 					source[key as keyof Config] = value as Config[keyof Config];
 				} else {
 					if (is_actual_array) {
-						log('ignoring invalid configuration value `%s` (expected object)', key_name);
+						log_config(`ignoring invalid configuration value '${key_name}' (expected object)`);
 						continue;
 					}
 
@@ -57,7 +62,7 @@ function validate_config_option(source: ConfigObject, target: ConfigObject, root
 				source[key as keyof Config] = value as Config[keyof Config];
 			}
 		} else {
-			log('ignoring unknown configuration key {%s}', key_name);	
+			log_config(`ignoring unknown configuration key {${key_name}}`);
 		}
 	}
 }
@@ -68,13 +73,13 @@ async function load_config(): Promise<Config> {
 		const json = await config_file.json();
 
 		if (json.spooder === null || typeof json.spooder !== 'object') {
-			log('failed to parse spooder configuration in {package.json}, using defaults');
+			log_config('failed to parse spooder configuration in {package.json}, using defaults');
 			return internal_config;
 		}
 
 		validate_config_option(internal_config, json.spooder, 'spooder');
 	} catch (e) {
-		log('failed to read {package.json}, using configuration defaults');
+		log_config('failed to read {package.json}, using configuration defaults');
 	}
 
 	return internal_config;

package/src/dispatch.ts

@@ -1,10 +1,134 @@
 import { get_config } from './config';
-import { create_github_issue } from './github';
-import { log } from './utils';
+import { log_create_logger } from './api';
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 
+const log = log_create_logger('canary', 'spooder');
+
+// region github
+type GitHubInstallationResponse = Array<{
+	id: number,
+	account: {
+		login: string
+	},
+	access_tokens_url: string,
+	repositories_url: string
+}>;
+
+type GitHubAccessTokenResponse = {
+	token: string;
+};
+
+type GitHubRepositoryResponse = {
+	repositories: Array<{
+		full_name: string,
+		name: string,
+		url: string,
+		owner: {
+			login: string
+		}
+	}>
+};
+
+type GitHubIssueResponse = {
+	number: number,
+	url: string
+};
+
+type GitHubIssue = {
+	app_id: number,
+	private_key: string,
+	login_name: string,
+	repository_name: string,
+	issue_title: string,
+	issue_body: string
+	issue_labels?: Array<string>
+};
+
+function github_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 github_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 github_assert_res(res: Response, message: string): void {
+	if (!res.ok)
+		throw new Error(message + ' (' + res.status + ' ' + res.statusText + ')');
+}
+
+async function github_create_issue(issue: GitHubIssue): Promise<void> {
+	const jwt = github_generate_jwt(issue.app_id, issue.private_key);
+	const app_res = await github_request_endpoint('https://api.github.com/app', jwt);
+
+	github_assert_res(app_res, 'cannot authenticate GitHub app ' + issue.app_id);
+
+	const res_installs = await github_request_endpoint('https://api.github.com/app/installations', jwt);
+	github_assert_res(res_installs, 'cannot fetch GitHub app installations');
+
+	const json_installs = await res_installs.json() as GitHubInstallationResponse;
+
+	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 github_request_endpoint(install.access_tokens_url, jwt, 'POST');
+	github_assert_res(res_access_token, 'cannot fetch GitHub app access token');
+
+	const json_access_token = await res_access_token.json() as GitHubAccessTokenResponse;
+	const access_token = json_access_token.token;
+
+	const repositories = await github_request_endpoint(install.repositories_url, access_token);
+	github_assert_res(repositories, 'cannot fetch GitHub app repositories');
+
+	const repositories_json = await repositories.json() as GitHubRepositoryResponse;
+
+	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 github_request_endpoint(repository.url + '/issues', access_token, 'POST', {
+		title: issue.issue_title,
+		body: issue.issue_body,
+		labels: issue.issue_labels
+	});
+
+	github_assert_res(issue_res, 'cannot create GitHub issue');
+
+	const json_issue = await issue_res.json() as GitHubIssueResponse;
+	log(`raised issue {${json_issue.number}} in {${repository.full_name}}: ${json_issue.url}`);
+}
+// endregion
+
+// region canary
 async function load_local_env(): Promise<Map<string, string>> {
 	const env = new Map<string, string>();
 
@@ -54,7 +178,7 @@ async function save_cache_table(table: Map<bigint, number>, cache_file_path: str
 	}
 
 	await new Promise(resolve => fs.mkdir(path.dirname(cache_file_path), { recursive: true }, resolve));
-	await Bun.write(cache_file_path, data);
+	await Bun.write(cache_file_path, data.buffer);
 }
 
 async function check_cache_table(key: string, repository: string, expiry: number): Promise<boolean> {
@@ -93,9 +217,9 @@ async function check_cache_table(key: string, repository: string, expiry: number
 			}
 		}
 	} catch (e) {
-		log('[{canary}] failed to read canary cache file {%s}', cache_file_path);
-		log('[{canary}] error: ' + (e as Error).message);
-		log('[{canary}] 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('resolve this issue to prevent spamming GitHub with canary reports');
 	}
 
 	if (cache_table.has(key_hash)) {
@@ -159,13 +283,13 @@ export async function dispatch_report(report_title: string, report_body: Array<u
 		const canary_repostiory = config.canary.repository;
 
 		if (canary_account.length === 0|| canary_repostiory.length === 0) {
-			log('[{canary}] report dispatch failed; no account/repository configured');
+			log(`report dispatch failed; no canary account/repository configured`);
 			return;
 		}
 
 		const is_cached = await check_cache_table(report_title, canary_repostiory, config.canary.throttle);
 		if (is_cached) {
-			log('[{canary}] throttled canary report: {%s}', report_title);
+			log(`throttled canary report: {${report_title}}`);
 			return;
 		}
 
@@ -201,7 +325,7 @@ export async function dispatch_report(report_title: string, report_body: Array<u
 
 		issue_body = '```json\n' + issue_body + '\n```\n\nℹ️ *This issue has been created automatically in response to a server panic, caution or crash.*';
 
-		await create_github_issue({
+		await github_create_issue({
 			app_id,
 			private_key: await key_file.text(),
 			repository_name: canary_repostiory,
@@ -211,6 +335,7 @@ export async function dispatch_report(report_title: string, report_body: Array<u
 			issue_labels: config.canary.labels
 		});
 	} catch (e) {
-		log('[{canary error}] ' + (e as Error)?.message ?? 'unspecified error');
+		log((e as Error).message);
 	}
-}
+}
+// endregion