@cedarjs/cli 7.0.1-next.314 → 7.0.1-next.466

package/dist/commands/deploy/baremetal/baremetalHandler.js

@@ -9,21 +9,34 @@ import { titleCase } from "title-case";
 import { colors as c } from "@cedarjs/cli-helpers/colors";
 import { formatCedarCommand } from "@cedarjs/cli-helpers/packageManager/display";
 import { getPackageManager } from "@cedarjs/project-config/packageManager";
-import { getPaths } from "../../../lib/index.js";
+import { getConfig, getPaths } from "../../../lib/index.js";
+import { MONITOR_ADAPTERS, MONITORS, isMonitor } from "./monitors.js";
 const CONFIG_FILENAME = "deploy.toml";
+const DOCS_URL = "https://cedarjs.com/docs/deploy/baremetal";
 const SYMLINK_FLAGS = "-nsf";
 const CURRENT_RELEASE_SYMLINK_NAME = "current";
 const LIFECYCLE_HOOKS = ["before", "after"];
+const DEFAULT_HEALTH_CHECK_PATH = "/graphql/health";
+const HEALTH_CHECK_INTERVAL_MS = 2e3;
+const HEALTH_CHECK_REQUEST_TIMEOUT_SECONDS = 5;
+const WEB_DIST_DIRS = ["web/dist", "web/dist/browser"];
+const BUILD_MANIFEST_FILENAME = "client-build-manifest.json";
+const LINK_BATCH_SIZE = 100;
+const RELEASE_DIR_PATTERN = "^[0-9]{14}$";
+const releaseDirRegExp = new RegExp(RELEASE_DIR_PATTERN);
+const DEFAULT_MONITOR = "pm2";
 const DEFAULT_SERVER_CONFIG = {
   port: 22,
   branch: "main",
   packageManagerCommand: getPackageManager(),
-  monitorCommand: "pm2",
+  monitor: DEFAULT_MONITOR,
   sides: ["api", "web"],
   keepReleases: 5,
-  freeSpaceRequired: 2048
+  freeSpaceRequired: 2048,
+  healthCheckTimeout: 30
 };
 const pathJoin = path.posix.join;
+const shellQuote = (value) => `'${value.replaceAll("'", `'\\''`)}'`;
 const throwMissingConfig = (name) => {
   throw new Error(
     `"${name}" config option not set. See https://cedarjs.com/docs/deployment/baremetal#deploytoml`
@@ -40,6 +53,17 @@ const verifyConfig = (config, yargs) => {
   }
   return true;
 };
