flightdeck 0.0.2 → 0.0.4

package/dist/lib.d.ts

@@ -1,36 +1,113 @@
-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;
-    protected restartTimes: number[];
-    alive: Future<unknown>;
+    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 logger: Pick<Console, `error` | `info` | `warn`>;
+    protected serviceLoggers: {
+        readonly [service in S]: Pick<Console, `error` | `info` | `warn`>;
+    };
+    servicesLive: Future<void>[];
+    servicesDead: Future<void>[];
+    live: Future<unknown>;
     dead: Future<unknown>;
+    protected restartTimes: number[];
     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;
+    protected getLatestRelease(): 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 };

package/dist/lib.js

@@ -1,66 +1,129 @@
-// 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;
-  restartTimes = [];
-  alive = new Future(() => {
+  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,
-      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.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`, () => {
-        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);
+          this.logger.info(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();
+                      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;
@@ -73,7 +136,7 @@ class FlightDeck {
               throw 405;
           }
         } catch (thrown) {
-          console.error(thrown, req.url);
+          this.logger.error(thrown, req.url);
           if (typeof thrown === `number`) {
             res.writeHead(thrown);
             res.end();
@@ -83,70 +146,91 @@ class FlightDeck {
         }
       });
     }).listen(PORT, () => {
-      console.log(`Server started on port ${PORT}`);
+      this.logger.info(`Server started on port ${PORT}`);
     });
-    this.startService();
+    this.startAllServices();
   }
-  startService() {
-    safety++;
-    if (safety > 10) {
-      throw new Error(`safety exceeded`);
+  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)) {
-      console.log(`Tried to start service but failed: Service ${this.serviceName} is not yet installed.`);
-      this.fetchLatestRelease();
+      this.logger.info(`Tried to start service but failed: could not find ${this.currentServiceDir}`);
+      this.getLatestRelease();
       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) => {
+      this.logger.info(`\uD83D\uDCAC`, ...messages);
     });
-    this.service.on(`readyToUpdate`, () => {
-      this.stopService();
+    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.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) => {
+      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) {
-        console.log(`Updates are ready; applying and restarting...`);
+        this.serviceLoggers[serviceName].info(`Updating 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) {
+          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() {
-    console.log(`Installing latest version of service ${this.serviceName}...`);
+    this.logger.info(`Applying update...`);
     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) {
+        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)) {
@@ -159,34 +243,89 @@ class FlightDeck {
       }
       renameSync(this.updateServiceDir, this.currentServiceDir);
       this.restartTimes = [];
+      this.servicesReadyToUpdate = { ...this.defaultServicesReadyToUpdate };
     } else {
-      console.log(`Service ${this.serviceName} is already up to date.`);
+      this.logger.error(`Tried to apply update but failed: could not find update directory ${this.updateServiceDir}`);
     }
   }
-  fetchLatestRelease() {
-    console.log(`Downloading latest version of service ${this.serviceName}...`);
+  getLatestRelease() {
+    this.logger.info(`Getting latest release...`);
     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}`);
+        this.logger.error(`Failed to get the latest release: ${thrown.message}`);
       }
       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() {
+    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 {
-      console.error(`Failed to stop service ${this.serviceName}: Service is not running.`);
+      this.serviceLoggers[serviceName].error(`Tried to stop service, but it wasn't 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.2",
+  "version": "0.0.4",
   "license": "MIT",
   "author": {
     "name": "Jeremy Banka",
@@ -17,12 +17,13 @@
   "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.1",
-    "comline": "0.1.0"
+    "atom.io": "0.29.2",
+    "comline": "0.1.1"
   },
   "devDependencies": {
     "@types/bun": "1.1.9",
@@ -32,14 +33,15 @@
     "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
 		})
 	}