flightdeck 0.0.1 → 0.0.3

package/dist/lib.js

@@ -1,24 +1,39 @@
-// src/flightdeck.ts
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/flightdeck.lib.ts
 import {execSync, spawn} from "node:child_process";
 import {existsSync, mkdirSync, renameSync, rmSync} from "node:fs";
-import {createServer} from "node:http2";
+import {createServer} from "node:http";
 import {homedir} from "node:os";
 import {resolve} from "node:path";
 import {Future} from "atom.io/internal";
+import {fromEntries, toEntries} from "atom.io/json";
 import {ChildSocket} from "atom.io/realtime-server";
-var safety = 0;
 var PORT = process.env.PORT ?? 8080;
 var ORIGIN = `http://localhost:${PORT}`;
 
 class FlightDeck {
   options;
-  get serviceName() {
-    return `${this.options.repo}/${this.options.app}`;
-  }
+  safety = 0;
   webhookServer;
-  service = null;
+  services;
+  serviceIdx;
+  defaultServicesReadyToUpdate;
+  servicesReadyToUpdate;
+  servicesShouldRestart;
   restartTimes = [];
-  alive = new Future(() => {
+  servicesLive;
+  servicesDead;
+  live = new Future(() => {
   });
   dead = new Future(() => {
   });
@@ -27,13 +42,25 @@ class FlightDeck {
   backupServiceDir;
   constructor(options) {
     this.options = options;
-    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`);
+    const { secret, flightdeckRootDir = resolve(homedir(), `services`) } = options;
+    const servicesEntries = toEntries(options.services);
+    this.services = fromEntries(servicesEntries.map(([serviceName]) => [serviceName, null]));
+    this.serviceIdx = fromEntries(servicesEntries.map(([serviceName], idx) => [serviceName, idx]));
+    this.defaultServicesReadyToUpdate = fromEntries(servicesEntries.map(([serviceName, { waitFor }]) => [
+      serviceName,
+      !waitFor
+    ]));
+    this.servicesReadyToUpdate = { ...this.defaultServicesReadyToUpdate };
+    this.servicesShouldRestart = true;
+    this.servicesLive = servicesEntries.map(() => new Future(() => {
+    }));
+    this.servicesDead = servicesEntries.map(() => new Future(() => {
+    }));
+    this.live.use(Promise.all(this.servicesLive));
+    this.dead.use(Promise.all(this.servicesDead));
+    this.currentServiceDir = resolve(flightdeckRootDir, options.packageName, `current`);
+    this.backupServiceDir = resolve(flightdeckRootDir, options.packageName, `backup`);
+    this.updateServiceDir = resolve(flightdeckRootDir, options.packageName, `update`);
     createServer((req, res) => {
       let data = [];
       req.on(`data`, (chunk) => {
@@ -42,6 +69,8 @@ class FlightDeck {
         console.log(req.headers);
         const authHeader = req.headers.authorization;
         try {
+          if (typeof req.url === `undefined`)
+            throw 400;
           if (authHeader !== `Bearer ${secret}`)
             throw 401;
           const url = new URL(req.url, ORIGIN);
@@ -56,11 +85,20 @@ class FlightDeck {
                       res.writeHead(200);
                       res.end();
                       this.fetchLatestRelease();
-                      if (this.service) {
-                        this.service.emit(`updatesReady`);
-                      } else {
-                        this.applyUpdate();
-                        this.startService();
+                      if (toEntries(this.servicesReadyToUpdate).every(([, isReady]) => isReady)) {
+                        console.log(`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;
@@ -85,68 +123,89 @@ class FlightDeck {
     }).listen(PORT, () => {
       console.log(`Server started on port ${PORT}`);
     });
-    this.startService();
+    this.startAllServices();
+  }
+  startAllServices() {
+    console.log(`Starting all services...`);
+    for (const [serviceName] of toEntries(this.services)) {
+      this.startService(serviceName);
+    }
   }
-  startService() {
-    safety++;
-    if (safety > 10) {
-      throw new Error(`safety exceeded`);
+  startService(serviceName) {
+    console.log(`Starting service ${this.options.packageName}::${serviceName}, try ${this.safety}/2...`);
+    if (this.safety > 2) {
+      throw new Error(`Out of tries...`);
     }
+    this.safety++;
     if (!existsSync(this.currentServiceDir)) {
-      console.log(`Tried to start service but failed: Service ${this.serviceName} is not yet installed.`);
+      console.log(`Tried to start service but failed: Service ${this.options.packageName} is not yet installed.`);
       this.fetchLatestRelease();
       this.applyUpdate();
-      this.startService();
+      this.startService(serviceName);
       return;
     }
-    const [executable, ...args] = this.options.runCmd;
+    const [executable, ...args] = this.options.services[serviceName].run;
     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(`\uD83D\uDEF0 `, ...messages);
+    this.services[serviceName] = new ChildSocket(serviceProcess, `${this.options.packageName}::${serviceName}`, console);
+    this.services[serviceName].onAny((...messages) => {
+      console.log(`${this.options.packageName}::${serviceName} \uD83D\uDCAC`, ...messages);
     });
-    this.service.on(`readyToUpdate`, () => {
-      this.stopService();
+    this.services[serviceName].on(`readyToUpdate`, () => {
+      console.log(`Service ${this.options.packageName}::${serviceName} is ready to update.`);
+      this.servicesReadyToUpdate[serviceName] = true;
+      if (toEntries(this.servicesReadyToUpdate).every(([, isReady]) => isReady)) {
+        console.log(`All services are ready to update!`);
+        this.stopAllServices();
+      }
     });
-    this.service.on(`alive`, () => {
-      this.alive.use(Promise.resolve());
-      this.dead = new Future(() => {
+    this.services[serviceName].on(`alive`, () => {
+      this.servicesLive[this.serviceIdx[serviceName]].use(Promise.resolve());
+      this.servicesDead[this.serviceIdx[serviceName]] = new Future(() => {
       });
+      if (this.dead.done) {
+        this.dead = new Future(() => {
+        });
+      }
+      this.dead.use(Promise.all(this.servicesDead));
     });
-    this.service.process.on(`close`, (exitCode) => {
-      console.log(`Service ${this.serviceName} exited with code ${exitCode}`);
-      this.service = null;
+    this.services[serviceName].process.on(`close`, (exitCode) => {
+      console.log(`${this.options.packageName}::${serviceName} exited with code ${exitCode}`);
+      this.services[serviceName] = null;
+      if (!this.servicesShouldRestart) {
+        console.log(`Service ${this.options.packageName}::${serviceName} will not be restarted.`);
+        return;
+      }
       const updatesAreReady = existsSync(this.updateServiceDir);
       if (updatesAreReady) {
-        console.log(`Updates are ready; applying and restarting...`);
+        console.log(`${this.options.packageName}::${serviceName} will be updated before startup...`);
         this.restartTimes = [];
         this.applyUpdate();
-        this.startService();
+        this.startService(serviceName);
       } 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.`);
-          }
+        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.options.packageName}::${serviceName} crashed. Restarting...`);
+          this.startService(serviceName);
+        } else {
+          console.log(`Service ${this.options.packageName}::${serviceName} crashed too many times. Not restarting.`);
         }
       }
     });
+    this.safety = 0;
   }
   applyUpdate() {
-    console.log(`Installing latest version of service ${this.serviceName}...`);
+    console.log(`Installing latest version of service ${this.options.packageName}...`);
     if (existsSync(this.updateServiceDir)) {
-      if (this.service) {
-        console.log(`Tried to apply update but failed: Service ${this.serviceName} is currently running.`);
+      const runningServices = toEntries(this.services).filter(([, service]) => service);
+      if (runningServices.length > 0) {
+        console.log(`Tried to apply update to ${this.options.packageName} but failed. The following services are currently running: [${runningServices.map(([serviceName]) => serviceName).join(`, `)}]`);
         return;
       }
       if (existsSync(this.currentServiceDir)) {
@@ -159,14 +218,15 @@ class FlightDeck {
       }
       renameSync(this.updateServiceDir, this.currentServiceDir);
       this.restartTimes = [];
+      this.servicesReadyToUpdate = { ...this.defaultServicesReadyToUpdate };
     } else {
-      console.log(`Service ${this.serviceName} is already up to date.`);
+      console.log(`Service ${this.options.packageName} is already up to date.`);
     }
   }
   fetchLatestRelease() {
-    console.log(`Downloading latest version of service ${this.serviceName}...`);
+    console.log(`Downloading latest version of service ${this.options.packageName}...`);
     try {
-      execSync(this.options.updateCmd.join(` `));
+      execSync(this.options.downloadPackageToUpdatesCmd.join(` `));
     } catch (thrown) {
       if (thrown instanceof Error) {
         console.error(`Failed to fetch the latest release: ${thrown.message}`);
@@ -174,19 +234,73 @@ class FlightDeck {
       return;
     }
   }
-  stopService() {
-    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(() => {
+  stopAllServices() {
+    console.log(`Stopping all services...`);
+    for (const [serviceName] of toEntries(this.services)) {
+      this.stopService(serviceName);
+    }
+  }
+  stopService(serviceName) {
+    if (this.services[serviceName]) {
+      console.log(`Stopping service ${this.options.packageName}::${serviceName}...`);
+      this.services[serviceName].process.kill();
+      this.services[serviceName] = null;
+      this.servicesDead[this.serviceIdx[serviceName]].use(Promise.resolve());
+      this.servicesLive[this.serviceIdx[serviceName]] = new Future(() => {
       });
+      if (this.live.done) {
+        this.live = new Future(() => {
+        });
+      }
+      this.live.use(Promise.all(this.servicesLive));
     } else {
-      console.error(`Failed to stop service ${this.serviceName}: Service is not running.`);
+      console.error(`Failed to stop service ${this.options.packageName}::${serviceName}: Service is not running.`);
+    }
+  }
+  shutdown() {
+    this.servicesShouldRestart = false;
+    this.stopAllServices();
+  }
+}
+// src/klaxon.lib.ts
+var exports_klaxon_lib = {};
+__export(exports_klaxon_lib, {
+  scramble: () => scramble,
+  alert: () => alert
+});
+async function alert({
+  secret,
+  endpoint
+}) {
+  const response = await fetch(endpoint, {
+    method: `POST`,
+    headers: {
+      "Content-Type": `application/json`,
+      Authorization: `Bearer ${secret}`
+    }
+  });
+  return response;
+}
+async function scramble({
+  packageConfig,
+  secretsConfig,
+  publishedPackages
+}) {
+  const alertResults = [];
+  for (const publishedPackage of publishedPackages) {
+    if (publishedPackage.name in packageConfig) {
+      const name = publishedPackage.name;
+      const { endpoint } = packageConfig[name];
+      const secret = secretsConfig[name];
+      const alertResultPromise = alert({ secret, endpoint }).then((alertResult) => [name, alertResult]);
+      alertResults.push(alertResultPromise);
     }
   }
+  const alertResultsResolved = await Promise.all(alertResults);
+  const scrambleResult = Object.fromEntries(alertResultsResolved);
+  return scrambleResult;
 }
 export {
+  exports_klaxon_lib as Klaxon,
   FlightDeck
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flightdeck",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "license": "MIT",
   "author": {
     "name": "Jeremy Banka",
@@ -17,29 +17,31 @@
   "main": "dist/lib.js",
   "types": "dist/lib.d.ts",
   "bin": {
-    "flightdeck": "./dist/bin.js"
+    "flightdeck": "./dist/flightdeck.bin.js",
+    "klaxon": "./dist/klaxon.bin.js"
   },
   "dependencies": {
     "zod": "3.23.8",
-    "atom.io": "0.29.0",
-    "comline": "0.1.0"
+    "atom.io": "0.29.2",
+    "comline": "0.1.1"
   },
   "devDependencies": {
-    "@types/bun": "1.1.8",
+    "@types/bun": "1.1.9",
     "@types/node": "20.16.5",
     "@types/tmp": "0.2.6",
-    "concurrently": "8.2.2",
+    "concurrently": "9.0.1",
     "tmp": "0.2.3",
     "tsup": "8.2.4",
     "rimraf": "6.0.1",
-    "vitest": "2.0.5"
+    "vitest": "2.1.1"
   },
   "scripts": {
-    "build": "rimraf dist && concurrently \"bun:build:*\" && bun run schema",
+    "build": "rimraf dist && concurrently \"bun:build:*\" && concurrently \"bun:schema:*\"",
+    "build:bin:flightdeck": "bun build --outdir dist --target node --external flightdeck --external atom.io --external comline --external zod -- src/flightdeck.bin.ts",
+    "build:bin:klaxon": "bun build --outdir dist --target node --external flightdeck --external atom.io --external comline --external zod -- src/klaxon.bin.ts",
     "build:lib": "bun build --outdir dist --target node --external flightdeck --external atom.io --external comline --external zod -- src/lib.ts ",
-    "build:bin": "bun build --outdir dist --target node --external flightdeck --external atom.io --external comline --external zod -- src/bin.ts",
     "build:dts": "tsup",
-    "schema": "bun ./src/bin.ts --outdir=dist -- schema",
+    "schema:flightdeck": "bun ./src/flightdeck.bin.ts --outdir=dist -- schema",
     "lint:biome": "biome check -- .",
     "lint:eslint": "eslint --flag unstable_ts_config -- .",
     "lint:types": "tsc --noEmit",

package/src/{bin.ts → flightdeck.bin.ts}

@@ -4,56 +4,52 @@ 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"
 
+import type { FlightDeckOptions } from "~/packages/flightdeck/src/flightdeck.lib"
+import { FlightDeck } from "~/packages/flightdeck/src/flightdeck.lib"
+
 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()),
+		packageName: z.string(),
+		services: z.record(
+			z.object({ run: z.array(z.string()), waitFor: z.boolean() }),
+		),
+		flightDeckRootDir: z.string(),
+		downloadPackageToUpdatesCmd: z.array(z.string()),
 	}),
 	options: {
 		secret: {
-			flag: `s`,
+			flag: `x`,
 			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`,
+		packageName: {
+			flag: `p`,
 			required: true,
-			description: `Name of the application.`,
-			example: `--app=\"my-app\"`,
+			description: `Name of the package.`,
+			example: `--packageName=\"my-app\"`,
 		},
-		runCmd: {
-			flag: `r`,
+		services: {
+			flag: `s`,
 			required: true,
-			description: `Command to run the application.`,
-			example: `--runCmd=\"./app\"`,
-			parse: parseArrayOption,
+			description: `Map of service names to executables.`,
+			example: `--services="{\\"frontend\\":{\\"run\\":[\\"./app\\"],\\"waitFor\\":false},\\"backend\\":{\\"run\\":[\\"./backend\\"],\\"waitFor\\":true}}"`,
+			parse: JSON.parse,
 		},
-		serviceDir: {
+		flightdeckRootDir: {
 			flag: `d`,
 			required: true,
 			description: `Directory where the service is stored.`,
-			example: `--serviceDir=\"./services/sample/repo/my-app/current\"`,
+			example: `--flightdeckRootDir=\"./services/sample/repo/my-app/current\"`,
 		},
-		updateCmd: {
+		downloadPackageToUpdatesCmd: {
 			flag: `u`,
 			required: true,
 			description: `Command to update the service.`,
-			example: `--updateCmd=\"./app\"`,
+			example: `--downloadPackageToUpdatesCmd=\"./app\"`,
 			parse: parseArrayOption,
 		},
 	},
@@ -106,7 +102,7 @@ switch (inputs.case) {
 	default: {
 		const flightDeck = new FlightDeck(inputs.opts)
 		process.on(`close`, async () => {
-			flightDeck.stopService()
+			flightDeck.stopAllServices()
 			await flightDeck.dead
 		})
 	}