+const isHttpUrl = (value) => {
+  if (typeof value !== "string") {
+    return false;
+  }
+  try {
+    const { protocol } = new URL(value);
+    return protocol === "http:" || protocol === "https:";
+  } catch {
+    return false;
+  }
+};
 const verifyServerConfig = (config) => {
   if (!config.host) {
     throwMissingConfig("host");
@@ -53,6 +77,17 @@ const verifyServerConfig = (config) => {
   if (!/^\d+$/.test(String(config.freeSpaceRequired))) {
     throw new Error('"freeSpaceRequired" must be an integer >= 0');
   }
+  if (config.healthCheckUrl !== void 0 && config.healthCheckUrl !== false && !isHttpUrl(config.healthCheckUrl)) {
+    throw new Error('"healthCheckUrl" must be an http(s) URL or `false`');
+  }
+  if (!/^\d+$/.test(String(config.healthCheckTimeout))) {
+    throw new Error('"healthCheckTimeout" must be an integer >= 0');
+  }
+  if (!isMonitor(config.monitor)) {
+    throw new Error(
+      `"monitor" must be one of ${MONITORS.map((monitor) => `"${monitor}"`).join(", ")}`
+    );
+  }
   return true;
 };
 const symlinkCurrentCommand = async (dir, ssh, deployPath) => {
@@ -62,17 +97,110 @@ const symlinkCurrentCommand = async (dir, ssh, deployPath) => {
     CURRENT_RELEASE_SYMLINK_NAME
   ]);
 };
-const restartProcessCommand = async (processName, ssh, serverConfig, deployPath) => {
-  return await ssh.exec(deployPath, serverConfig.monitorCommand, [
-    "restart",
-    processName
-  ]);
+const monitorAdapter = (serverConfig) => MONITOR_ADAPTERS[serverConfig.monitor];
+const runMonitorCommand = async (command, ssh, serverConfig) => {
+  return await ssh.exec(
+    serverConfig.path,
+    serverConfig.monitorCommand,
+    command.args
+  );
+};
+const monitorTask = (command, ssh, serverConfig, skip) => {
+  return {
+    title: command.title,
+    task: async () => {
+      await runMonitorCommand(command, ssh, serverConfig);
+    },
+    ...skip ? { skip } : {}
+  };
+};
+const healthCheckUrl = (serverConfig) => {
+  if (serverConfig.healthCheckUrl === false) {
+    return void 0;
+  }
+  if (serverConfig.healthCheckUrl) {
+    return serverConfig.healthCheckUrl;
+  }
+  if (!serverConfig.sides.includes("api")) {
+    return void 0;
+  }
+  return `http://localhost:${getConfig().api.port}${DEFAULT_HEALTH_CHECK_PATH}`;
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const waitForHealthCheck = async ({
+  url,
+  timeoutSeconds,
+  ssh,
+  serverConfig,
+  nextSteps,
+  onFailedAttempt
+}) => {
+  const deadline = Date.now() + timeoutSeconds * 1e3;
+  let lastFailure = "";
+  let keepTrying = true;
+  while (keepTrying) {
+    try {
+      await ssh.exec(serverConfig.path, "curl", [
+        "--fail",
+        "--location",
+        "--silent",
+        "--show-error",
+        "--output",
+        "/dev/null",
+        "--max-time",
+        String(HEALTH_CHECK_REQUEST_TIMEOUT_SECONDS),
+        shellQuote(url)
+      ]);
+      return;
+    } catch (e) {
+      lastFailure = e instanceof Error ? e.message : String(e);
+      onFailedAttempt?.(lastFailure);
+    }
+    keepTrying = Date.now() + HEALTH_CHECK_INTERVAL_MS <= deadline;
+    if (keepTrying) {
+      await sleep(HEALTH_CHECK_INTERVAL_MS);
+    }
+  }
+  throw new Error(
+    [
+      `Health check failed: ${url} did not respond successfully within ${timeoutSeconds} seconds of restarting the ${serverConfig.processNames?.join(", ")} process(es).`,
+      `Last attempt: ${lastFailure}`,
+      "",
+      ...nextSteps,
+      `If your app serves its health check somewhere else, set \`healthCheckUrl\` in deploy.toml. Set it to \`false\` to skip the check. See ${DOCS_URL}#health-check`
+    ].join("\n")
+  );
+};
+const healthCheckTask = (url, ssh, serverConfig, nextSteps) => {
+  return {
+    title: url ? `Checking ${url}...` : "Checking health...",
+    task: async (_ctx, task) => {
+      if (!url) {
+        return;
+      }
+      await waitForHealthCheck({
+        url,
+        timeoutSeconds: parseInt(String(serverConfig.healthCheckTimeout), 10),
+        ssh,
+        serverConfig,
+        nextSteps,
+        onFailedAttempt: (reason) => {
+          task.output = reason;
+        }
+      });
+    },
+    skip: () => !url
+  };
 };
 const serverConfigWithDefaults = (serverConfig, yargs) => {
+  const monitor = serverConfig.monitor ?? DEFAULT_SERVER_CONFIG.monitor;
+  const monitorCommand = serverConfig.monitorCommand ?? (isMonitor(monitor) ? MONITOR_ADAPTERS[monitor].defaultCommand : "");
   return {
     ...DEFAULT_SERVER_CONFIG,
     ...serverConfig,
-    branch: yargs.branch || serverConfig.branch || DEFAULT_SERVER_CONFIG.branch
+    branch: yargs.branch || serverConfig.branch || DEFAULT_SERVER_CONFIG.branch,
+    monitor,
+    monitorCommand
   };
 };
 const maintenanceTasks = (status, ssh, serverConfig) => {
@@ -94,26 +222,24 @@ const maintenanceTasks = (status, ssh, serverConfig) => {
       }
     });
     if (serverConfig.processNames) {
-      tasks.push({
-        title: `Stopping ${serverConfig.processNames.join(", ")} processes...`,
-        task: async () => {
-          await ssh.exec(serverConfig.path, serverConfig.monitorCommand, [
-            "stop",
-            serverConfig.processNames.join(" ")
-          ]);
-        }
-      });
+      tasks.push(
+        monitorTask(
+          monitorAdapter(serverConfig).stop(serverConfig.processNames),
+          ssh,
+          serverConfig
+        )
+      );
     }
   } else if (status === "down") {
-    tasks.push({
-      title: `Starting ${serverConfig.processNames?.join(", ")} processes...`,
-      task: async () => {
-        await ssh.exec(serverConfig.path, serverConfig.monitorCommand, [
-          "start",
-          serverConfig.processNames.join(" ")
-        ]);
-      }
-    });
+    if (serverConfig.processNames) {
+      tasks.push(
+        monitorTask(
+          monitorAdapter(serverConfig).start(serverConfig.processNames),
+          ssh,
+          serverConfig
+        )
+      );
+    }
     if (serverConfig.processNames) {
       tasks.push({
         title: `Disabling maintenance page...`,
@@ -141,8 +267,13 @@ const rollbackTasks = (count, ssh, serverConfig) => {
       title: `Rolling back ${rollbackCount} release(s)...`,
       task: async () => {
         const currentLink = (await ssh.exec(serverConfig.path, "readlink", ["-f", "current"])).stdout.split("/").pop();
-        const dirs = (await ssh.exec(serverConfig.path, "ls", ["-t"])).stdout.split("\n").filter((dirs2) => !dirs2.match(/current/));
+        const dirs = (await ssh.exec(serverConfig.path, "ls", ["-t"])).stdout.split("\n").filter((dir) => releaseDirRegExp.test(dir));
         const deployedIndex = dirs.indexOf(currentLink ?? "");
+        if (deployedIndex === -1) {
+          throw new Error(
+            `Cannot rollback: \`current\` points to "${currentLink}", which is not a timestamp-named release directory`
+          );
+        }
         const rollbackIndex = deployedIndex + rollbackCount;
         if (dirs[rollbackIndex]) {
           console.info("Setting symlink");
@@ -153,26 +284,22 @@ const rollbackTasks = (count, ssh, serverConfig) => {
           );
         } else {
           throw new Error(
-            `Cannot rollback ${rollbackCount} release(s): ${dirs.length - dirs.indexOf(currentLink ?? "") - 1} previous release(s) available`
+            `Cannot rollback ${rollbackCount} release(s): ${dirs.length - deployedIndex - 1} previous release(s) available`
           );
         }
       }
     }
   ];
   if (serverConfig.processNames) {
+    const adapter = monitorAdapter(serverConfig);
     for (const processName of serverConfig.processNames) {
-      tasks.push({
-        title: `Restarting ${processName} process...`,
-        task: async () => {
-          await restartProcessCommand(
-            processName,
-            ssh,
-            serverConfig,
-            serverConfig.path
-          );
-        }
-      });
+      tasks.push(monitorTask(adapter.restart(processName), ssh, serverConfig));
     }
+    tasks.push(
+      healthCheckTask(healthCheckUrl(serverConfig), ssh, serverConfig, [
+        "The release you rolled back to is live as `current`. Check the process logs on the server, or run the rollback again with `--rollback` to move one more release back."
+      ])
+    );
   }
   return tasks;
 };
@@ -203,6 +330,134 @@ const commandWithLifecycleEvents = ({
   tasks.push(lifecycleTask("after", name, skip, config));
   return tasks.flat().filter((t) => Boolean(t));
 };
+const manifestAssetFiles = (manifestJson) => {
+  const manifest = JSON.parse(manifestJson);
+  const files = /* @__PURE__ */ new Set();
+  if (!manifest || typeof manifest !== "object") {
+    return [];
+  }
+  for (const entry of Object.values(manifest)) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    if ("file" in entry && typeof entry.file === "string") {
+      files.add(entry.file);
+    }
+    for (const key of ["css", "assets"]) {
+      if (!(key in entry) || !Array.isArray(entry[key])) {
+        continue;
+      }
+      for (const item of entry[key]) {
+        if (typeof item === "string") {
+          files.add(item);
+        }
+      }
+    }
+  }
+  return [...files];
+};
+const readBuildManifest = async (ssh, releasePath) => {
+  for (const distDir of WEB_DIST_DIRS) {
+    let stdout;
+    try {
+      ;
+      ({ stdout } = await ssh.exec(pathJoin(releasePath, distDir), "cat", [
+        BUILD_MANIFEST_FILENAME
+      ]));
+    } catch {
+      continue;
+    }
+    const jsonStart = stdout.indexOf("{");
+    const json = jsonStart === -1 ? stdout : stdout.slice(jsonStart);
+    try {
+      return { distDir, files: manifestAssetFiles(json) };
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      throw new Error(
+        `Could not parse ${pathJoin(releasePath, distDir, BUILD_MANIFEST_FILENAME)}: ${message}`
+      );
+    }
+  }
+  return void 0;
+};
+const keepPreviousAssets = async (yargs, ssh, serverConfig) => {
+  const newReleasePath = pathJoin(serverConfig.path, yargs.releaseDir);
+  let newRelease;
+  try {
+    newRelease = await readBuildManifest(ssh, newReleasePath);
+  } catch (e) {
+    const reason = e instanceof Error ? e.message : String(e);
+    return { status: "skipped", reason };
+  }
+  if (!newRelease) {
+    return {
+      status: "skipped",
+      reason: `No ${BUILD_MANIFEST_FILENAME} in ` + WEB_DIST_DIRS.map((dir) => pathJoin(yargs.releaseDir, dir)).join(
+        " or "
+      )
+    };
+  }
+  const { stdout } = await ssh.exec(serverConfig.path, "ls");
+  const previousReleases = stdout.split("\n").map((line) => line.trim()).filter((dir) => releaseDirRegExp.test(dir) && dir !== yargs.releaseDir).sort().reverse().slice(0, Math.max(serverConfig.keepReleases - 1, 0));
+  const presentFiles = new Set(newRelease.files);
+  const warnings = [];
+  let linkedCount = 0;
+  for (const release of previousReleases) {
+    const releasePath = pathJoin(serverConfig.path, release);
+    let previousRelease;
+    try {
+      previousRelease = await readBuildManifest(ssh, releasePath);
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      warnings.push(`Skipping the web assets of release ${release}: ${message}`);
+      continue;
+    }
+    if (!previousRelease) {
+      warnings.push(
+        `Release ${release} has no web build manifest, skipping its assets`
+      );
+      continue;
+    }
+    const missingFiles = previousRelease.files.filter(
+      (file) => !presentFiles.has(file)
+    );
+    if (missingFiles.length === 0) {
+      continue;
+    }
+    const filesByDir = /* @__PURE__ */ new Map();
+    for (const file of missingFiles) {
+      const dir = path.posix.dirname(file);
+      filesByDir.set(dir, [...filesByDir.get(dir) ?? [], file]);
+    }
+    try {
+      for (const [dir, files] of filesByDir) {
+        const targetDir = pathJoin(newReleasePath, newRelease.distDir, dir);
+        await ssh.exec(newReleasePath, "mkdir", ["-p", shellQuote(targetDir)]);
+        for (let i = 0; i < files.length; i += LINK_BATCH_SIZE) {
+          const sources = files.slice(i, i + LINK_BATCH_SIZE).map(
+            (file) => shellQuote(pathJoin(releasePath, previousRelease.distDir, file))
+          );
+          await ssh.exec(newReleasePath, "ln", [
+            "-f",
+            ...sources,
+            shellQuote(targetDir)
+          ]);
+        }
+      }
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      warnings.push(
+        `Could not keep the web assets of release ${release}: ${message}`
+      );
+      continue;
+    }
+    for (const file of missingFiles) {
+      presentFiles.add(file);
+    }
+    linkedCount += missingFiles.length;
+  }
+  return { status: "done", linkedCount, warnings };
+};
 const deployTasks = (yargs, ssh, serverConfig, serverLifecycle) => {
   const cmdPath = pathJoin(serverConfig.path, yargs.releaseDir);
   const config = {
@@ -351,6 +606,46 @@ const deployTasks = (yargs, ssh, serverConfig, serverLifecycle) => {
       })
     );
   }
+  tasks.push(
+    ...commandWithLifecycleEvents({
+      name: "keepAssets",
+      config,
+      skip: !yargs.keepAssets || !yargs.build || !serverConfig.sides.includes("web"),
+      command: {
+        title: `Keeping web assets of previous releases...`,
+        task: async (_ctx, task) => {
+          const result = await keepPreviousAssets(yargs, ssh, serverConfig);
+          if (result.status === "skipped") {
+            return task.skip(
+              c.warning(
+                `Warning: ${result.reason}, not keeping the web assets of previous releases`
+              )
+            );
+          }
+          task.output = [
+            `Linked ${result.linkedCount} file(s) from previous releases`,
+            ...result.warnings.map((warning) => c.warning(warning))
+          ].join("\n");
+        }
+      }
+    })
+  );
+  if (serverConfig.processNames && yargs.firstRun) {
+    const configFile = monitorAdapter(serverConfig).firstRunConfigFile;
+    if (configFile) {
+      tasks.push({
+        title: `Checking for ${configFile}...`,
+        task: () => {
+          if (!fs.existsSync(path.join(getPaths().base, configFile))) {
+            throw new Error(
+              `${configFile} is missing. The ${serverConfig.monitor} monitor reads it when starting processes for the first time. Run \`${formatCedarCommand(["setup", "deploy", "baremetal"])}\` to generate it, or deploy without \`--first-run\` if the processes are already running.`
+            );
+          }
+        },
+        skip: () => !yargs.restart
+      });
+    }
+  }
   tasks.push(
     ...commandWithLifecycleEvents({
       name: "symlinkCurrent",
@@ -366,56 +661,56 @@ const deployTasks = (yargs, ssh, serverConfig, serverLifecycle) => {
     })
   );
   if (serverConfig.processNames) {
+    const adapter = monitorAdapter(serverConfig);
+    const skipRestart = () => !yargs.restart;
+    if (yargs.firstRun) {
+      for (const command of adapter.firstRunSetup) {
+        tasks.push(monitorTask(command, ssh, serverConfig, skipRestart));
+      }
+    }
     for (const processName of serverConfig.processNames) {
       if (yargs.firstRun) {
+        const [firstCommand, ...followUpCommands] = adapter.firstRun(processName);
+        if (!firstCommand) {
+          continue;
+        }
         tasks.push(
           ...commandWithLifecycleEvents({
             name: "restart",
             config,
             skip: !yargs.restart,
-            command: {
-              title: `Starting ${processName} process for the first time...`,
-              task: async () => {
-                await ssh.exec(serverConfig.path, serverConfig.monitorCommand, [
-                  "start",
-                  pathJoin(CURRENT_RELEASE_SYMLINK_NAME, "ecosystem.config.js"),
-                  "--only",
-                  processName
-                ]);
-              }
-            }
+            command: monitorTask(firstCommand, ssh, serverConfig)
           })
         );
-        tasks.push({
-          title: `Saving ${processName} state for future startup...`,
-          task: async () => {
-            await ssh.exec(serverConfig.path, serverConfig.monitorCommand, [
-              "save"
-            ]);
-          },
-          skip: () => !yargs.restart
-        });
+        for (const command of followUpCommands) {
+          tasks.push(monitorTask(command, ssh, serverConfig, skipRestart));
+        }
       } else {
         tasks.push(
           ...commandWithLifecycleEvents({
             name: "restart",
             config,
             skip: !yargs.restart,
-            command: {
-              title: `Restarting ${processName} process...`,
-              task: async () => {
-                await restartProcessCommand(
-                  processName,
-                  ssh,
-                  serverConfig,
-                  serverConfig.path
-                );
-              }
-            }
+            command: monitorTask(
+              adapter.restart(processName),
+              ssh,
+              serverConfig
+            )
           })
         );
       }
     }
+    const url = healthCheckUrl(serverConfig);
+    tasks.push(
+      ...commandWithLifecycleEvents({
+        name: "healthCheck",
+        config: { ...config, cmdPath: serverConfig.path },
+        skip: !yargs.restart || !url,
+        command: healthCheckTask(url, ssh, serverConfig, [
+          `The new release is live as \`current\`. Check the process logs on the server, or roll back to the previous release with \`${formatCedarCommand(["deploy", "baremetal", yargs.environment, "--rollback"])}\`.`
+        ])
+      })
+    );
   }
   tasks.push(
     ...commandWithLifecycleEvents({
@@ -425,10 +720,10 @@ const deployTasks = (yargs, ssh, serverConfig, serverLifecycle) => {
       command: {
         title: `Cleaning up old deploys...`,
         task: async () => {
-          const fileStartIndex = serverConfig.keepReleases + 2;
+          const fileStartIndex = serverConfig.keepReleases + 1;
           await ssh.exec(
             serverConfig.path,
-            `ls -t | tail -n +${fileStartIndex} | xargs rm -rf`
+            `ls -t | grep -E '${RELEASE_DIR_PATTERN}' | tail -n +${fileStartIndex} | xargs -r rm -rf`
           );
         }
       }
@@ -552,9 +847,8 @@ const warnIfUnpushedCommits = async () => {
 };
 const handler = async (yargs) => {
   const { SshExecutor } = await import("./SshExecutor.js");
-  const tomlPath = path.join(getPaths().base, "deploy.toml");
-  const ecosystemPath = path.join(getPaths().base, "ecosystem.config.js");
-  if (!fs.existsSync(tomlPath) || !fs.existsSync(ecosystemPath)) {
+  const tomlPath = path.join(getPaths().base, CONFIG_FILENAME);
+  if (!fs.existsSync(tomlPath)) {
     console.error(
       c.error("\nError: Baremetal deploy has not been properly setup.\n") + `Please run \`${formatCedarCommand(["setup", "deploy", "baremetal"])}\` before deploying`
     );
@@ -587,17 +881,22 @@ const handler = async (yargs) => {
 };
 export {
   DEFAULT_SERVER_CONFIG,
+  RELEASE_DIR_PATTERN,
   commandWithLifecycleEvents,
   commands,
   deployTasks,
   handler,
+  healthCheckUrl,
+  keepPreviousAssets,
   lifecycleTask,
   maintenanceTasks,
+  manifestAssetFiles,
   parseConfig,
   rollbackTasks,
   serverConfigWithDefaults,
   throwMissingConfig,
   verifyConfig,
   verifyServerConfig,
+  waitForHealthCheck,
   warnIfUnpushedCommits
 };

package/dist/commands/deploy/baremetal/monitors.js

@@ -0,0 +1,66 @@
+const MONITORS = ["pm2", "systemd-user", "systemd-system"];
+const pm2 = {
+  defaultCommand: "pm2",
+  firstRunConfigFile: "ecosystem.config.js",
+  firstRunSetup: [],
+  firstRun: (processName) => [
+    {
+      title: `Starting ${processName} process for the first time...`,
+      args: ["start", "current/ecosystem.config.js", "--only", processName]
+    },
+    {
+      title: `Saving ${processName} state for future startup...`,
+      args: ["save"]
+    }
+  ],
+  restart: (processName) => ({
+    title: `Restarting ${processName} process...`,
+    args: ["restart", processName]
+  }),
+  stop: (processNames) => ({
+    title: `Stopping ${processNames.join(", ")} processes...`,
+    args: ["stop", ...processNames]
+  }),
+  start: (processNames) => ({
+    title: `Starting ${processNames.join(", ")} processes...`,
+    args: ["start", ...processNames]
+  })
+};
+const systemd = (defaultCommand) => ({
+  defaultCommand,
+  firstRunSetup: [
+    {
+      title: "Reloading systemd unit files...",
+      args: ["daemon-reload"]
+    }
+  ],
+  firstRun: (processName) => [
+    {
+      title: `Enabling and starting ${processName} for the first time...`,
+      args: ["enable", "--now", processName]
+    }
+  ],
+  restart: (processName) => ({
+    title: `Restarting ${processName}...`,
+    args: ["restart", processName]
+  }),
+  stop: (processNames) => ({
+    title: `Stopping ${processNames.join(", ")}...`,
+    args: ["stop", ...processNames]
+  }),
+  start: (processNames) => ({
+    title: `Starting ${processNames.join(", ")}...`,
+    args: ["start", ...processNames]
+  })
+});
+const MONITOR_ADAPTERS = {
+  pm2,
+  "systemd-user": systemd("systemctl --user"),
+  "systemd-system": systemd("sudo systemctl")
+};
+const isMonitor = (value) => typeof value === "string" && MONITORS.includes(value);
+export {
+  MONITORS,
+  MONITOR_ADAPTERS,
+  isMonitor
+};

package/dist/commands/deploy/baremetal.js

@@ -48,6 +48,11 @@ const builder = (yargs) => {
     default: true,
     type: "boolean"
   });
+  yargs.option("keep-assets", {
+    describe: "Hardlink previous releases' hashed web assets into the new release so open browser tabs keep working after the deploy",
+    default: true,
+    type: "boolean"
+  });
   yargs.option("releaseDir", {
     describe: "Directory to create for the latest release, defaults to timestamp",
     default: (/* @__PURE__ */ new Date()).toISOString().replace(/[:\-TZ]/g, "").replace(/\.\d+$/, ""),
@@ -95,6 +100,7 @@ async function handler(yargs) {
     build: yargs.build,
     restart: yargs.restart,
     cleanup: yargs.cleanup,
+    keepAssets: yargs.keepAssets,
     maintenance: yargs.maintenance,
     rollback: yargs.rollback,
     verbose: yargs.verbose,