flightdeck 0.0.0

package/package.json

@@ -0,0 +1,49 @@
+{
+	"name": "flightdeck",
+	"version": "0.0.0",
+	"license": "MIT",
+	"author": {
+		"name": "Jeremy Banka",
+		"email": "hello@jeremybanka.com"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"type": "module",
+	"files": ["dist", "src"],
+	"main": "dist/lib.js",
+	"types": "dist/lib.d.ts",
+	"bin": {
+		"flightdeck": "./dist/bin.js"
+	},
+	"dependencies": {
+		"atom.io": "workspace:*",
+		"comline": "workspace:*",
+		"zod": "3.23.8"
+	},
+	"scripts": {
+		"build": "rimraf dist && concurrently \"bun:build:*\" && bun run schema",
+		"build:lib": "bun build --outdir dist --target node --external flightdeck -- src/lib.ts ",
+		"build:bin": "bun build --outdir dist --target node --external flightdeck -- src/bin.ts",
+		"build:dts": "tsup",
+		"schema": "bun ./src/bin.ts --outdir=dist -- schema",
+		"lint:biome": "biome check -- .",
+		"lint:eslint": "eslint --flag unstable_ts_config -- .",
+		"lint:types": "tsc --noEmit",
+		"lint:types:watch": "tsc --watch --noEmit",
+		"lint": "bun run lint:biome && bun run lint:eslint && bun run lint:types",
+		"test": "vitest",
+		"test:once": "vitest run",
+		"test:coverage": "echo no test coverage yet"
+	},
+	"devDependencies": {
+		"@types/bun": "1.1.8",
+		"@types/node": "20.16.3",
+		"@types/tmp": "0.2.6",
+		"concurrently": "8.2.2",
+		"tmp": "0.2.3",
+		"tsup": "8.2.4",
+		"rimraf": "6.0.1",
+		"vitest": "2.0.5"
+	}
+}

package/src/bin.ts

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+import * as path from "node:path"
+
+import type { OptionsGroup } from "comline"
+import { cli, optional, parseArrayOption } from "comline"
+import type { FlightDeckOptions } from "flightdeck"
+import { FlightDeck } from "flightdeck"
+import { z } from "zod"
+
+const FLIGHTDECK_MANUAL = {
+	optionsSchema: z.object({
+		secret: z.string(),
+		repo: z.string(),
+		app: z.string(),
+		runCmd: z.array(z.string()),
+		serviceDir: z.string(),
+		updateCmd: z.array(z.string()),
+	}),
+	options: {
+		secret: {
+			flag: `s`,
+			required: true,
+			description: `Secret used to authenticate with the service.`,
+			example: `--secret=\"secret\"`,
+		},
+		repo: {
+			flag: `r`,
+			required: true,
+			description: `Name of the repository.`,
+			example: `--repo=\"sample/repo\"`,
+		},
+		app: {
+			flag: `a`,
+			required: true,
+			description: `Name of the application.`,
+			example: `--app=\"my-app\"`,
+		},
+		runCmd: {
+			flag: `r`,
+			required: true,
+			description: `Command to run the application.`,
+			example: `--runCmd=\"./app\"`,
+			parse: parseArrayOption,
+		},
+		serviceDir: {
+			flag: `d`,
+			required: true,
+			description: `Directory where the service is stored.`,
+			example: `--serviceDir=\"./services/sample/repo/my-app/current\"`,
+		},
+		updateCmd: {
+			flag: `u`,
+			required: true,
+			description: `Command to update the service.`,
+			example: `--updateCmd=\"./app\"`,
+			parse: parseArrayOption,
+		},
+	},
+} satisfies OptionsGroup<FlightDeckOptions>
+
+const SCHEMA_MANUAL = {
+	optionsSchema: z.object({
+		outdir: z.string().optional(),
+	}),
+	options: {
+		outdir: {
+			flag: `o`,
+			required: false,
+			description: `Directory to write the schema to.`,
+			example: `--outdir=./dist`,
+		},
+	},
+} satisfies OptionsGroup<{ outdir?: string | undefined }>
+
+const parse = cli(
+	{
+		cliName: `flightdeck`,
+		routes: optional({ schema: null, $configPath: null }),
+		routeOptions: {
+			"": FLIGHTDECK_MANUAL,
+			$configPath: FLIGHTDECK_MANUAL,
+			schema: SCHEMA_MANUAL,
+		},
+		discoverConfigPath: (args) => {
+			if (args[0] === `schema`) {
+				return
+			}
+			const configPath =
+				args[0] ?? path.join(process.cwd(), `flightdeck.config.json`)
+			return configPath
+		},
+	},
+	console,
+)
+
+const { inputs, writeJsonSchema } = parse(process.argv)
+
+switch (inputs.case) {
+	case `schema`:
+		{
+			const { outdir } = inputs.opts
+			writeJsonSchema(outdir ?? `.`)
+		}
+		break
+	default: {
+		const flightDeck = new FlightDeck(inputs.opts)
+		process.on(`close`, async () => {
+			flightDeck.stopService()
+			await flightDeck.dead
+		})
+	}
+}

package/src/flightdeck.ts

@@ -0,0 +1,235 @@
+import { execSync, spawn } from "node:child_process"
+import { existsSync, mkdirSync, renameSync, rmSync, unlinkSync } from "node:fs"
+import type { Http2Server } from "node:http2"
+import { createServer } from "node:http2"
+import { homedir } from "node:os"
+import { resolve } from "node:path"
+
+import { Future } from "atom.io/internal"
+import { ChildSocket } from "atom.io/realtime-server"
+
+export type FlightDeckOptions = {
+	secret: string
+	repo: string
+	app: string
+	runCmd: string[]
+	updateCmd: string[]
+	serviceDir?: string | undefined
+}
+
+let safety = 0
+const PORT = process.env.PORT ?? 8080
+const ORIGIN = `http://localhost:${PORT}`
+export class FlightDeck {
+	public get serviceName(): string {
+		return `${this.options.repo}/${this.options.app}`
+	}
+
+	protected webhookServer: Http2Server
+	protected service: ChildSocket<
+		{ updatesReady: [] },
+		{ readyToUpdate: []; alive: [] }
+	> | null = null
+	protected restartTimes: number[] = []
+
+	public alive = new Future(() => {})
+	public dead = new Future(() => {})
+
+	public readonly currentServiceDir: string
+	public readonly updateServiceDir: string
+	public readonly backupServiceDir: string
+
+	public constructor(public readonly options: FlightDeckOptions) {
+		const {
+			secret,
+			serviceDir = resolve(
+				homedir(),
+				`services`,
+				`sample/repo`,
+				`my-app`,
+				`current`,
+			),
+		} = options
+
+		this.currentServiceDir = resolve(serviceDir, `current`)
+		this.backupServiceDir = resolve(serviceDir, `backup`)
+		this.updateServiceDir = resolve(serviceDir, `update`)
+
+		createServer((req, res) => {
+			let data: Uint8Array[] = []
+			req
+				.on(`data`, (chunk) => {
+					data.push(chunk instanceof Buffer ? chunk : Buffer.from(chunk))
+				})
+				.on(`end`, () => {
+					console.log(req.headers)
+					const authHeader = req.headers.authorization
+					try {
+						if (authHeader !== `Bearer ${secret}`) throw 401
+						const url = new URL(req.url, ORIGIN)
+						console.log(req.method, url.pathname)
+						switch (req.method) {
+							case `POST`:
+								{
+									console.log(`received post, url is ${url.pathname}`)
+									switch (url.pathname) {
+										case `/`:
+											{
+												res.writeHead(200)
+												res.end()
+												this.fetchLatestRelease()
+												if (this.service) {
+													this.service.emit(`updatesReady`)
+												} else {
+													this.applyUpdate()
+													this.startService()
+												}
+											}
+											break
+
+										default:
+											throw 404
+									}
+								}
+								break
+
+							default:
+								throw 405
+						}
+					} catch (thrown) {
+						console.error(thrown, req.url)
+						if (typeof thrown === `number`) {
+							res.writeHead(thrown)
+							res.end()
+						}
+					} finally {
+						data = []
+					}
+				})
+		}).listen(PORT, () => {
+			console.log(`Server started on port ${PORT}`)
+		})
+
+		this.startService()
+	}
+
+	protected startService(): void {
+		safety++
+		if (safety > 10) {
+			throw new Error(`safety exceeded`)
+		}
+		if (!existsSync(this.currentServiceDir)) {
+			console.log(
+				`Tried to start service but failed: Service ${this.serviceName} is not yet installed.`,
+			)
+			this.fetchLatestRelease()
+			this.applyUpdate()
+			this.startService()
+
+			return
+		}
+
+		const [executable, ...args] = this.options.runCmd
+		const program = executable.startsWith(`./`)
+			? resolve(this.currentServiceDir, executable)
+			: executable
+		const serviceProcess = spawn(program, args, {
+			cwd: this.currentServiceDir,
+			env: import.meta.env,
+		})
+		this.service = new ChildSocket(serviceProcess, this.serviceName, console)
+		this.service.onAny((...messages) => {
+			console.log(`🛰 `, ...messages)
+		})
+		this.service.on(`readyToUpdate`, () => {
+			this.stopService()
+		})
+		this.service.on(`alive`, () => {
+			this.alive.use(Promise.resolve())
+			this.dead = new Future(() => {})
+		})
+		this.service.process.on(`close`, (exitCode) => {
+			console.log(`Service ${this.serviceName} exited with code ${exitCode}`)
+			this.service = null
+			const updatesAreReady = existsSync(this.updateServiceDir)
+			if (updatesAreReady) {
+				console.log(`Updates are ready; applying and restarting...`)
+				this.restartTimes = []
+				this.applyUpdate()
+				this.startService()
+			} else {
+				if (exitCode !== 0) {
+					const now = Date.now()
+					const fiveMinutesAgo = now - 5 * 60 * 1000
+					this.restartTimes = this.restartTimes.filter(
+						(time) => time > fiveMinutesAgo,
+					)
+					this.restartTimes.push(now)
+
+					if (this.restartTimes.length < 5) {
+						console.log(`Service ${this.serviceName} crashed. Restarting...`)
+						this.startService()
+					} else {
+						console.log(
+							`Service ${this.serviceName} crashed too many times. Not restarting.`,
+						)
+					}
+				}
+			}
+		})
+	}
+
+	protected applyUpdate(): void {
+		console.log(`Installing latest version of service ${this.serviceName}...`)
+
+		if (existsSync(this.updateServiceDir)) {
+			if (this.service) {
+				console.log(
+					`Tried to apply update but failed: Service ${this.serviceName} is currently running.`,
+				)
+				return
+			}
+
+			if (existsSync(this.currentServiceDir)) {
+				if (!existsSync(this.backupServiceDir)) {
+					mkdirSync(this.backupServiceDir, { recursive: true })
+				} else {
+					rmSync(this.backupServiceDir, { recursive: true })
+				}
+				renameSync(this.currentServiceDir, this.backupServiceDir)
+			}
+
+			renameSync(this.updateServiceDir, this.currentServiceDir)
+			this.restartTimes = []
+		} else {
+			console.log(`Service ${this.serviceName} is already up to date.`)
+		}
+	}
+
+	protected fetchLatestRelease(): void {
+		console.log(`Downloading latest version of service ${this.serviceName}...`)
+
+		try {
+			execSync(this.options.updateCmd.join(` `))
+		} catch (thrown) {
+			if (thrown instanceof Error) {
+				console.error(`Failed to fetch the latest release: ${thrown.message}`)
+			}
+			return
+		}
+	}
+
+	public stopService(): void {
+		if (this.service) {
+			console.log(`Stopping service ${this.serviceName}...`)
+			this.service.process.kill()
+			this.service = null
+			this.dead.use(Promise.resolve())
+			this.alive = new Future(() => {})
+		} else {
+			console.error(
+				`Failed to stop service ${this.serviceName}: Service is not running.`,
+			)
+		}
+	}
+}

package/src/lib.ts

@@ -0,0 +1 @@
+export * from "./flightdeck"