flightdeck 0.0.2 → 0.0.3

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,350 @@
+#!/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;
+  restartTimes = [];
+  servicesLive;
+  servicesDead;
+  live = new Future(() => {
+  });
+  dead = new Future(() => {
+  });
+  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.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`, () => {
+        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);
+          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 (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;
+                  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.startAllServices();
+  }
+  startAllServices() {
+    console.log(`Starting all services...`);
+    for (const [serviceName] of toEntries(this.services)) {
+      this.startService(serviceName);
+    }
+  }
+  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.options.packageName} is not yet installed.`);
+      this.fetchLatestRelease();
+      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) => {
+      console.log(`${this.options.packageName}::${serviceName} \uD83D\uDCAC`, ...messages);
+    });
+    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.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) => {
+      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(`${this.options.packageName}::${serviceName} will be updated 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) {
+          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.options.packageName}...`);
+    if (existsSync(this.updateServiceDir)) {
+      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)) {
+        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 {
+      console.log(`Service ${this.options.packageName} is already up to date.`);
+    }
+  }
+  fetchLatestRelease() {
+    console.log(`Downloading latest version of service ${this.options.packageName}...`);
+    try {
+      execSync(this.options.downloadPackageToUpdatesCmd.join(` `));
+    } catch (thrown) {
+      if (thrown instanceof Error) {
+        console.error(`Failed to fetch the latest release: ${thrown.message}`);
+      }
+      return;
+    }
+  }
+  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.options.packageName}::${serviceName}: Service is not 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);
+});

package/dist/lib.d.ts

@@ -1,36 +1,109 @@
-import { Http2Server } from 'node:http2';
+import { Server } from 'node:http';
 import { Future } from 'atom.io/internal';
 import { ChildSocket } from 'atom.io/realtime-server';
 
-type FlightDeckOptions = {
+type FlightDeckOptions<S extends string = string> = {
     secret: string;
-    repo: string;
-    app: string;
-    runCmd: string[];
-    updateCmd: string[];
-    serviceDir?: string | undefined;
-};
-declare class FlightDeck {
-    readonly options: FlightDeckOptions;
-    get serviceName(): string;
-    protected webhookServer: Http2Server;
-    protected service: ChildSocket<{
-        updatesReady: [];
-    }, {
-        readyToUpdate: [];
-        alive: [];
-    }> | null;
+    packageName: string;
+    services: {
+        [service in S]: {
+            run: string[];
+            waitFor: boolean;
+        };
+    };
+    downloadPackageToUpdatesCmd: string[];
+    flightdeckRootDir?: string | undefined;
+};
+declare class FlightDeck<S extends string = string> {
+    readonly options: FlightDeckOptions<S>;
+    protected safety: number;
+    protected webhookServer: Server;
+    protected services: {
+        [service in S]: ChildSocket<{
+            updatesReady: [];
+        }, {
+            readyToUpdate: [];
+            alive: [];
+        }> | null;
+    };
+    protected serviceIdx: {
+        readonly [service in S]: number;
+    };
+    defaultServicesReadyToUpdate: {
+        readonly [service in S]: boolean;
+    };
+    servicesReadyToUpdate: {
+        [service in S]: boolean;
+    };
+    servicesShouldRestart: boolean;
     protected restartTimes: number[];
-    alive: Future<unknown>;
+    servicesLive: Future<void>[];
+    servicesDead: Future<void>[];
+    live: Future<unknown>;
     dead: Future<unknown>;
     readonly currentServiceDir: string;
     readonly updateServiceDir: string;
     readonly backupServiceDir: string;
-    constructor(options: FlightDeckOptions);
-    protected startService(): void;
+    constructor(options: FlightDeckOptions<S>);
+    protected startAllServices(): void;
+    protected startService(serviceName: S): void;
     protected applyUpdate(): void;
     protected fetchLatestRelease(): void;
-    stopService(): void;
+    stopAllServices(): void;
+    stopService(serviceName: S): void;
+    shutdown(): void;
+}
+
+type AlertOptions = {
+    secret: string;
+    endpoint: string;
+};
+declare function alert({ secret, endpoint, }: AlertOptions): Promise<Response>;
+/**
+ * @see https://github.com/changesets/action/blob/main/src/run.ts
+ */
+type ChangesetsPublishedPackage = {
+    name: string;
+    version: string;
+};
+/**
+ * @see https://github.com/changesets/action/blob/main/src/run.ts
+ */
+type ChangesetsPublishResult = {
+    published: true;
+    publishedPackages: ChangesetsPublishedPackage[];
+} | {
+    published: false;
+};
+type PackageConfig<K extends string> = {
+    [key in K]: {
+        endpoint: string;
+    };
+};
+type SecretsConfig<K extends string> = {
+    [key in K]: string;
+};
+type ScrambleOptions<K extends string = string> = {
+    packageConfig: PackageConfig<K>;
+    secretsConfig: SecretsConfig<K>;
+    publishedPackages: ChangesetsPublishedPackage[];
+};
+type ScrambleResult<K extends string = string> = {
+    [key in K]: Response;
+};
+declare function scramble<K extends string = string>({ packageConfig, secretsConfig, publishedPackages, }: ScrambleOptions<K>): Promise<ScrambleResult<K>>;
+
+type klaxon_lib_AlertOptions = AlertOptions;
+type klaxon_lib_ChangesetsPublishResult = ChangesetsPublishResult;
+type klaxon_lib_ChangesetsPublishedPackage = ChangesetsPublishedPackage;
+type klaxon_lib_PackageConfig<K extends string> = PackageConfig<K>;
+type klaxon_lib_ScrambleOptions<K extends string = string> = ScrambleOptions<K>;
+type klaxon_lib_ScrambleResult<K extends string = string> = ScrambleResult<K>;
+type klaxon_lib_SecretsConfig<K extends string> = SecretsConfig<K>;
+declare const klaxon_lib_alert: typeof alert;
+declare const klaxon_lib_scramble: typeof scramble;
+declare namespace klaxon_lib {
+  export { type klaxon_lib_AlertOptions as AlertOptions, type klaxon_lib_ChangesetsPublishResult as ChangesetsPublishResult, type klaxon_lib_ChangesetsPublishedPackage as ChangesetsPublishedPackage, type klaxon_lib_PackageConfig as PackageConfig, type klaxon_lib_ScrambleOptions as ScrambleOptions, type klaxon_lib_ScrambleResult as ScrambleResult, type klaxon_lib_SecretsConfig as SecretsConfig, klaxon_lib_alert as alert, klaxon_lib_scramble as scramble };
 }
 
-export { FlightDeck, type FlightDeckOptions };
+export { FlightDeck, type FlightDeckOptions, klaxon_lib as Klaxon };