spooder 2.0.5 → 2.0.7

package/README.md

@@ -16,5 +16,26 @@ The `instance` is an API that can be imported into a Bun process to scaffold a w
 
 The `watcher` is a daemon responsible for updating, starting and monitoring a collection of `instance` processes. It is intended to be run as a service on the host machine.
 
+## Watcher
+
+```toml
+# /var/www/spooder.toml
+[[domains]]
+name = "testdomain.net"
+path = "/var/www/testdomain.net"
+port = 3000
+```
+
+```bash
+# Installation
+bun add spooder -g
+```
+
+```bash
+# Running the watcher
+screen -S spooder # Create a new screen session
+spooder
+```
+
 ## License
 The code in this repository is licensed under the ISC license. See the [LICENSE](LICENSE) file for more information.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "spooder",
 	"type": "module",
-	"version": "2.0.5",
+	"version": "2.0.7",
 	"exports": {
 		".": {
 			"bun": "./src/api.ts",
@@ -9,9 +9,15 @@
 		}
 	},
 	"bin": {
-		"spooder": "./src/watcher.ts"
+		"spooder": "./src/instance.ts",
+		"spooder-update": "./src/update.ts",
+		"spooder-heartbeat": "./src/heartbeat.ts"
 	},
 	"devDependencies": {
+		"@types/node": "^20.0.0",
 		"bun-types": "^0.5.0"
+	},
+	"dependencies": {
+		"zod": "^3.21.4"
 	}
 }

package/src/heartbeat.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env bun
+
+// TODO: Iterate over all directories in /var/www and identify which ones are spooder domains.
+// TODO: For each spooder domain, check if the process is running.
+// TODO: Run `spooder` inside any domain directory that is not running.
+// TODO: Report crashed domains somewhere/somehow?

package/src/instance.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/src/instance.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env bun
+
+import { join } from 'node:path';
+
+async function write_pid_file() {
+	const pid_file = join(process.cwd(), '.spooder_pid');
+	await Bun.write(pid_file, process.pid.toString());
+}
+
+async function main() {
+	await write_pid_file();
+
+	const index_file = join(process.cwd(), 'index.ts');
+	// TODO: Add error handling if index_file does not exist?
+
+	const module = await import(index_file);
+	console.log(module);
+	// TODO: Add a route for GitHub webhooks.
+	// TODO: Add authentication for the webhook to prevent abuse.
+	// TODO: Run `spooder-update` when the webhook is triggered, then self-terminate.
+}
+
+main();

package/src/update.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/src/update.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env bun
+
+import { join } from 'node:path';
+import { z } from 'zod';
+
+const ConfigSchema = z.object({
+	domain: z.object({
+		name: z.string(),
+		port: z.number()
+	}),
+
+	git: z.object({
+		url: z.string(),
+		branch: z.string().default('main')
+	}).optional()
+});
+
+async function get_last_pid() : Promise<number> {
+	const pid_file = Bun.file(join(process.cwd(), '.spooder_pid'));
+	if (pid_file.size > 0) {
+		const pid = parseInt(await pid_file.text());
+		if (!isNaN(pid))
+			return pid;
+	}
+
+	return -1;
+}
+
+async function pid_is_running(pid: number) : Promise<boolean> {
+	const process = Bun.spawnSync(['ps', '-p', pid.toString()]);
+	if (!process.success)
+		return false;
+
+	const stdout = process.stdout?.toString();
+
+	// Ensure stdout contains more than one line.
+	if (!stdout || stdout.split('\n').length <= 1)
+		return false;
+
+	return false;
+}
+
+async function wait_for_pid_to_exit(pid: number) : Promise<void> {
+	console.log(`Waiting for process ${pid} to exit...`);
+	while (await pid_is_running(pid))
+		await Bun.sleep(1000);
+}
+
+function is_git_repository(directory: string): boolean {
+	// The command `git rev-parse --is-inside-work-tree` returns `true` to stdout
+	// if the current working directory is inside a git repository.
+	const process = Bun.spawnSync(['git', 'rev-parse', '--is-inside-work-tree'], { cwd: directory });
+	return process.stdout?.toString().trim() === 'true';
+}
+
+function pull_git_repository(directory: string, url: string, branch: string) {
+	console.log(`Pulling git repository ${branch} @ ${url} into ${directory}...`);
+	const process = Bun.spawnSync(['git', 'pull', url, branch], { cwd: directory });
+	if (!process.success)
+		throw new Error('Failed to pull git repository.');
+}
+
+function init_git_repository(directory: string) {
+	console.log(`Initializing git repository in ${directory}...`);
+	const process = Bun.spawnSync(['git', 'init'], { cwd: directory });
+	if (!process.success)
+		throw new Error('Failed to initialize git repository.');
+}
+
+async function load_configuration() {
+	const config_file = join(process.cwd(), 'spooder.toml');
+	return ConfigSchema.parse(await import(config_file));
+}
+
+async function main() {
+	const config = await load_configuration();
+
+	// Wait for the previous process, if it exists, to exit.
+	await wait_for_pid_to_exit(await get_last_pid());
+
+	const cwd = process.cwd();
+	if (config.git) {
+		if (!is_git_repository(cwd))
+			init_git_repository(cwd);
+		
+		pull_git_repository(cwd, config.git.url, config.git.branch);
+	}
+	
+	const server = Bun.spawn(['spooder'], { cwd });
+	server.unref();
+}
+
+main();

package/tsconfig.json

@@ -16,6 +16,7 @@
 		"declaration": true,
 		"allowJs": true,
 		"types": [
+			"node",
 			"bun-types" // add Bun global
 		]
 	}

package/src/api.d.ts

@@ -1,2 +0,0 @@
-declare function test_function(): void;
-export { test_function };

package/src/api.ts

@@ -1,5 +0,0 @@
-function test_function() {
-	console.log("Hello World");
-}
-
-export { test_function };

package/src/watcher.ts

@@ -1,7 +0,0 @@
-#!/usr/bin/env bun
-
-console.log('Begin test.');
-
-setInterval(() => {
-	console.log('This is a test.');
-}, 1000);