spooder 3.0.8 → 3.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "spooder",
 	"type": "module",
-	"version": "3.0.8",
+	"version": "3.2.0",
 	"exports": {
 		".": {
 			"bun": "./src/api.ts",
@@ -15,5 +15,8 @@
 	},
 	"bin": {
 		"spooder": "./src/cli.ts"
+	},
+	"dependencies": {
+		"@octokit/app": "^13.1.5"
 	}
 }

package/src/api.d.ts

@@ -1 +1,28 @@
-export declare function test_api(): void;
+/// <reference types="bun-types" />
+/// <reference types="node" />
+export declare function panic(err_message_or_obj: string | object, ...err: object[]): Promise<void>;
+export declare function caution(err_message_or_obj: string | object, ...err: object[]): Promise<void>;
+type HandlerReturnType = any;
+type RequestHandler = (req: Request, url: URL) => HandlerReturnType;
+type ErrorHandler = (err: Error) => Response;
+type DefaultHandler = (req: Request, status_code: number) => HandlerReturnType;
+type StatusCodeHandler = (req: Request) => HandlerReturnType;
+type DirOptions = {
+    ignoreHidden?: boolean;
+    index?: string;
+};
+/** Built-in route handler for redirecting to a different URL. */
+export declare function route_location(redirect_url: string): (req: Request, url: URL) => Response;
+export declare function serve(port: number): {
+    /** Register a handler for a specific route. */
+    route: (path: string, handler: RequestHandler) => void;
+    /** Serve a directory for a specific route. */
+    dir: (path: string, dir: string, options?: DirOptions) => void;
+    /** Register a default handler for all status codes. */
+    default: (handler: DefaultHandler) => void;
+    /** Register a handler for a specific status code. */
+    handle: (status_code: number, handler: StatusCodeHandler) => void;
+    /** Register a handler for uncaught errors. */
+    error: (handler: ErrorHandler) => void;
+};
+export {};

package/src/api.ts

