spooder 3.0.1 → 3.0.2

package/README.md

@@ -11,12 +11,16 @@
 ## Installation
 
 ```bash
+# Installing globally for CLI runner usage.
 bun add spooder --global
+
+# Install into local package for API usage.
+bun add spooder
 ```
 
 ## Runner
 
-`spooder` also includes a global command-line tool for running the server. It is recommended that you run this in a `screen` session.
+`spooder` includes a global command-line tool for running servers. It is recommended that you run this in a `screen` session.
 
 ```bash
 screen -S spooder # Create a new screen session
@@ -24,40 +28,65 @@ cd /var/www/my_server/
 spooder
 ```
 
-`spooder` will load the `module` defined in your `package.json` in a new process using `bun run <module>`. This can be overridden using the `entry` property of the `spooder section` in your `package.json`.
+While the intended use of this runner is for web servers, it can be used to run anything. It provides two primary features: automatic updating and restarting.
+
+### Entry Point
+
+`spooder` will attempt to launch the server from the current working directory using the command `bun run index.ts` as a default.
+
+To customize this, provide an alternative command via the `run` configuration.
 
 ```json
 {
 	"spooder": {
-		"entry": "index.ts"
+		"run": "bun run my_server.ts"
 	}
 }
 ```
 
-In the event that the server exits (regardless of exit code), `spooder` will automatically restart it after a short delay. This delay is configurable in the `spooder` section of your `package.json`.
+While `spooder` uses a `bun run` command by default, it is possible to use any command string.
+
+It is possible to chain commands, such as updating your source with `git pull && bun run index.ts`, however it is recommended that `run` is only used to launch the service. Instead, use the `update` property for updating which will fail gracefully and will not block the server from starting.
+
+### Auto Restart
+
+In the event that the server exits (regardless of exit code), `spooder` will automatically restart it after a short delay.
+
+This feature is enabled by default with a delay of `5000` milliseconds. The delay can be changed by providing a value for `autoRestart` in the configuration.
 
 ```json
 {
 	"spooder": {
-		"autoRestart": true, // Defaults to true.
-		"restartDelay": 5000, // Defaults to 5000ms.
+		"autoRestart": 5000
 	}
 }
 ```
 
-When starting your server, `spooder` can automatically update the source code by running `git pull` in the working directory. This feature is disabled by default and can be enabled in the `spooder` section of your `package.json`.
+If set to `0`, the server will be restarted immediately without delay. If set to `-1`, the server will not be restarted at all.
+
+### Auto Update
+
+When starting your server, `spooder` can automatically update the source code in the working directory. To enable this feature, provide an update command as `update` in the configuration.
 
 ```json
 {
 	"spooder": {
-		"autoUpdate": true // Defaults to false.
+		"update": "git pull && bun install"
 	}
 }
 ```
+It is worth nothing that if the `update` command fails to execute, the server will still be started. This is preferred over entering a restart loop or failing to start the server at all.
 
-When `autoUpdate` is enabled, your server process can initiate a self-update by terminating with the exit code `205`. This will cause `spooder` to run `git pull` and restart the server, which can be useful for responding to webhooks.
+As well as being executed when the server is first started, the `update` command is also run when `spooder` automatically restarts the server after it exits.
 
-If `autoUpdate` is disabled, all exit codes will be considered a crash and the server will be restarted if `autoRestart` is enabled.
+You can utilize this to automatically update your server in response to a webhook or other event by simply exiting the process.
+
+```ts
+events.on('receive-webhook', () => {
+	// <- Gracefully finish processing here.
+	process.exit(0);
+});
+```
 
 ## API
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "spooder",
 	"type": "module",
-	"version": "3.0.1",
+	"version": "3.0.2",
 	"exports": {
 		".": {
 			"bun": "./src/api.ts",
@@ -14,6 +14,6 @@
 		"bun-types": "^0.5.0"
 	},
 	"bin": {
-		"spooder": "./src/cli.ts"
+		"spooder": "bun run ./src/cli.ts"
 	}
 }

package/src/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/src/cli.ts

@@ -1 +1,98 @@
-console.log('Welcome to the Spooder CLI!');
+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_update_command = config.update as string ?? '';
+const config_run_command = config.run as string ?? 'bun run index.ts';
+const config_auto_restart_ms = config.autoRestart as number ?? 5000;
+
+async function start_server() {
+	log('start_server');
+
+	if (config_update_command.length > 0) {
+		log('running update command: %s', config_update_command);
+		const update = Bun.spawn(parse_command(config_update_command), {
+			cwd: process.cwd(),
+			stdout: 'inherit',
+			stderr: 'inherit'
+		});
+
+		await update.exited;
+		log('auto update exited with code %d', update.exitCode)
+	}
+
+	const server_process = Bun.spawn(parse_command(config_run_command), {
+		cwd: process.cwd(),
+		stdout: 'inherit',
+		stderr: 'inherit'
+	});
+
+	log('server process started with pid %d', server_process.pid);
+
+	server_process.exited.then(() => {
+		log('server exited with code %d', server_process.exitCode);
+
+		if (config_auto_restart_ms > -1) {
+			log('restarting server in %dms', config_auto_restart_ms);
+			setTimeout(start_server, config_auto_restart_ms);
+		}
+	});
+}
+
+start_server();