@rpcbase/cli 0.181.0 → 0.183.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/cli",
-  "version": "0.181.0",
+  "version": "0.183.0",
   "type": "module",
   "files": [
     "src"

package/src/cmd-deploy/detect-compose-changes.js

@@ -53,11 +53,10 @@ const hashTree = (rootDir) => {
   }
 }
 
-const buildRsyncCmd = ({ includeArgs, excludeArgs, keyPath, source, dest, remote }) => {
+const buildRsyncCmd = ({ filterArgs, keyPath, source, dest, remote }) => {
   const parts = [
     "rsync -az --delete --filter=':- .gitignore'",
-    includeArgs.join(" "),
-    excludeArgs,
+    filterArgs,
     remote ? `-e "ssh -i '${keyPath}' -o StrictHostKeyChecking=no"` : null,
     source,
     dest,
@@ -75,15 +74,27 @@ const runRsync = (cmd) => {
   }
 }
 
-// Pull remote compose files into a temp dir, mirror local ones into another, then hash trees to detect diffs.
+// Pull tracked deployment files into temp dirs, then hash the trees to detect diffs.
 // Callers await this check; errors bubble up except for benign rsync statuses handled in runRsync.
-export const detectComposeChanges = async ({ keyPath, user, host, deployDir, log, extraExcludes = [] }) => {
-  const includeArgs = ["--include='*/'", "--include='*compose*.yml'", "--exclude='*'"]
-  const excludeArgs = baseExcludeList
+export const detectComposeChanges = async ({
+  keyPath,
+  user,
+  host,
+  deployDir,
+  localSource = "./",
+  log,
+  extraExcludes = [],
+  includePatterns = ["*compose*.yml"],
+}) => {
+  const excludePatterns = baseExcludeList
     // dev compose files are not relevant for prod deploy checks
     .concat(["compose.dev.yml"])
     .concat(extraExcludes)
-    .map((p) => `--exclude='${p}'`)
+
+  const filterArgs = excludePatterns.map((pattern) => `--exclude='${pattern}'`)
+    .concat(["--include='*/'"])
+    .concat(includePatterns.map((pattern) => `--include='${pattern}'`))
+    .concat(["--exclude='*'"])
     .join(" ")
 
   const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "rb-compose-"))
@@ -102,8 +113,7 @@ export const detectComposeChanges = async ({ keyPath, user, host, deployDir, log
 
   try {
     const remoteSyncCmd = buildRsyncCmd({
-      includeArgs,
-      excludeArgs,
+      filterArgs,
       keyPath,
       source: `${user}@${host}:~/apps/${deployDir}/`,
       dest: `${remoteDir}/`,
@@ -113,10 +123,9 @@ export const detectComposeChanges = async ({ keyPath, user, host, deployDir, log
     runRsync(remoteSyncCmd)
 
     const localSyncCmd = buildRsyncCmd({
-      includeArgs,
-      excludeArgs,
+      filterArgs,
       keyPath,
-      source: "./",
+      source: `${localSource.replace(/\/$/, "")}/`,
       dest: `${localDir}/`,
       remote: false,
     })
@@ -150,7 +159,7 @@ export const detectComposeChanges = async ({ keyPath, user, host, deployDir, log
     if (missingLocal.length) summary.push(`Only on remote: ${missingLocal.join(", ")}`)
     if (missingRemote.length) summary.push(`Only on local: ${missingRemote.join(", ")}`)
     if (changed.length) summary.push(`Content differs: ${changed.join(", ")}`)
-    if (!hasChanges) summary.push("Compose files are identical.")
+    if (!hasChanges) summary.push("Tracked deployment files are identical.")
 
     return { hasChanges, output: summary.join("\n") }
   } finally {

package/src/cmd-deploy/index.js

@@ -7,6 +7,180 @@ import validator from "validator"
 
 import { purgeCloudflareCaches } from "./purge-cloudflare.js"
 import { baseExcludeList, detectComposeChanges } from "./detect-compose-changes.js"
+import { createPrivateApiClient } from "./private-api.js"
+
+
+const deploymentInstances = ["a", "b"]
+
+const normalizeInstance = (instance) => {
+  if (!instance) return null
+  const normalized = String(instance).trim().toLowerCase()
+  return deploymentInstances.includes(normalized) ? normalized : null
+}
+
+const parseInstance = (instance) => {
+  const normalized = normalizeInstance(instance)
+  if (!normalized) throw new Error(`Invalid deployment instance: ${instance}`)
+  return normalized
+}
+
+const getOtherInstance = (instance) => instance === "a" ? "b" : "a"
+
+const getInstanceDeployDir = (baseDeployDir, instance) => `${baseDeployDir}-${instance}`
+
+const sleep = async (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+
+const sharedInfrastructureIncludePatterns = [
+  "infrastructure/compose.yml",
+  "infrastructure/compose.instances.yml",
+  "infrastructure/package.json",
+  "infrastructure/package-lock.json",
+  "infrastructure/ensure-*",
+  "infrastructure/mongot/***",
+  ".env",
+  ".env.*",
+]
+
+const sharedInfrastructureExcludePatterns = [
+  "infrastructure/data/***",
+]
+
+const toArray = (value) => {
+  if (value == null) return []
+  return Array.isArray(value) ? value : [value]
+}
+
+const shellQuote = (value) => `'${String(value).replace(/'/g, "'\\''")}'`
+
+const withTrailingSlash = (value) => `${String(value).replace(/\/$/, "")}/`
+
+const resolveFrom = (baseDir, value) => (
+  path.isAbsolute(value) ? value : path.resolve(baseDir, value)
+)
+
+const toRelativePattern = (baseDir, value) => {
+  const resolved = resolveFrom(baseDir, value)
+  const relative = path.relative(baseDir, resolved)
+  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return null
+  return relative.split(path.sep).join("/")
+}
+
+const buildRsyncFilterArgs = ({ includes = [], excludes = [] }) => {
+  const excludeArgs = excludes.map((pattern) => `--exclude=${shellQuote(pattern)}`)
+
+  if (includes.length === 0) return excludeArgs.join(" ")
+
+  return excludeArgs
+    .concat(["--include='*/'"])
+    .concat(includes.map((pattern) => `--include=${shellQuote(pattern)}`))
+    .concat(["--exclude='*'"])
+    .join(" ")
+}
+
+const prepareDeploySource = ({
+  sourceDir,
+  infrastructureDir,
+  sharedEnvFiles,
+  includePatterns,
+  excludePatterns,
+  log,
+}) => {
+  if (!fs.existsSync(sourceDir) || !fs.statSync(sourceDir).isDirectory()) {
+    throw new Error(`Deploy source directory does not exist: ${sourceDir}`)
+  }
+
+  const defaultInfrastructureDir = path.resolve(sourceDir, "infrastructure")
+  const needsStaging = (
+    sourceDir !== process.cwd() ||
+    infrastructureDir !== defaultInfrastructureDir ||
+    sharedEnvFiles.length > 0 ||
+    includePatterns.length > 0
+  )
+
+  if (!needsStaging) {
+    return {
+      deployRoot: sourceDir,
+      sharedEnvFileNames: [],
+      cleanup: () => {},
+    }
+  }
+
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "rb-deploy-"))
+  const deployRoot = path.join(tempRoot, "root")
+  fs.mkdirSync(deployRoot)
+  const cleanup = () => {
+    try {
+      fs.rmSync(tempRoot, { recursive: true, force: true })
+    } catch (err) {
+      console.warn(`Cleanup failed for ${tempRoot}: ${err}`)
+    }
+  }
+
+  try {
+    const sharedEnvSourceExcludes = sharedEnvFiles
+      .map((filePath) => toRelativePattern(sourceDir, filePath))
+      .filter(Boolean)
+
+    const sourceFilterArgs = buildRsyncFilterArgs({
+      includes: includePatterns,
+      excludes: baseExcludeList.concat(sharedEnvSourceExcludes).concat(excludePatterns),
+    })
+
+    const sourceRsyncCmd = [
+      "rsync -a",
+      includePatterns.length > 0 ? "--prune-empty-dirs" : null,
+      "--delete",
+      sourceFilterArgs,
+      shellQuote(withTrailingSlash(sourceDir)),
+      shellQuote(withTrailingSlash(deployRoot)),
+    ].filter(Boolean).join(" ")
+
+    log(`Preparing deploy source: ${sourceRsyncCmd}`)
+    execSync(sourceRsyncCmd, { stdio: "ignore" })
+
+    if (fs.existsSync(infrastructureDir)) {
+      const deployInfrastructureDir = path.join(deployRoot, "infrastructure")
+      fs.mkdirSync(deployInfrastructureDir, { recursive: true })
+
+      const infrastructureRsyncCmd = [
+        "rsync -a",
+        "--delete",
+        buildRsyncFilterArgs({ excludes: baseExcludeList.concat(["data/"]).concat(excludePatterns) }),
+        shellQuote(withTrailingSlash(infrastructureDir)),
+        shellQuote(withTrailingSlash(deployInfrastructureDir)),
+      ].filter(Boolean).join(" ")
+
+      log(`Preparing infrastructure source: ${infrastructureRsyncCmd}`)
+      execSync(infrastructureRsyncCmd, { stdio: "ignore" })
+    } else if (infrastructureDir !== defaultInfrastructureDir) {
+      throw new Error(`Infrastructure directory does not exist: ${infrastructureDir}`)
+    }
+
+    const sharedEnvFileNames = []
+    for (const sharedEnvFile of sharedEnvFiles) {
+      const sourcePath = resolveFrom(sourceDir, sharedEnvFile)
+      if (!fs.existsSync(sourcePath) || !fs.statSync(sourcePath).isFile()) {
+        throw new Error(`Shared env file does not exist: ${sourcePath}`)
+      }
+
+      const fileName = path.basename(sourcePath)
+      if (sharedEnvFileNames.includes(fileName)) {
+        throw new Error(`Multiple shared env files resolve to ${fileName}`)
+      }
+      sharedEnvFileNames.push(fileName)
+      fs.copyFileSync(sourcePath, path.join(deployRoot, fileName))
+    }
+
+    return {
+      deployRoot,
+      sharedEnvFileNames,
+      cleanup,
+    }
+  } catch (err) {
+    cleanup()
+    throw err
+  }
+}
 
 
 export const deploy = async (argv) => {
@@ -50,12 +224,17 @@ export const deploy = async (argv) => {
 
   const host = RB_SSH_HOST
   const user = RB_SSH_USER
-  const deployDir = RB_DEPLOY_DIR
+  const baseDeployDir = RB_DEPLOY_DIR
+  const sourceDir = resolveFrom(process.cwd(), argv.sourceDir || ".")
+  const infrastructureDir = resolveFrom(sourceDir, argv.infrastructureDir || "infrastructure")
+  const sharedEnvFiles = toArray(argv.sharedEnvFile)
+  const deployIncludePatterns = toArray(argv.include)
+  const deployExcludePatterns = toArray(argv.exclude).concat(toArray(argv.ignore))
   let keyPath = RB_SSH_KEY
 
   let tempKeyPath = null
+  let preparedDeploy = null
 
-  // Create an SSH function that can be reused
   const ssh = async (command, stdioInherit = false) => {
     const sshCommand = `ssh -i "${keyPath}" -o StrictHostKeyChecking=no ${user}@${host} "${command}"`
     log(`${command}`)
@@ -66,6 +245,47 @@ export const deploy = async (argv) => {
     return res
   }
 
+  const syncSharedEnvFiles = (deployRoot, sharedEnvFileNames) => {
+    const envFiles = sharedEnvFileNames.length > 0
+      ? sharedEnvFileNames
+      : fs.readdirSync(deployRoot)
+        .filter((name) => name === ".env" || name.startsWith(".env."))
+
+    if (envFiles.length === 0) return
+
+    const rsyncCmd = [
+      "rsync -avz",
+      `-e "ssh -i '${keyPath}' -o StrictHostKeyChecking=no"`,
+      ...envFiles.map((name) => shellQuote(path.join(deployRoot, name))),
+      `${user}@${host}:~/apps/${baseDeployDir}/`,
+    ].join(" ")
+
+    log(`Running: ${rsyncCmd}`)
+    execSync(rsyncCmd, { stdio: argv.verbose ? "inherit" : "ignore" })
+  }
+
+  const runInstanceAction = async (action, instance) => {
+    await ssh(`cd ~/apps/${baseDeployDir}/infrastructure && node ctrl.js ${action}-instance ${instance} prod`, true)
+  }
+
+  const waitForInstance = async (instance, target) => {
+    const port = Number(target?.port)
+    if (!Number.isFinite(port) || port <= 0) throw new Error(`Cannot healthcheck instance ${instance}: invalid port`)
+
+    const url = `http://127.0.0.1:${port}/`
+    for (let attempt = 1; attempt <= 60; attempt += 1) {
+      try {
+        await ssh(`node -e "fetch('${url}').then((res)=>process.exit(res.status < 500 ? 0 : 1)).catch(()=>process.exit(1))"`)
+        console.log(`Instance ${instance} is healthy at ${url}`)
+        return
+      } catch {
+        await sleep(1000)
+      }
+    }
+
+    throw new Error(`Instance ${instance} did not become healthy at ${url}`)
+  }
+
   try {
     if (keyPath.startsWith("~")) keyPath = keyPath.replace("~", os.homedir())
 
@@ -86,57 +306,169 @@ export const deploy = async (argv) => {
     log(`Connecting to ${host} as ${user} using key at ${keyPath}`)
     const res = await ssh("echo connection-ok")
     console.log(`${user}@${host}`, res)
-    await ssh(`mkdir -p ~/apps/${deployDir}`)
-
-    const { hasChanges: infrastructureChanged, output: infrastructureDiff } = await detectComposeChanges({
-      keyPath,
-      user,
-      host,
-      deployDir,
-      log,
-      extraExcludes: argv.ignore || [],
-    })
+    const useBlueGreen = argv.blueGreen || argv.rollback
+    const siteId = baseDeployDir
 
-    if (infrastructureChanged) {
-      console.log("Infrastructure compose files differ between local and remote (info only; deploy proceeds).")
-      if (argv.verbose) console.log(infrastructureDiff)
-    }
+    const privateApi = useBlueGreen ? createPrivateApiClient({env: argv.env}) : null
 
-    const excludeList = baseExcludeList.concat(argv.ignore)
+    if (argv.rollback) {
+      const statusRes = await privateApi.get(`/_private/v1/sites/${siteId}/deployment`)
+      const deployment = statusRes.data?.deployment
+      const activeInstance = parseInstance(deployment?.activeInstance)
+      const previousInstance = parseInstance(deployment?.previousInstance)
 
-    const excludeArgs = excludeList.map((p) => `--exclude='${p}'`).join(" ")
+      const previousTarget = deployment?.instances?.[previousInstance]
+      const activeTarget = deployment?.instances?.[activeInstance]
+      if (!previousTarget) throw new Error(`Cannot rollback ${siteId}: instance ${previousInstance} is not configured`)
+      if (!activeTarget) throw new Error(`Cannot rollback ${siteId}: active instance ${activeInstance} is not configured`)
 
-    const rsyncCmd = [
-      "rsync -avz -C",
-      excludeArgs,
-      "--delete",
-      `-e "ssh -i '${keyPath}' -o StrictHostKeyChecking=no"`,
-      ".",
-      `${user}@${host}:~/apps/${deployDir}/`,
-    ].join(" ")
+      console.log(`Starting rollback instance ${previousInstance}`)
+      await runInstanceAction("up", previousInstance)
+      await waitForInstance(previousInstance, previousTarget)
+      console.log(`Rolling back ${siteId}: ${activeInstance} -> ${previousInstance}`)
+      await privateApi.post(`/_private/v1/sites/${siteId}/lock`)
+      try {
+        await privateApi.post(`/_private/v1/sites/${siteId}/deployment/rollback`)
+      } finally {
+        await privateApi.post(`/_private/v1/sites/${siteId}/unlock`)
+      }
+      await runInstanceAction("down", activeInstance)
+      console.log(`Rollback complete: ${siteId} is on instance ${previousInstance}`)
+    } else {
+      preparedDeploy = prepareDeploySource({
+        sourceDir,
+        infrastructureDir,
+        sharedEnvFiles,
+        includePatterns: deployIncludePatterns,
+        excludePatterns: deployExcludePatterns,
+        log,
+      })
 
-    log(`Running: ${rsyncCmd}`)
-    execSync(rsyncCmd, { stdio: argv.verbose ? "inherit" : "ignore" })
+      const deployRoot = preparedDeploy.deployRoot
+      const deployInfrastructureDir = path.join(deployRoot, "infrastructure")
+      let deployDir = baseDeployDir
+      let targetInstance = null
+      let activeInstance = null
+      let target = null
 
-    await ssh(`cd ~/apps/${deployDir}/infrastructure && [ -f package.json ] && npm ci || true`)
+      if (useBlueGreen) {
+        const statusRes = await privateApi.get(`/_private/v1/sites/${siteId}/deployment`)
+        const deployment = statusRes.data?.deployment
+        activeInstance = parseInstance(deployment?.activeInstance)
+        targetInstance = getOtherInstance(activeInstance)
+        target = deployment?.instances?.[targetInstance]
+        if (!target) throw new Error(`Cannot deploy ${siteId}: instance ${targetInstance} is not configured`)
 
-    log("Restarting application...")
-    await ssh(`cd ~/apps/${deployDir}/infrastructure && node ctrl.js down prod`, true)
-    log("Application stopped. Starting it up again...")
-    await ssh(`cd ~/apps/${deployDir}/infrastructure && node ctrl.js up prod`, true)
+        deployDir = getInstanceDeployDir(baseDeployDir, targetInstance)
+        console.log(`Deploying ${siteId} to inactive instance ${targetInstance} at ${deployDir}`)
+      }
 
-    if (argv.pruneDocker !== false) {
-      log("Pruning dangling docker images on the remote host...")
-      try {
-        await ssh("docker image prune -f")
-      } catch (pruneError) {
-        console.warn(
-          `Warning: docker image prune failed (deploy continues): ${pruneError instanceof Error ? pruneError.message : pruneError}`,
-        )
+      await ssh(`mkdir -p ~/apps/${deployDir}`)
+      if (useBlueGreen) {
+        await ssh(`mkdir -p ~/apps/${baseDeployDir}`)
       }
-    }
 
-    log("Deployment complete ✅")
+      const hasInfrastructure = fs.existsSync(deployInfrastructureDir)
+      if (!useBlueGreen || hasInfrastructure) {
+        const infrastructureDeployDir = useBlueGreen ? baseDeployDir : deployDir
+        const { hasChanges: infrastructureChanged, output: infrastructureDiff } = await detectComposeChanges({
+          keyPath,
+          user,
+          host,
+          deployDir: infrastructureDeployDir,
+          localSource: deployRoot,
+          log,
+          extraExcludes: useBlueGreen
+            ? sharedInfrastructureExcludePatterns.concat(deployExcludePatterns)
+            : deployExcludePatterns,
+          includePatterns: useBlueGreen
+            ? sharedInfrastructureIncludePatterns.concat(preparedDeploy.sharedEnvFileNames)
+            : undefined,
+        })
+
+        if (infrastructureChanged) {
+          if (useBlueGreen) {
+            if (argv.verbose) console.log(infrastructureDiff)
+            throw new Error("Shared infrastructure files changed. Deploy or restart the shared infrastructure explicitly before running a blue/green app deploy.")
+          }
+          console.log("Infrastructure compose files differ between local and remote (info only; deploy proceeds).")
+          if (argv.verbose) console.log(infrastructureDiff)
+        }
+      }
+
+      if (useBlueGreen && hasInfrastructure) {
+        await ssh(`mkdir -p ~/apps/${baseDeployDir}/infrastructure`)
+        syncSharedEnvFiles(deployRoot, preparedDeploy.sharedEnvFileNames)
+
+        const infrastructureExcludeArgs = baseExcludeList
+          .concat(["data/"])
+          .concat(deployExcludePatterns)
+
+        const infrastructureRsyncCmd = [
+          "rsync -avz -C",
+          buildRsyncFilterArgs({ excludes: infrastructureExcludeArgs }),
+          "--delete",
+          `-e "ssh -i '${keyPath}' -o StrictHostKeyChecking=no"`,
+          shellQuote(withTrailingSlash(deployInfrastructureDir)),
+          `${user}@${host}:~/apps/${baseDeployDir}/infrastructure/`,
+        ].join(" ")
+
+        log(`Running: ${infrastructureRsyncCmd}`)
+        execSync(infrastructureRsyncCmd, { stdio: argv.verbose ? "inherit" : "ignore" })
+        await ssh(`cd ~/apps/${baseDeployDir}/infrastructure && [ -f package.json ] && npm ci || true`)
+      }
+
+      const excludeList = baseExcludeList
+        .concat(useBlueGreen ? ["infrastructure/"] : [])
+        .concat(useBlueGreen ? preparedDeploy.sharedEnvFileNames : [])
+        .concat(deployExcludePatterns)
+
+      const rsyncCmd = [
+        "rsync -avz -C",
+        buildRsyncFilterArgs({ excludes: excludeList }),
+        "--delete",
+        `-e "ssh -i '${keyPath}' -o StrictHostKeyChecking=no"`,
+        shellQuote(withTrailingSlash(deployRoot)),
+        `${user}@${host}:~/apps/${deployDir}/`,
+      ].join(" ")
+
+      log(`Running: ${rsyncCmd}`)
+      execSync(rsyncCmd, { stdio: argv.verbose ? "inherit" : "ignore" })
+
+      if (useBlueGreen) {
+        console.log(`Starting instance ${targetInstance}`)
+        await runInstanceAction("up", targetInstance)
+        await waitForInstance(targetInstance, target)
+
+        console.log(`Switching ${siteId}: ${activeInstance} -> ${targetInstance}`)
+        await privateApi.post(`/_private/v1/sites/${siteId}/lock`)
+        try {
+          await privateApi.post(`/_private/v1/sites/${siteId}/deployment/switch`, {instance: targetInstance})
+        } finally {
+          await privateApi.post(`/_private/v1/sites/${siteId}/unlock`)
+        }
+        await runInstanceAction("down", activeInstance)
+      } else {
+        await ssh(`cd ~/apps/${deployDir}/infrastructure && [ -f package.json ] && npm ci || true`)
+        log("Restarting application...")
+        await ssh(`cd ~/apps/${deployDir}/infrastructure && node ctrl.js down prod`, true)
+        log("Application stopped. Starting it up again...")
+        await ssh(`cd ~/apps/${deployDir}/infrastructure && node ctrl.js up prod`, true)
+      }
+
+      if (argv.pruneDocker !== false) {
+        log("Pruning dangling docker images on the remote host...")
+        try {
+          await ssh("docker image prune -f")
+        } catch (pruneError) {
+          console.warn(
+            `Warning: docker image prune failed (deploy continues): ${pruneError instanceof Error ? pruneError.message : pruneError}`,
+          )
+        }
+      }
+
+      log("Deployment complete ✅")
+    }
   } catch (error) {
     console.error(
       `Deployment failed: ${error instanceof Error ? error.message : error}`,
@@ -151,6 +483,10 @@ export const deploy = async (argv) => {
         console.warn(`Failed to remove temporary key file: ${cleanupError}`)
       }
     }
+
+    if (preparedDeploy) {
+      preparedDeploy.cleanup()
+    }
   }
 
   try {

package/src/cmd-deploy/private-api.js

@@ -0,0 +1,26 @@
+import fs from "fs"
+import https from "https"
+
+import axios from "axios"
+
+
+const requiredEnv = (env, name) => {
+  const value = env[name]
+  if (!value) throw new Error(`Missing required environment variable: ${name}`)
+  return value
+}
+
+export const createPrivateApiClient = ({env, timeoutMs = 15_000}) => {
+  const httpsAgent = new https.Agent({
+    cert: fs.readFileSync(requiredEnv(env, "RB_PROXY_PRIVATE_API_CLIENT_CERT")),
+    key: fs.readFileSync(requiredEnv(env, "RB_PROXY_PRIVATE_API_CLIENT_KEY")),
+    ca: fs.readFileSync(requiredEnv(env, "RB_PROXY_PRIVATE_API_CA")),
+  })
+
+  return axios.create({
+    baseURL: requiredEnv(env, "RB_PROXY_PRIVATE_API_URL"),
+    timeout: timeoutMs,
+    httpsAgent,
+    validateStatus: (status) => status >= 200 && status < 300,
+  })
+}

package/src/index.js

@@ -74,6 +74,41 @@ yargs(hideBin(process.argv))
           type: "array",
           default: [],
         })
+        .option("source-dir", {
+          describe: "Directory to use as the deployment source",
+          type: "string",
+          default: ".",
+        })
+        .option("infrastructure-dir", {
+          describe: "Infrastructure directory, relative to source-dir unless absolute",
+          type: "string",
+          default: "infrastructure",
+        })
+        .option("shared-env-file", {
+          describe: "Env file to sync to the shared deployment directory",
+          type: "array",
+          default: [],
+        })
+        .option("include", {
+          describe: "Only include matching source paths in the deployment root",
+          type: "array",
+          default: [],
+        })
+        .option("exclude", {
+          describe: "Exclude matching source paths from the deployment root and rsync commands",
+          type: "array",
+          default: [],
+        })
+        .option("blue-green", {
+          describe: "Deploy to the inactive blue/green instance and switch the reverse proxy",
+          type: "boolean",
+          default: false,
+        })
+        .option("rollback", {
+          describe: "Rollback the reverse proxy to the previous instance",
+          type: "boolean",
+          default: false,
+        })
     },
     async (argv) => {
       await deploy(argv)