@@ -1,3 +1,243 @@
-export function test_api() {
-	console.log('test_api :: hello world!');
+import { dispatch_report } from './dispatch';
+import http from 'node:http';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+async function handle_error(prefix: string, err_message_or_obj: string | object, ...err: unknown[]): Promise<void> {
+	let error_message = 'unknown error';
+
+	if (typeof err_message_or_obj === 'string') {
+		error_message = err_message_or_obj;
+		err.unshift(error_message);
+	} else {
+		if (err_message_or_obj instanceof Error)
+			error_message = err_message_or_obj.message;
+
+		err.push(err_message_or_obj);
+	}
+
+	// Serialize error objects.
+	err = err.map(e => {
+		if (e instanceof Error) {
+			return {
+				name: e.name,
+				message: e.message,
+				stack: e.stack?.split('\n') ?? []
+			}
+		}
+
+		return e;
+	})
+
+	await dispatch_report(prefix + error_message, err);
+}
+
+export async function panic(err_message_or_obj: string | object, ...err: object[]): Promise<void> {
+	await handle_error('panic: ', err_message_or_obj, ...err);
+	process.exit(1);
+}
+
+export async function caution(err_message_or_obj: string | object, ...err: object[]): Promise<void> {
+	await handle_error('caution: ', err_message_or_obj, ...err);
+}
+
+type HandlerReturnType = any;
+type RequestHandler = (req: Request, url: URL) => HandlerReturnType;
+type ErrorHandler = (err: Error) => Response;
+type DefaultHandler = (req: Request, status_code: number) => HandlerReturnType;
+type StatusCodeHandler = (req: Request) => HandlerReturnType;
+
+type DirOptions = {
+	ignoreHidden?: boolean;
+	index?: string;
+};
+
+/** Built-in route handler for redirecting to a different URL. */
+export function route_location(redirect_url: string) {
+	return (req: Request, url: URL) => {
+		return new Response(null, {
+			status: 301,
+			headers: {
+				Location: redirect_url
+			}
+		});
+	};
+}
+
+function route_directory(route_path: string, dir: string, options: DirOptions): RequestHandler {
+	const ignore_hidden = options.ignoreHidden ?? true;
+
+	return async (req: Request, url: URL) => {
+		const file_path = path.join(dir, url.pathname.slice(route_path.length));
+
+		if (ignore_hidden && path.basename(file_path).startsWith('.'))
+			return 404;
+
+		try {
+			const file_stat = await fs.stat(file_path);
+
+			if (file_stat.isDirectory()) {
+				if (options.index !== undefined) {
+					const index_path = path.join(file_path, options.index);
+					const index = Bun.file(index_path);
+
+					if (index.size !== 0)
+						return index;
+				}
+				return 401;
+			}
+
+			return Bun.file(file_path);
+		} catch (e) {
+			const err = e as NodeJS.ErrnoException;
+			if (err?.code === 'ENOENT')
+				return 404;
+
+			return 500;
+		}
+	};
+}
+
+export function serve(port: number) {
+	const routes = new Map<string[], RequestHandler>();
+	const handlers = new Map<number, StatusCodeHandler>();
+	
+	let error_handler: ErrorHandler | undefined;
+	let default_handler: DefaultHandler | undefined;
+
+	async function resolve_handler(response: HandlerReturnType | Promise<HandlerReturnType>, status_code: number, return_status_code = false): Promise<Response | number> {
+		if (response instanceof Promise)
+			response = await response;
+
+		// Pre-assembled responses are returned as-is.
+		if (response instanceof Response)
+			return response;
+	
+		// Content-type/content-length are automatically set for blobs.
+		if (response instanceof Blob)
+			return new Response(response, { status: status_code });
+
+		// Status codes can be returned from some handlers.
+		if (return_status_code && typeof response === 'number')
+			return response;
+
+		// This should cover objects, arrays, etc.
+		if (typeof response === 'object')
+			return new Response(JSON.stringify(response), { status: status_code, headers: { 'Content-Type': 'application/json' } });
+	
+		return new Response(String(response), { status: status_code })
+	}
+
+	const server = Bun.serve({
+		port,
+		development: false,
+
+		async fetch(req: Request): Promise<Response> {
+			const url = new URL(req.url);
+			let status_code = 200;
+
+			console.log(`${req.method} ${url.pathname}`);
+
+			const route_array = url.pathname.split('/').filter(e => !(e === '..' || e === '.'));
+			let handler: RequestHandler | undefined;
+
+			for (const [path, route_handler] of routes) {
+				const is_trailing_wildcard = path[path.length - 1] === '*';
+				if (!is_trailing_wildcard && path.length !== route_array.length)
+					continue;
+
+				let match = true;
+				for (let i = 0; i < path.length; i++) {
+					const path_part = path[i];
+
+					if (path_part === '*')
+						continue;
+
+					if (path_part.startsWith(':')) {
+						url.searchParams.append(path_part.slice(1), route_array[i]);
+						continue;
+					}
+
+					if (path_part !== route_array[i]) {
+						match = false;
+						break;
+					}
+				}
+
+				if (match) {
+					handler = route_handler;
+					break;
+				}
+			}
+
+			// Check for a handler for the route.
+			if (handler !== undefined) {
+				const response = await resolve_handler(handler(req, url), status_code, true);
+				if (response instanceof Response)
+					return response;
+
+				// If the handler returned a status code, use that instead.
+				status_code = response;
+			} else {
+				status_code = 404;
+			}
+
+			// Fallback to checking for a handler for the status code.
+			const status_code_handler = handlers.get(status_code);
+			if (status_code_handler !== undefined) {
+				const response = await resolve_handler(status_code_handler(req), status_code);
+				if (response instanceof Response)
+					return response;
+			}
+
+			// Fallback to the default handler, if any.
+			if (default_handler !== undefined) {
+				const response = await resolve_handler(default_handler(req, status_code), status_code);
+				if (response instanceof Response)
+					return response;
+			}
+
+			// Fallback to returning a basic response.
+			return new Response(http.STATUS_CODES[status_code], { status: status_code });
+		},
+
+		error(err: Error): Response {
+			if (error_handler !== undefined)
+				return error_handler(err);
+
+			return new Response(http.STATUS_CODES[500], { status: 500 });
+		}
+	});
+
+	console.log(`Server started on port ${port}`);
+
+	return {
+		/** Register a handler for a specific route. */
+		route: (path: string, handler: RequestHandler): void => {
+			routes.set(path.split('/'), handler);
+		},
+
+		/** Serve a directory for a specific route. */
+		dir: (path: string, dir: string, options?: DirOptions): void => {
+			if (path.endsWith('/'))
+				path = path.slice(0, -1);
+
+			routes.set([...path.split('/'), '*'], route_directory(path, dir, options ?? {}));
+		},
+
+		/** Register a default handler for all status codes. */
+		default: (handler: DefaultHandler): void => {
+			default_handler = handler;
+		},
+
+		/** Register a handler for a specific status code. */
+		handle: (status_code: number, handler: StatusCodeHandler): void => {
+			handlers.set(status_code, handler);
+		},
+
+		/** Register a handler for uncaught errors. */
+		error: (handler: ErrorHandler): void => {
+			error_handler = handler;
+		}
+	}
 }

package/src/cli.ts

@@ -1,87 +1,25 @@
 #!/usr/bin/env bun
-import path from 'node:path';
-
-type Config = Record<string, unknown>;
-
-async function load_config(): Promise<Config> {
-	try {
-		const config_file = Bun.file(path.join(process.cwd(), 'package.json'));
-		const json = await config_file.json();
-
-		return json?.spooder ?? {};
-	} catch (e) {
-		return {};
-	}
-}
-
-function parse_command(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;
-}
-
-function log(message: string, ...args: unknown[]): void {
-	console.log('[spooder] ' + message, ...args);
-}
-
-const config = await load_config();
-const config_run_command = config.run as string ?? 'bun run index.ts';
-const config_auto_restart_ms = config.autoRestart as number ?? 5000;
-
-let config_update_commands = [] as string[];
-if (config.update) {
-	if (typeof config.update === 'string')
-		config_update_commands = [config.update]
-	else if (Array.isArray(config.update))
-		config_update_commands = config.update;
-}
+import { get_config } from './config';
+import { parse_command_line, log, strip_color_codes } from './utils';
+import { dispatch_report } from './dispatch';
 
 async function start_server() {
 	log('start_server');
 
-	if (config_update_commands.length > 0) {
-		log('running %d update commands', config_update_commands.length);
+	const config = await get_config();
+
+	const update_commands = config.update;
+	const n_update_commands = update_commands.length;
 
-		for (let i = 0; i < config_update_commands.length; i++) {
-			const config_update_command = config_update_commands[i];
+	if (n_update_commands > 0) {
+		log('running %d update commands', n_update_commands);
+
+		for (let i = 0; i < n_update_commands; i++) {
+			const config_update_command = update_commands[i];
 
 			log('[%d] %s', i, config_update_command);
 
-			const update_proc = Bun.spawn(parse_command(config_update_command), {
+			const update_proc = Bun.spawn(parse_command_line(config_update_command), {
 				cwd: process.cwd(),
 				stdout: 'inherit',
 				stderr: 'inherit'
@@ -98,17 +36,35 @@ async function start_server() {
 		}
 	}
 
-	Bun.spawn(parse_command(config_run_command), {
+	Bun.spawn(parse_command_line(config.run), {
 		cwd: process.cwd(),
 		stdout: 'inherit',
-		stderr: 'inherit',
+		stderr: 'pipe',
 
 		onExit: (proc, exitCode, signal) => {
 			log('server exited with code %d', exitCode);
 
-			if (config_auto_restart_ms > -1) {
-				log('restarting server in %dms', config_auto_restart_ms);
-				setTimeout(start_server, config_auto_restart_ms);
+			if (exitCode !== null && exitCode > 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', [{
+							exitCode,
+							stderr: strip_color_codes(stderr).split(/\r?\n/)
+						}]);
+					});
+				} else {
+					dispatch_report('crash: service exited unexpectedly', [{
+						exitCode
+					}]);
+				}
+			}
+
+			const auto_restart_ms = config.autoRestart;
+			if (auto_restart_ms > -1) {
+				log('restarting server in %dms', auto_restart_ms);
+				setTimeout(start_server, auto_restart_ms);
 			}
 		}
 	});

package/src/config.d.ts

@@ -0,0 +1,15 @@
+declare const internal_config: {
+    run: string;
+    autoRestart: number;
+    update: never[];
+    canary: {
+        account: string;
+        repository: string;
+        labels: never[];
+        throttle: number;
+        sanitize: boolean;
+    };
+};
+type Config = typeof internal_config;
+export declare function get_config(): Promise<Config>;
+export {};

package/src/config.ts

@@ -0,0 +1,78 @@
+import path from 'node:path';
+import { warn } from './utils';
+
+const internal_config = {
+	run: 'bun run index.ts',
+	autoRestart: -1,
+	update: [],
+	canary: {
+		account: '',
+		repository: '',
+		labels: [],
+		throttle: 86400,
+		sanitize: true
+	}
+};
+
+type Config = typeof internal_config;
+type ConfigObject = Record<string, unknown>;
+
+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}`;
+		if (key in source) {
+			const default_value = source[key as keyof Config];
+			const expected_type = typeof default_value;
+
+			const actual_type = typeof value;
+
+			if (actual_type !== expected_type) {
+				warn('ignoring invalid configuration value `%s` (expected %s, got %s)', key_name, expected_type, actual_type);
+				continue;
+			}
+
+			if (actual_type === 'object') {
+				const is_default_array = Array.isArray(default_value);
+				const is_actual_array = Array.isArray(value);
+
+				if (is_default_array) {
+					if (!is_actual_array) {
+						warn('ignoring invalid configuration value `%s` (expected array)', key_name);
+						continue;
+					}
+
+					source[key as keyof Config] = value as Config[keyof Config];
+				} else {
+					if (is_actual_array) {
+						warn('ignoring invalid configuration value `%s` (expected object)', key_name);
+						continue;
+					}
+
+					validate_config_option(default_value as ConfigObject, value as ConfigObject, key_name);
+				}
+			} else {
+				source[key as keyof Config] = value as Config[keyof Config];
+			}
+		} else {
+			warn('ignoring unknown configuration key `%s`', key_name);	
+		}
+	}
+}
+
+export async function get_config(): Promise<Config> {
+	try {
+		const config_file = Bun.file(path.join(process.cwd(), 'package.json'));
+		const json = await config_file.json();
+
+		if (json.spooder === null || typeof json.spooder !== 'object') {
+			warn('failed to parse spooder configuration in package.json, using defaults');
+			return internal_config;
+		}
+
+		validate_config_option(internal_config, json.spooder, 'spooder');
+	} catch (e) {
+		warn('failed to read package.json, using configuration defaults');
+	}
+
+	return internal_config;
+}

package/src/dispatch.d.ts

@@ -0,0 +1 @@
+export declare function dispatch_report(report_title: string, report_body: Array<unknown>): Promise<void>;