flightdeck 0.1.3 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flightdeck",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "license": "MIT",
   "author": {
     "name": "Jeremy Banka",
@@ -22,19 +22,20 @@
   },
   "dependencies": {
     "@t3-oss/env-core": "0.11.1",
+    "cron": "3.2.0",
     "zod": "3.23.8",
     "atom.io": "0.30.2",
     "comline": "0.1.6"
   },
   "devDependencies": {
-    "@types/node": "22.7.9",
+    "@types/node": "22.9.0",
     "@types/tmp": "0.2.6",
-    "bun-types": "1.1.33",
-    "concurrently": "9.0.1",
+    "bun-types": "1.1.34",
+    "concurrently": "9.1.0",
     "rimraf": "6.0.1",
     "tmp": "0.2.3",
-    "tsup": "8.3.0",
-    "vitest": "2.1.3"
+    "tsup": "8.3.5",
+    "vitest": "2.1.4"
   },
   "scripts": {
     "build": "rimraf dist && concurrently \"bun:build:*\" && concurrently \"bun:schema:*\"",

package/src/filesystem-storage.ts

@@ -0,0 +1,67 @@
+import {
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	rmSync,
+	statSync,
+	writeFileSync,
+} from "node:fs"
+import { resolve } from "node:path"
+
+export type FilesystemStorageOptions = {
+	path: string
+}
+
+export class FilesystemStorage<
+	T extends Record<string, string> = Record<string, string>,
+> implements Storage
+{
+	public rootDir: string
+
+	public constructor(options: FilesystemStorageOptions) {
+		this.rootDir = options.path
+		if (!existsSync(this.rootDir)) {
+			mkdirSync(this.rootDir, { recursive: true })
+		}
+	}
+
+	public getItem<K extends string & keyof T>(key: K): T[K] | null {
+		const filePath = resolve(this.rootDir, key)
+		if (existsSync(filePath)) {
+			return readFileSync(filePath, `utf-8`) as T[K]
+		}
+		return null
+	}
+
+	public setItem<K extends string & keyof T>(key: K, value: T[K]): void {
+		const filePath = resolve(this.rootDir, key)
+		writeFileSync(filePath, value)
+	}
+
+	public removeItem<K extends string & keyof T>(key: K): void {
+		const filePath = resolve(this.rootDir, key)
+		if (existsSync(filePath)) {
+			rmSync(filePath)
+		}
+	}
+
+	public key(index: number): (string & keyof T) | null {
+		const filePaths = readdirSync(this.rootDir)
+		const filePathsByDateCreated = filePaths.sort((a, b) => {
+			const aStat = statSync(a)
+			const bStat = statSync(b)
+			return bStat.ctimeMs - aStat.ctimeMs
+		})
+		return (filePathsByDateCreated[index] as string & keyof T) ?? null
+	}
+
+	public clear(): void {
+		rmSync(this.rootDir, { recursive: true })
+		mkdirSync(this.rootDir, { recursive: true })
+	}
+
+	public get length(): number {
+		return readdirSync(this.rootDir).length
+	}
+}

package/src/flightdeck.bin.ts

@@ -18,6 +18,7 @@ const FLIGHTDECK_MANUAL = {
 		scripts: z.object({
 			download: z.string(),
 			install: z.string(),
+			checkAvailability: z.string(),
 		}),
 	}),
 	options: {
@@ -105,8 +106,7 @@ switch (inputs.case) {
 	default: {
 		const flightDeck = new FlightDeck(inputs.opts)
 		process.on(`close`, async () => {
-			flightDeck.stopAllServices()
-			await flightDeck.dead
+			await flightDeck.stopAllServices()
 		})
 	}
 }

package/src/flightdeck.lib.ts

@@ -1,22 +1,39 @@
 import { execSync, spawn } from "node:child_process"
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
 import type { Server } from "node:http"
 import { createServer } from "node:http"
 import { homedir } from "node:os"
 import { resolve } from "node:path"
 
 import { Future } from "atom.io/internal"
+import { discoverType } from "atom.io/introspection"
 import { fromEntries, toEntries } from "atom.io/json"
 import { ChildSocket } from "atom.io/realtime-server"
+import { CronJob } from "cron"
 
+import { FilesystemStorage } from "./filesystem-storage"
 import { env } from "./flightdeck.env"
 
+export const FLIGHTDECK_SETUP_PHASES = [`downloaded`, `installed`] as const
+
+export type FlightDeckSetupPhase = (typeof FLIGHTDECK_SETUP_PHASES)[number]
+
+export const FLIGHTDECK_UPDATE_PHASES = [`notified`, `confirmed`] as const
+
+export type FlightDeckUpdatePhase = (typeof FLIGHTDECK_UPDATE_PHASES)[number]
+
+export function isVersionNumber(version: string): boolean {
+	return (
+		/^\d+\.\d+\.\d+$/.test(version) || !Number.isNaN(Number.parseFloat(version))
+	)
+}
+
 export type FlightDeckOptions<S extends string = string> = {
 	packageName: string
 	services: { [service in S]: { run: string; waitFor: boolean } }
 	scripts: {
 		download: string
 		install: string
+		checkAvailability?: string
 	}
 	port?: number | undefined
 	flightdeckRootDir?: string | undefined
@@ -25,23 +42,30 @@ export type FlightDeckOptions<S extends string = string> = {
 export class FlightDeck<S extends string = string> {
 	protected safety = 0
 
+	protected storage: FilesystemStorage<{
+		setupPhase: FlightDeckSetupPhase
+		updatePhase: FlightDeckUpdatePhase
+		updateAwaitedVersion: string
+	}>
 	protected webhookServer: Server
 	protected services: {
 		[service in S]: ChildSocket<
-			{ updatesReady: [] },
+			{ timeToStop: []; updatesReady: [] },
 			{ readyToUpdate: []; alive: [] }
 		> | null
 	}
 	protected serviceIdx: { readonly [service in S]: number }
 	public defaultServicesReadyToUpdate: { readonly [service in S]: boolean }
 	public servicesReadyToUpdate: { [service in S]: boolean }
-	public servicesShouldRestart: boolean
+	public autoRespawnDeadServices: boolean
 
 	protected logger: Pick<Console, `error` | `info` | `warn`>
 	protected serviceLoggers: {
 		readonly [service in S]: Pick<Console, `error` | `info` | `warn`>
 	}
 
+	protected updateAvailabilityChecker: CronJob | null = null
+
 	public servicesLive: Future<void>[]
 	public servicesDead: Future<void>[]
 	public live = new Future(() => {})
@@ -49,11 +73,9 @@ export class FlightDeck<S extends string = string> {
 
 	protected restartTimes: number[] = []
 
-	protected persistentStateDir: string
-
 	public constructor(public readonly options: FlightDeckOptions<S>) {
 		const { FLIGHTDECK_SECRET } = env
-		const { flightdeckRootDir = resolve(homedir(), `services`) } = options
+		const { flightdeckRootDir = resolve(homedir(), `.flightdeck`) } = options
 		const port = options.port ?? 8080
 		const origin = `http://localhost:${port}`
 
@@ -71,7 +93,7 @@ export class FlightDeck<S extends string = string> {
 			]),
 		)
 		this.servicesReadyToUpdate = { ...this.defaultServicesReadyToUpdate }
-		this.servicesShouldRestart = true
+		this.autoRespawnDeadServices = true
 
 		this.logger = {
 			info: (...args: any[]) => {
@@ -109,14 +131,9 @@ export class FlightDeck<S extends string = string> {
 		this.live.use(Promise.all(this.servicesLive))
 		this.dead.use(Promise.all(this.servicesDead))
 
-		this.persistentStateDir = resolve(
-			flightdeckRootDir,
-			`.state`,
-			options.packageName,
-		)
-		if (!existsSync(this.persistentStateDir)) {
-			mkdirSync(this.persistentStateDir, { recursive: true })
-		}
+		this.storage = new FilesystemStorage({
+			path: resolve(flightdeckRootDir, `storage`, options.packageName),
+		})
 
 		if (FLIGHTDECK_SECRET === undefined) {
 			this.logger.warn(
@@ -142,63 +159,34 @@ export class FlightDeck<S extends string = string> {
 							}
 							const url = new URL(req.url, origin)
 							this.logger.info(req.method, url.pathname)
-							switch (req.method) {
-								case `POST`:
-									{
-										switch (url.pathname) {
-											case `/`:
-												{
-													res.writeHead(200)
-													res.end()
-													const installFile = resolve(
-														this.persistentStateDir,
-														`install`,
-													)
-													const readyFile = resolve(
-														this.persistentStateDir,
-														`ready`,
-													)
-													if (!existsSync(installFile)) {
-														this.logger.info(
-															`Install file does not exist yet. Creating...`,
-														)
-														writeFileSync(installFile, ``)
-													}
-													if (existsSync(readyFile)) {
-														this.logger.info(`Ready file exists. Removing...`)
-														rmSync(readyFile)
-													}
-													this.getLatestRelease()
-													if (
-														toEntries(this.servicesReadyToUpdate).every(
-															([, isReady]) => isReady,
-														)
-													) {
-														this.logger.info(`All services are ready to update!`)
-														this.stopAllServices()
-														return
-													}
-													for (const entry of toEntries(this.services)) {
-														const [serviceName, service] = entry
-														if (service) {
-															if (this.options.services[serviceName].waitFor) {
-																service.emit(`updatesReady`)
-															}
-														} else {
-															this.startService(serviceName)
-														}
-													}
-												}
-												break
-
-											default:
-												throw 404
-										}
-									}
-									break
-
-								default:
-									throw 405
+
+							const versionForeignInput = Buffer.concat(data).toString()
+							if (!isVersionNumber(versionForeignInput)) {
+								throw 400
+							}
+
+							res.writeHead(200)
+							res.end()
+
+							this.storage.setItem(`updatePhase`, `notified`)
+							this.storage.setItem(`updateAwaitedVersion`, versionForeignInput)
+							const { checkAvailability } = options.scripts
+							if (checkAvailability) {
+								this.updateAvailabilityChecker?.stop()
+								this.seekUpdate(versionForeignInput)
+								const updatePhase = this.storage.getItem(`updatePhase`)
+								this.logger.info(`> storage("updatePhase") >`, updatePhase)
+								if (updatePhase === `notified`) {
+									this.updateAvailabilityChecker = new CronJob(
+										`30 * * * * *`,
+										() => {
+											this.seekUpdate(versionForeignInput)
+										},
+									)
+									this.updateAvailabilityChecker.start()
+								}
+							} else {
+								this.downloadPackage()
 							}
 						} catch (thrown) {
 							this.logger.error(thrown, req.url)
@@ -216,12 +204,101 @@ export class FlightDeck<S extends string = string> {
 		}
 
 		this.startAllServices()
+			.then(() => {
+				this.logger.info(`All services started.`)
+			})
+			.catch((thrown) => {
+				if (thrown instanceof Error) {
+					this.logger.error(`Failed to start all services:`, thrown.message)
+				}
+			})
+	}
+
+	protected seekUpdate(version: string): void {
+		this.logger.info(`Checking for updates...`)
+		const { checkAvailability } = this.options.scripts
+		if (!checkAvailability) {
+			this.logger.info(`No checkAvailability script found.`)
+			return
+		}
+		try {
+			const out = execSync(`${checkAvailability} ${version}`)
+			this.logger.info(`Check stdout:`, out.toString())
+			this.updateAvailabilityChecker?.stop()
+			this.storage.setItem(`updatePhase`, `confirmed`)
+			this.downloadPackage()
+			this.announceUpdate()
+		} catch (thrown) {
+			if (thrown instanceof Error) {
+				this.logger.error(`Check failed:`, thrown.message)
+			} else {
+				const thrownType = discoverType(thrown)
+				this.logger.error(`Check threw`, thrownType, thrown)
+			}
+		}
+	}
+
+	protected announceUpdate(): void {
+		for (const entry of toEntries(this.services)) {
+			const [serviceName, service] = entry
+			if (service) {
+				if (this.options.services[serviceName].waitFor) {
+					service.emit(`updatesReady`)
+				}
+			} else {
+				this.startService(serviceName)
+			}
+		}
 	}
 
-	protected startAllServices(): void {
+	protected tryUpdate(): void {
+		if (toEntries(this.servicesReadyToUpdate).every(([, isReady]) => isReady)) {
+			this.logger.info(`All services are ready to update.`)
+			this.stopAllServices()
+				.then(() => {
+					this.logger.info(`All services stopped; starting up fresh...`)
+					this.startAllServices()
+						.then(() => {
+							this.logger.info(`All services started; we're back online.`)
+						})
+						.catch((thrown) => {
+							if (thrown instanceof Error) {
+								this.logger.error(
+									`Failed to start all services:`,
+									thrown.message,
+								)
+							}
+						})
+				})
+				.catch((thrown) => {
+					if (thrown instanceof Error) {
+						this.logger.error(`Failed to stop all services:`, thrown.message)
+					}
+				})
+		}
+	}
+
+	protected startAllServices(): Future<unknown> {
 		this.logger.info(`Starting all services...`)
-		for (const [serviceName] of toEntries(this.services)) {
-			this.startService(serviceName)
+		this.autoRespawnDeadServices = true
+		const setupPhase = this.storage.getItem(`setupPhase`)
+		this.logger.info(`> storage("setupPhase") >`, setupPhase)
+		switch (setupPhase) {
+			case null:
+				this.logger.info(`Starting from scratch.`)
+				this.downloadPackage()
+				this.installPackage()
+				return this.startAllServices()
+			case `downloaded`:
+				this.logger.info(`Found package downloaded but not installed.`)
+				this.installPackage()
+				return this.startAllServices()
+			case `installed`: {
+				for (const [serviceName] of toEntries(this.services)) {
+					this.startService(serviceName)
+				}
+				return this.live
+			}
 		}
 	}
 
@@ -233,17 +310,6 @@ export class FlightDeck<S extends string = string> {
 			throw new Error(`Out of tries...`)
 		}
 		this.safety++
-		const readyFile = resolve(this.persistentStateDir, `ready`)
-		if (!existsSync(readyFile)) {
-			this.logger.info(
-				`Tried to start service but failed: could not find readyFile: ${readyFile}`,
-			)
-			this.getLatestRelease()
-			this.applyUpdate()
-			this.startService(serviceName)
-
-			return
-		}
 
 		const [exe, ...args] = this.options.services[serviceName].run.split(` `)
 		const serviceProcess = spawn(exe, args, {
@@ -256,17 +322,12 @@ export class FlightDeck<S extends string = string> {
 			console,
 		)
 		this.services[serviceName].onAny((...messages) => {
-			this.logger.info(`💬`, ...messages)
+			this.serviceLoggers[serviceName].info(`💬`, ...messages)
 		})
 		this.services[serviceName].on(`readyToUpdate`, () => {
-			this.serviceLoggers[serviceName].info(`Ready to update.`)
+			this.logger.info(`Service "${serviceName}" is ready to update.`)
 			this.servicesReadyToUpdate[serviceName] = true
-			if (
-				toEntries(this.servicesReadyToUpdate).every(([, isReady]) => isReady)
-			) {
-				this.logger.info(`All services are ready to update.`)
-				this.stopAllServices()
-			}
+			this.tryUpdate()
 		})
 		this.services[serviceName].on(`alive`, () => {
 			this.servicesLive[this.serviceIdx[serviceName]].use(Promise.resolve())
@@ -276,19 +337,22 @@ export class FlightDeck<S extends string = string> {
 			}
 			this.dead.use(Promise.all(this.servicesDead))
 		})
-		this.services[serviceName].process.on(`close`, (exitCode) => {
-			this.serviceLoggers[serviceName].info(`Exited with code ${exitCode}`)
+		this.services[serviceName].process.once(`close`, (exitCode) => {
+			this.logger.info(
+				`Auto-respawn saw "${serviceName}" exit with code ${exitCode}`,
+			)
 			this.services[serviceName] = null
-			if (!this.servicesShouldRestart) {
-				this.serviceLoggers[serviceName].info(`Will not be restarted.`)
+			if (!this.autoRespawnDeadServices) {
+				this.logger.info(`Auto-respawn is off; "${serviceName}" rests.`)
 				return
 			}
-			const installFile = resolve(this.persistentStateDir, `install`)
-			const updatesAreReady = existsSync(installFile)
+			const updatePhase = this.storage.getItem(`updatePhase`)
+			this.logger.info(`> storage("updatePhase") >`, updatePhase)
+			const updatesAreReady = updatePhase === `confirmed`
 			if (updatesAreReady) {
 				this.serviceLoggers[serviceName].info(`Updating before startup...`)
 				this.restartTimes = []
-				this.applyUpdate()
+				this.installPackage()
 				this.startService(serviceName)
 			} else {
 				const now = Date.now()
@@ -311,18 +375,13 @@ export class FlightDeck<S extends string = string> {
 		this.safety = 0
 	}
 
-	protected applyUpdate(): void {
-		this.logger.info(`Installing...`)
-
+	protected downloadPackage(): void {
+		this.logger.info(`Downloading...`)
 		try {
-			execSync(this.options.scripts.install)
-			const installFile = resolve(this.persistentStateDir, `install`)
-			if (existsSync(installFile)) {
-				rmSync(installFile)
-			}
-			const readyFile = resolve(this.persistentStateDir, `ready`)
-			writeFileSync(readyFile, ``)
-			this.logger.info(`Installed!`)
+			const out = execSync(this.options.scripts.download)
+			this.logger.info(`Download stdout:`, out.toString())
+			this.storage.setItem(`setupPhase`, `downloaded`)
+			this.logger.info(`Downloaded!`)
 		} catch (thrown) {
 			if (thrown instanceof Error) {
 				this.logger.error(`Failed to get the latest release: ${thrown.message}`)
@@ -331,12 +390,14 @@ export class FlightDeck<S extends string = string> {
 		}
 	}
 
-	protected getLatestRelease(): void {
-		this.logger.info(`Downloading...`)
+	protected installPackage(): void {
+		this.logger.info(`Installing...`)
 
 		try {
-			execSync(this.options.scripts.download)
-			this.logger.info(`Downloaded!`)
+			const out = execSync(this.options.scripts.install)
+			this.logger.info(`Install stdout:`, out.toString())
+			this.storage.setItem(`setupPhase`, `installed`)
+			this.logger.info(`Installed!`)
 		} catch (thrown) {
 			if (thrown instanceof Error) {
 				this.logger.error(`Failed to get the latest release: ${thrown.message}`)
@@ -345,19 +406,32 @@ export class FlightDeck<S extends string = string> {
 		}
 	}
 
-	public stopAllServices(): void {
-		this.logger.info(`Stopping all services...`)
+	public stopAllServices(): Future<unknown> {
+		this.logger.info(`Stopping all services... auto-respawn disabled.`)
+		this.autoRespawnDeadServices = false
 		for (const [serviceName] of toEntries(this.services)) {
 			this.stopService(serviceName)
 		}
+		return this.dead
 	}
 
 	public stopService(serviceName: S): void {
-		if (this.services[serviceName]) {
-			this.serviceLoggers[serviceName].info(`Stopping service...`)
-			this.services[serviceName].process.kill(`SIGINT`)
-			this.services[serviceName] = null
-			this.servicesDead[this.serviceIdx[serviceName]].use(Promise.resolve())
+		const service = this.services[serviceName]
+		if (service) {
+			this.logger.info(`Stopping service "${serviceName}"...`)
+			this.servicesDead[this.serviceIdx[serviceName]].use(
+				new Promise((pass) => {
+					service.emit(`timeToStop`)
+					service.process.once(`close`, (exitCode) => {
+						this.logger.info(
+							`Stopped service "${serviceName}"; exited with code ${exitCode}`,
+						)
+						this.services[serviceName] = null
+						pass()
+					})
+				}),
+			)
+			this.dead.use(Promise.all(this.servicesDead))
 			this.servicesLive[this.serviceIdx[serviceName]] = new Future(() => {})
 			if (this.live.done) {
 				this.live = new Future(() => {})
@@ -369,10 +443,4 @@ export class FlightDeck<S extends string = string> {
 			)
 		}
 	}
-
-	public shutdown(): void {
-		this.logger.info(`Shutting down...`)
-		this.servicesShouldRestart = false
-		this.stopAllServices()
-	}
 }

package/src/klaxon.lib.ts

@@ -1,18 +1,21 @@
 export type AlertOptions = {
 	secret: string
 	endpoint: string
+	version: string
 }
 
 export async function alert({
 	secret,
 	endpoint,
+	version,
 }: AlertOptions): Promise<Response> {
 	const response = await fetch(endpoint, {
 		method: `POST`,
 		headers: {
-			"Content-Type": `application/json`,
+			"Content-Type": `text/plain;charset=UTF-8`,
 			Authorization: `Bearer ${secret}`,
 		},
+		body: version,
 	})
 
 	return response
@@ -64,7 +67,8 @@ export async function scramble<K extends string = string>({
 			const name = publishedPackage.name as K
 			const { endpoint } = packageConfig[name]
 			const secret = secretsConfig[name]
-			const alertResultPromise = alert({ secret, endpoint }).then(
+			const version = publishedPackage.version
+			const alertResultPromise = alert({ secret, endpoint, version }).then(
 				(alertResult) => [name, alertResult] as const,
 			)
 			alertResults.push(alertResultPromise)

package/src/lib.ts

@@ -1,3 +1,4 @@
+export * from "./filesystem-storage"
 export * from "./flightdeck.lib"
 import * as Klaxon from "./klaxon.lib"