flightdeck 0.0.2 → 0.0.4

package/dist/flightdeck.$configPath.schema.json

@@ -4,22 +4,35 @@
 		"secret": {
 			"type": "string"
 		},
-		"repo": {
+		"packageName": {
 			"type": "string"
 		},
-		"app": {
-			"type": "string"
-		},
-		"runCmd": {
-			"type": "array",
-			"items": {
-				"type": "string"
+		"services": {
+			"type": "object",
+			"additionalProperties": {
+				"type": "object",
+				"properties": {
+					"run": {
+						"type": "array",
+						"items": {
+							"type": "string"
+						}
+					},
+					"waitFor": {
+						"type": "boolean"
+					}
+				},
+				"required": [
+					"run",
+					"waitFor"
+				],
+				"additionalProperties": false
 			}
 		},
-		"serviceDir": {
+		"flightdeckRootDir": {
 			"type": "string"
 		},
-		"updateCmd": {
+		"downloadPackageToUpdatesCmd": {
 			"type": "array",
 			"items": {
 				"type": "string"
@@ -28,11 +41,10 @@
 	},
 	"required": [
 		"secret",
-		"repo",
-		"app",
-		"runCmd",
-		"serviceDir",
-		"updateCmd"
+		"packageName",
+		"services",
+		"flightdeckRootDir",
+		"downloadPackageToUpdatesCmd"
 	],
 	"additionalProperties": false,
 	"$schema": "http://json-schema.org/draft-07/schema#"

package/dist/flightdeck.bin.js

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+
+// src/flightdeck.bin.ts
+import * as path from "node:path";
+import {cli, optional, parseArrayOption} from "comline";
+import {z} from "zod";
+
+// src/flightdeck.lib.ts
+import {execSync, spawn} from "node:child_process";
+import {existsSync, mkdirSync, renameSync, rmSync} from "node:fs";
+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 PORT = process.env.PORT ?? 8080;
+var ORIGIN = `http://localhost:${PORT}`;
+
+class FlightDeck {
+  options;
+  safety = 0;
+  webhookServer;
+  services;
+  serviceIdx;
+  defaultServicesReadyToUpdate;
+  servicesReadyToUpdate;
+  servicesShouldRestart;
+  logger;
+  serviceLoggers;
+  servicesLive;
+  servicesDead;
+  live = new Future(() => {
+  });
+  dead = new Future(() => {
+  });
+  restartTimes = [];
+  currentServiceDir;
+  updateServiceDir;
+  backupServiceDir;
+  constructor(options) {
+    this.options = options;
+    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.logger = {
+      info: (...args) => {
+        console.log(`${this.options.packageName}:`, ...args);
+      },
+      warn: (...args) => {
+        console.warn(`${this.options.packageName}:`, ...args);
+      },
+      error: (...args) => {
+        console.error(`${this.options.packageName}:`, ...args);
+      }
+    };
+    this.serviceLoggers = fromEntries(servicesEntries.map(([serviceName]) => [
+      serviceName,
+      {
+        info: (...args) => {
+          console.log(`${this.options.packageName}::${serviceName}:`, ...args);
+        },
+        warn: (...args) => {
+          console.warn(`${this.options.packageName}::${serviceName}:`, ...args);
+        },
+        error: (...args) => {
+          console.error(`${this.options.packageName}::${serviceName}:`, ...args);
+        }
+      }
+    ]));
+    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) => {
+        data.push(chunk instanceof Buffer ? chunk : Buffer.from(chunk));
+      }).on(`end`, () => {
+        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);
+          this.logger.info(req.method, url.pathname);
+          switch (req.method) {
+            case `POST`:
+              {
+                switch (url.pathname) {
+                  case `/`:
+                    {
+                      res.writeHead(200);
+                      res.end();
+                      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;
+          }
+        } catch (thrown) {
+          this.logger.error(thrown, req.url);
+          if (typeof thrown === `number`) {
+            res.writeHead(thrown);
+            res.end();
+          }
+        } finally {
+          data = [];
+        }
+      });
+    }).listen(PORT, () => {
+      this.logger.info(`Server started on port ${PORT}`);
+    });
+    this.startAllServices();
+  }
+  startAllServices() {
+    this.logger.info(`Starting all services...`);
+    for (const [serviceName] of toEntries(this.services)) {
+      this.startService(serviceName);
+    }
+  }
+  startService(serviceName) {
+    this.logger.info(`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)) {
+      this.logger.info(`Tried to start service but failed: could not find ${this.currentServiceDir}`);
+      this.getLatestRelease();
+      this.applyUpdate();
+      this.startService(serviceName);
+      return;
+    }
+    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.services[serviceName] = new ChildSocket(serviceProcess, `${this.options.packageName}::${serviceName}`, console);
+    this.services[serviceName].onAny((...messages) => {
+      this.logger.info(`\uD83D\uDCAC`, ...messages);
+    });
+    this.services[serviceName].on(`readyToUpdate`, () => {
+      this.serviceLoggers[serviceName].info(`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.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.services[serviceName].process.on(`close`, (exitCode) => {
+      this.serviceLoggers[serviceName].info(`Exited with code ${exitCode}`);
+      this.services[serviceName] = null;
+      if (!this.servicesShouldRestart) {
+        this.serviceLoggers[serviceName].info(`Will not be restarted.`);
+        return;
+      }
+      const updatesAreReady = existsSync(this.updateServiceDir);
+      if (updatesAreReady) {
+        this.serviceLoggers[serviceName].info(`Updating before startup...`);
+        this.restartTimes = [];
+        this.applyUpdate();
+        this.startService(serviceName);
+      } else {
+        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) {
+          this.serviceLoggers[serviceName].info(`Crashed. Restarting...`);
+          this.startService(serviceName);
+        } else {
+          this.serviceLoggers[serviceName].info(`Crashed 5 times in 5 minutes. Not restarting.`);
+        }
+      }
+    });
+    this.safety = 0;
+  }
+  applyUpdate() {
+    this.logger.info(`Applying update...`);
+    if (existsSync(this.updateServiceDir)) {
+      const runningServices = toEntries(this.services).filter(([, service]) => service);
+      if (runningServices.length > 0) {
+        this.logger.error(`Tried to apply update but failed. The following services are currently running: [${runningServices.map(([serviceName]) => serviceName).join(`, `)}]`);
+        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 = [];
+      this.servicesReadyToUpdate = { ...this.defaultServicesReadyToUpdate };
+    } else {
+      this.logger.error(`Tried to apply update but failed: could not find update directory ${this.updateServiceDir}`);
+    }
+  }
+  getLatestRelease() {
+    this.logger.info(`Getting latest release...`);
+    try {
+      execSync(this.options.downloadPackageToUpdatesCmd.join(` `));
+    } catch (thrown) {
+      if (thrown instanceof Error) {
+        this.logger.error(`Failed to get the latest release: ${thrown.message}`);
+      }
+      return;
+    }
+  }
+  stopAllServices() {
+    this.logger.info(`Stopping all services...`);
+    for (const [serviceName] of toEntries(this.services)) {
+      this.stopService(serviceName);
+    }
+  }
+  stopService(serviceName) {
+    if (this.services[serviceName]) {
+      this.serviceLoggers[serviceName].info(`Stopping service...`);
+      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 {
+      this.serviceLoggers[serviceName].error(`Tried to stop service, but it wasn't running.`);
+    }
+  }
+  shutdown() {
+    this.servicesShouldRestart = false;
+    this.stopAllServices();
+  }
+}
+
+// src/flightdeck.bin.ts
+var FLIGHTDECK_MANUAL = {
+  optionsSchema: z.object({
+    secret: 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: `x`,
+      required: true,
+      description: `Secret used to authenticate with the service.`,
+      example: `--secret=\"secret\"`
+    },
+    packageName: {
+      flag: `p`,
+      required: true,
+      description: `Name of the package.`,
+      example: `--packageName=\"my-app\"`
+    },
+    services: {
+      flag: `s`,
+      required: true,
+      description: `Map of service names to executables.`,
+      example: `--services="{\\"frontend\\":{\\"run\\":[\\"./app\\"],\\"waitFor\\":false},\\"backend\\":{\\"run\\":[\\"./backend\\"],\\"waitFor\\":true}}"`,
+      parse: JSON.parse
+    },
+    flightdeckRootDir: {
+      flag: `d`,
+      required: true,
+      description: `Directory where the service is stored.`,
+      example: `--flightdeckRootDir=\"./services/sample/repo/my-app/current\"`
+    },
+    downloadPackageToUpdatesCmd: {
+      flag: `u`,
+      required: true,
+      description: `Command to update the service.`,
+      example: `--downloadPackageToUpdatesCmd=\"./app\"`,
+      parse: parseArrayOption
+    }
+  }
+};
+var 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`
+    }
+  }
+};
+var 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);
+var { 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.stopAllServices();
+      await flightDeck.dead;
+    });
+  }
+}

package/dist/flightdeck.main.schema.json

@@ -4,22 +4,35 @@
 		"secret": {
 			"type": "string"
 		},
-		"repo": {
+		"packageName": {
 			"type": "string"
 		},
-		"app": {
-			"type": "string"
-		},
-		"runCmd": {
-			"type": "array",
-			"items": {
-				"type": "string"
+		"services": {
+			"type": "object",
+			"additionalProperties": {
+				"type": "object",
+				"properties": {
+					"run": {
+						"type": "array",
+						"items": {
+							"type": "string"
+						}
+					},
+					"waitFor": {
+						"type": "boolean"
+					}
+				},
+				"required": [
+					"run",
+					"waitFor"
+				],
+				"additionalProperties": false
 			}
 		},
-		"serviceDir": {
+		"flightdeckRootDir": {
 			"type": "string"
 		},
-		"updateCmd": {
+		"downloadPackageToUpdatesCmd": {
 			"type": "array",
 			"items": {
 				"type": "string"
@@ -28,11 +41,10 @@
 	},
 	"required": [
 		"secret",
-		"repo",
-		"app",
-		"runCmd",
-		"serviceDir",
-		"updateCmd"
+		"packageName",
+		"services",
+		"flightdeckRootDir",
+		"downloadPackageToUpdatesCmd"
 	],
 	"additionalProperties": false,
 	"$schema": "http://json-schema.org/draft-07/schema#"

package/dist/klaxon.bin.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+// src/klaxon.bin.ts
+import {cli, required} from "comline";
+import {z} from "zod";
+
+// src/klaxon.lib.ts
+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;
+}
+
+// src/klaxon.bin.ts
+var changesetsPublishedPackagesSchema = z.object({
+  packageConfig: z.record(z.string(), z.object({ endpoint: z.string() })),
+  secretsConfig: z.record(z.string(), z.string()),
+  publishedPackages: z.array(z.object({
+    name: z.string(),
+    version: z.string()
+  }))
+});
+var klaxon = cli({
+  cliName: `klaxon`,
+  routes: required({
+    scramble: null
+  }),
+  routeOptions: {
+    scramble: {
+      options: {
+        packageConfig: {
+          description: `Maps the names of your packages to the endpoints that klaxon will POST to.`,
+          example: `--packageConfig="{\\"my-app\\":{\\"endpoint\\":\\"https://my-app.com\\"}}"`,
+          flag: `c`,
+          parse: JSON.parse,
+          required: true
+        },
+        secretsConfig: {
+          description: `Maps the names of your packages to the secrets that klaxon will use to authenticate with their respective endpoints.`,
+          example: `--secretsConfig="{\\"my-app\\":\\"XXXX-XXXX-XXXX\\"}"`,
+          flag: `s`,
+          parse: JSON.parse,
+          required: true
+        },
+        publishedPackages: {
+          description: `The output of the "Publish" step in Changesets.`,
+          example: `--publishedPackages="[{\\"name\\":\\"my-app\\",\\"version\\":\\"0.0.0\\"}]"`,
+          flag: `p`,
+          parse: JSON.parse,
+          required: true
+        }
+      },
+      optionsSchema: changesetsPublishedPackagesSchema
+    }
+  }
+});
+var { inputs } = klaxon(process.argv);
+await scramble(inputs.opts).then((scrambleResult) => {
+  console.log(scrambleResult);
+});