netlify-cli 12.6.0 → 12.7.0

package/src/commands/dev/dev.mjs

@@ -1,311 +1,35 @@
 // @ts-check
-import events from 'events'
-import path from 'path'
 import process from 'process'
 
-import fastifyStatic from '@fastify/static'
-import boxen from 'boxen'
 import { Option } from 'commander'
-import execa from 'execa'
-import Fastify from 'fastify'
-import stripAnsiCc from 'strip-ansi-control-characters'
-import waitPort from 'wait-port'
 
 import { promptEditorHelper } from '../../lib/edge-functions/editor-helper.mjs'
 import { startFunctionsServer } from '../../lib/functions/server.mjs'
-import {
-  OneGraphCliClient,
-  loadCLISession,
-  markCliSessionInactive,
-  persistNewOperationsDocForSession,
-  startOneGraphCLISession,
-} from '../../lib/one-graph/cli-client.mjs'
-import {
-  defaultExampleOperationsDoc,
-  getGraphEditUrlBySiteId,
-  getNetlifyGraphConfig,
-  readGraphQLOperationsSourceFile,
-} from '../../lib/one-graph/cli-netlify-graph.mjs'
-import { startSpinner, stopSpinner } from '../../lib/spinner.mjs'
+import { printBanner } from '../../utils/banner.mjs'
 import {
   BANG,
   chalk,
-  error,
   exit,
-  getToken,
   log,
   NETLIFYDEV,
   NETLIFYDEVERR,
   NETLIFYDEVLOG,
   NETLIFYDEVWARN,
   normalizeConfig,
-  warn,
-  watchDebounced,
 } from '../../utils/command-helpers.mjs'
-import detectServerSettings from '../../utils/detect-server-settings.mjs'
-import { generateNetlifyGraphJWT, getSiteInformation, injectEnvVariables, processOnExit } from '../../utils/dev.mjs'
+import detectServerSettings, { getConfigWithPlugins } from '../../utils/detect-server-settings.mjs'
+import { getSiteInformation, injectEnvVariables } from '../../utils/dev.mjs'
 import { getEnvelopeEnv, normalizeContext } from '../../utils/env/index.mjs'
 import { ensureNetlifyIgnore } from '../../utils/gitignore.mjs'
+import { startNetlifyGraph, startPollingForAPIAuthentication } from '../../utils/graph.mjs'
 import { startLiveTunnel } from '../../utils/live-tunnel.mjs'
 import openBrowser from '../../utils/open-browser.mjs'
-import { startProxy } from '../../utils/proxy.mjs'
+import { generateInspectSettings, startProxyServer } from '../../utils/proxy-server.mjs'
+import { runDevTimeline } from '../../utils/run-build.mjs'
+import { getGeoCountryArgParser } from '../../utils/validation.mjs'
 
 import { createDevExecCommand } from './dev-exec.mjs'
 
-const netlifyBuildPromise = import('@netlify/build')
-
-const startStaticServer = async ({ settings }) => {
-  const server = Fastify()
-  const rootPath = path.resolve(settings.dist)
-  server.register(fastifyStatic, {
-    root: rootPath,
-    etag: false,
-    acceptRanges: false,
-    lastModified: false,
-  })
-
-  server.setNotFoundHandler((_req, res) => {
-    res.code(404).sendFile('404.html', rootPath)
-  })
-
-  server.addHook('onRequest', (req, reply, done) => {
-    reply.header('X-Powered-by', 'netlify-dev')
-    const validMethods = ['GET', 'HEAD']
-    if (!validMethods.includes(req.method)) {
-      reply.code(405).send('Method Not Allowed')
-    }
-    done()
-  })
-
-  await server.listen({ port: settings.frameworkPort })
-  log(`\n${NETLIFYDEVLOG} Static server listening to`, settings.frameworkPort)
-}
-
-const isNonExistingCommandError = ({ command, error: commandError }) => {
-  // `ENOENT` is only returned for non Windows systems
-  // See https://github.com/sindresorhus/execa/pull/447
-  if (commandError.code === 'ENOENT') {
-    return true
-  }
-
-  // if the command is a package manager we let it report the error
-  if (['yarn', 'npm'].includes(command)) {
-    return false
-  }
-
-  // this only works on English versions of Windows
-  return (
-    typeof commandError.message === 'string' &&
-    commandError.message.includes('is not recognized as an internal or external command')
-  )
-}
-
-/**
- * @type {(() => Promise<void>)[]} - array of functions to run before the process exits
- */
-const cleanupWork = []
-
-let cleanupStarted = false
-
-/**
- * @param {object} input
- * @param {number=} input.exitCode The exit code to return when exiting the process after cleanup
- */
-const cleanupBeforeExit = async ({ exitCode }) => {
-  // If cleanup has started, then wherever started it will be responsible for exiting
-  if (!cleanupStarted) {
-    cleanupStarted = true
-    try {
-      // eslint-disable-next-line no-unused-vars
-      const cleanupFinished = await Promise.all(cleanupWork.map((cleanup) => cleanup()))
-    } finally {
-      process.exit(exitCode)
-    }
-  }
-}
-
-/**
- * Run a command and pipe stdout, stderr and stdin
- * @param {string} command
- * @param {NodeJS.ProcessEnv} env
- * @returns {execa.ExecaChildProcess<string>}
- */
-const runCommand = (command, env = {}, spinner = null) => {
-  const commandProcess = execa.command(command, {
-    preferLocal: true,
-    // we use reject=false to avoid rejecting synchronously when the command doesn't exist
-    reject: false,
-    env,
-    // windowsHide needs to be false for child process to terminate properly on Windows
-    windowsHide: false,
-  })
-
-  // This ensures that an active spinner stays at the bottom of the commandline
-  // even though the actual framework command might be outputting stuff
-  const pipeDataWithSpinner = (writeStream, chunk) => {
-    if (spinner && spinner.isSpinning) {
-      spinner.clear()
-      spinner.isSilent = true
-    }
-    writeStream.write(chunk, () => {
-      if (spinner && spinner.isSpinning) {
-        spinner.isSilent = false
-        spinner.render()
-      }
-    })
-  }
-
-  commandProcess.stdout.pipe(stripAnsiCc.stream()).on('data', pipeDataWithSpinner.bind(null, process.stdout))
-  commandProcess.stderr.pipe(stripAnsiCc.stream()).on('data', pipeDataWithSpinner.bind(null, process.stderr))
-  process.stdin.pipe(commandProcess.stdin)
-
-  // we can't try->await->catch since we don't want to block on the framework server which
-  // is a long running process
-  // eslint-disable-next-line promise/catch-or-return
-  commandProcess
-    // eslint-disable-next-line promise/prefer-await-to-then
-    .then(async () => {
-      const result = await commandProcess
-      const [commandWithoutArgs] = command.split(' ')
-      if (result.failed && isNonExistingCommandError({ command: commandWithoutArgs, error: result })) {
-        log(
-          NETLIFYDEVERR,
-          `Failed running command: ${command}. Please verify ${chalk.magenta(`'${commandWithoutArgs}'`)} exists`,
-        )
-      } else {
-        const errorMessage = result.failed
-          ? `${NETLIFYDEVERR} ${result.shortMessage}`
-          : `${NETLIFYDEVWARN} "${command}" exited with code ${result.exitCode}`
-
-        log(`${errorMessage}. Shutting down Netlify Dev server`)
-      }
-
-      return await cleanupBeforeExit({ exitCode: 1 })
-    })
-  processOnExit(async () => await cleanupBeforeExit({}))
-
-  return commandProcess
-}
-
-/**
- * @typedef StartReturnObject
- * @property {4 | 6 | undefined=} ipVersion The version the open port was found on
- */
-
-/**
- * Start a static server if the `useStaticServer` is provided or a framework specific server
- * @param {object} config
- * @param {Partial<import('../../utils/types').ServerSettings>} config.settings
- * @returns {Promise<StartReturnObject>}
- */
-const startFrameworkServer = async function ({ settings }) {
-  if (settings.useStaticServer) {
-    if (settings.command) {
-      runCommand(settings.command, settings.env)
-    }
-    await startStaticServer({ settings })
-
-    return {}
-  }
-
-  log(`${NETLIFYDEVLOG} Starting Netlify Dev with ${settings.framework || 'custom config'}`)
-
-  const spinner = startSpinner({
-    text: `Waiting for framework port ${settings.frameworkPort}. This can be configured using the 'targetPort' property in the netlify.toml`,
-  })
-
-  runCommand(settings.command, settings.env, spinner)
-
-  let port
-  try {
-    port = await waitPort({
-      port: settings.frameworkPort,
-      host: 'localhost',
-      output: 'silent',
-      timeout: FRAMEWORK_PORT_TIMEOUT,
-      ...(settings.pollingStrategies.includes('HTTP') && { protocol: 'http' }),
-    })
-
-    if (!port.open) {
-      throw new Error(`Timed out waiting for port '${settings.frameworkPort}' to be open`)
-    }
-
-    stopSpinner({ error: false, spinner })
-  } catch (error_) {
-    stopSpinner({ error: true, spinner })
-    log(NETLIFYDEVERR, `Netlify Dev could not start or connect to localhost:${settings.frameworkPort}.`)
-    log(NETLIFYDEVERR, `Please make sure your framework server is running on port ${settings.frameworkPort}`)
-    error(error_)
-    exit(1)
-  }
-
-  return { ipVersion: port?.ipVersion }
-}
-
-// 10 minutes
-const FRAMEWORK_PORT_TIMEOUT = 6e5
-
-/**
- * @typedef {Object} InspectSettings
- * @property {boolean} enabled - Inspect enabled
- * @property {boolean} pause - Pause on breakpoints
- * @property {string|undefined} address - Host/port override (optional)
- */
-
-/**
- *
- * @param {object} params
- * @param {*} params.addonsUrls
- * @param {import('../base-command.mjs').NetlifyOptions["config"]} params.config
- * @param {import('../base-command.mjs').NetlifyOptions["cachedConfig"]['env']} params.env
- * @param {InspectSettings} params.inspectSettings
- * @param {() => Promise<object>} params.getUpdatedConfig
- * @param {string} params.geolocationMode
- * @param {string} params.geoCountry
- * @param {*} params.settings
- * @param {boolean} params.offline
- * @param {*} params.site
- * @param {*} params.siteInfo
- * @param {import('../../utils/state-config.mjs').default} params.state
- * @returns
- */
-const startProxyServer = async ({
-  addonsUrls,
-  config,
-  env,
-  geoCountry,
-  geolocationMode,
-  getUpdatedConfig,
-  inspectSettings,
-  offline,
-  settings,
-  site,
-  siteInfo,
-  state,
-}) => {
-  const url = await startProxy({
-    addonsUrls,
-    config,
-    configPath: site.configPath,
-    env,
-    geolocationMode,
-    geoCountry,
-    getUpdatedConfig,
-    inspectSettings,
-    offline,
-    projectDir: site.root,
-    settings,
-    state,
-    siteInfo,
-  })
-  if (!url) {
-    log(NETLIFYDEVERR, `Unable to start proxy server on port '${settings.port}'`)
-    exit(1)
-  }
-
-  return url
-}
-
 /**
  *
  * @param {object} config
@@ -327,83 +51,6 @@ const handleLiveTunnel = async ({ api, options, settings, site }) => {
   }
 }
 
-const printBanner = ({ url }) => {
-  const banner = chalk.bold(`${NETLIFYDEVLOG} Server now ready on ${url}`)
-
-  log(
-    boxen(banner, {
-      padding: 1,
-      margin: 1,
-      align: 'center',
-      borderColor: '#00c7b7',
-    }),
-  )
-}
-
-const startPollingForAPIAuthentication = async function (options) {
-  const { api, command, config, site, siteInfo } = options
-  const frequency = 5000
-
-  const helper = async (maybeSiteData) => {
-    const siteData = await (maybeSiteData || api.getSite({ siteId: site.id }))
-    const authlifyTokenId = siteData && siteData.authlify_token_id
-
-    const existingAuthlifyTokenId = config && config.netlifyGraphConfig && config.netlifyGraphConfig.authlifyTokenId
-    if (authlifyTokenId && authlifyTokenId !== existingAuthlifyTokenId) {
-      const netlifyToken = await command.authenticate()
-      // Only inject the authlify config if a token ID exists. This prevents
-      // calling command.authenticate() (which opens a browser window) if the
-      // user hasn't enabled API Authentication
-      const netlifyGraphConfig = {
-        netlifyToken,
-        authlifyTokenId: siteData.authlify_token_id,
-        siteId: site.id,
-      }
-      config.netlifyGraphConfig = netlifyGraphConfig
-
-      const netlifyGraphJWT = generateNetlifyGraphJWT(netlifyGraphConfig)
-
-      if (netlifyGraphJWT != null) {
-        // XXX(anmonteiro): this name is deprecated. Delete after 3/31/2022
-        process.env.ONEGRAPH_AUTHLIFY_TOKEN = netlifyGraphJWT
-        process.env.NETLIFY_GRAPH_TOKEN = netlifyGraphJWT
-      }
-    } else if (!authlifyTokenId) {
-      // If there's no `authlifyTokenId`, it's because the user disabled API
-      // Auth. Delete the config in this case.
-      delete config.netlifyGraphConfig
-    }
-
-    setTimeout(helper, frequency)
-  }
-
-  await helper(siteInfo)
-}
-
-/**
- * @param {boolean|string} edgeInspect
- * @param {boolean|string} edgeInspectBrk
- * @returns {InspectSettings}
- */
-const generateInspectSettings = (edgeInspect, edgeInspectBrk) => {
-  const enabled = Boolean(edgeInspect) || Boolean(edgeInspectBrk)
-  const pause = Boolean(edgeInspectBrk)
-  const getAddress = () => {
-    if (edgeInspect) {
-      return typeof edgeInspect === 'string' ? edgeInspect : undefined
-    }
-    if (edgeInspectBrk) {
-      return typeof edgeInspectBrk === 'string' ? edgeInspectBrk : undefined
-    }
-  }
-
-  return {
-    enabled,
-    pause,
-    address: getAddress(),
-  }
-}
-
 const validateShortFlagArgs = (args) => {
   if (args.startsWith('=')) {
     throw new Error(
@@ -420,19 +67,6 @@ const validateShortFlagArgs = (args) => {
   return args
 }
 
-const validateGeoCountryCode = (arg) => {
-  // Validate that the arg passed is two letters only for country
-  // See https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes
-  if (!/^[a-z]{2}$/i.test(arg)) {
-    throw new Error(
-      `The geo country code must use a two letter abbreviation.
-      ${chalk.red(BANG)}  Example:
-      netlify dev --geo=mock --country=FR`,
-    )
-  }
-  return arg.toUpperCase()
-}
-
 /**
  * The dev command
  * @param {import('commander').OptionValues} options
@@ -441,7 +75,6 @@ const validateGeoCountryCode = (arg) => {
 const dev = async (options, command) => {
   log(`${NETLIFYDEV}`)
   const { api, cachedConfig, config, repositoryRoot, site, siteInfo, state } = command.netlify
-  const netlifyBuild = await netlifyBuildPromise
   config.dev = { ...config.dev }
   config.build = { ...config.build }
   /** @type {import('./types').DevConfig} */
@@ -455,6 +88,8 @@ const dev = async (options, command) => {
 
   let { env } = cachedConfig
 
+  env.NETLIFY_DEV = { sources: ['internal'], value: 'true' }
+
   if (!options.offline && siteInfo.use_envelope) {
     env = await getEnvelopeEnv({ api, context: options.context, env, siteInfo })
     log(`${NETLIFYDEVLOG} Injecting environment variable values for ${chalk.yellow('all scopes')}`)
@@ -476,25 +111,7 @@ const dev = async (options, command) => {
   try {
     settings = await detectServerSettings(devConfig, options, site.root)
 
-    // If there are plugins that we should be running for this site, add them
-    // to the config as if they were declared in netlify.toml. We must check
-    // whether the plugin has already been added by another source (like the
-    // TOML file or the UI), as we don't want to run the same plugin twice.
-    if (settings.plugins) {
-      const { plugins: existingPlugins = [] } = cachedConfig.config
-      const existingPluginNames = new Set(existingPlugins.map((plugin) => plugin.package))
-      const newPlugins = settings.plugins
-        .map((pluginName) => {
-          if (existingPluginNames.has(pluginName)) {
-            return
-          }
-
-          return { package: pluginName, origin: 'config', inputs: {} }
-        })
-        .filter(Boolean)
-
-      cachedConfig.config.plugins = [...newPlugins, ...cachedConfig.config.plugins]
-    }
+    cachedConfig.config = getConfigWithPlugins(cachedConfig.config, settings)
   } catch (error_) {
     log(NETLIFYDEVERR, error_.message)
     exit(1)
@@ -507,10 +124,15 @@ const dev = async (options, command) => {
     startPollingForAPIAuthentication({ api, command, config, site, siteInfo })
   }
 
+  log(`${NETLIFYDEVWARN} Setting up local development server`)
+
+  const { configPath: configPathOverride } = await runDevTimeline({ cachedConfig, options, settings, site })
+
   await startFunctionsServer({
     api,
     command,
     config,
+    debug: options.debug,
     settings,
     site,
     siteInfo,
@@ -519,23 +141,6 @@ const dev = async (options, command) => {
     timeouts,
   })
 
-  log(`${NETLIFYDEVWARN} Setting up local development server`)
-
-  const devCommand = async () => {
-    const { ipVersion } = await startFrameworkServer({ settings })
-
-    settings.frameworkHost = ipVersion === 6 ? '::1' : '127.0.0.1'
-  }
-  const startDevOptions = getBuildOptions({
-    cachedConfig,
-    options,
-  })
-  const { error: startDevError, success } = await netlifyBuild.startDev(devCommand, startDevOptions)
-
-  if (!success) {
-    error(`Could not start local development server\n\n${startDevError.message}\n\n${startDevError.stack}`)
-  }
-
   // Try to add `.netlify` to `.gitignore`.
   try {
     await ensureNetlifyIgnore(repositoryRoot)
@@ -557,7 +162,8 @@ const dev = async (options, command) => {
   let url = await startProxyServer({
     addonsUrls,
     config,
-    env: command.netlify.cachedConfig.env,
+    configPath: configPathOverride,
+    env,
     geolocationMode: options.geo,
     geoCountry: options.country,
     getUpdatedConfig,
@@ -579,121 +185,19 @@ const dev = async (options, command) => {
   process.env.URL = url
   process.env.DEPLOY_URL = url
 
-  if (startNetlifyGraphWatcher && options.offline) {
-    warn(`Unable to start Netlify Graph in offline mode`)
-  } else if (startNetlifyGraphWatcher && !site.id) {
-    error(
-      `No siteId defined, unable to start Netlify Graph. To enable, run ${chalk.yellow(
-        'netlify init',
-      )} or ${chalk.yellow('netlify link')}.`,
-    )
-  } else if (startNetlifyGraphWatcher) {
-    const netlifyToken = await command.authenticate()
-    await OneGraphCliClient.ensureAppForSite(netlifyToken, site.id)
-
-    let stopWatchingCLISessions
-
-    let liveConfig = { ...config }
-    let isRestartingSession = false
-
-    const createOrResumeSession = async function () {
-      const netlifyGraphConfig = await getNetlifyGraphConfig({ command, options, settings })
-
-      let graphqlDocument = readGraphQLOperationsSourceFile(netlifyGraphConfig)
-
-      if (!graphqlDocument || graphqlDocument.trim().length === 0) {
-        graphqlDocument = defaultExampleOperationsDoc
-      }
-
-      stopWatchingCLISessions = await startOneGraphCLISession({
-        config: liveConfig,
-        netlifyGraphConfig,
-        netlifyToken,
-        site,
-        state,
-        oneGraphSessionId: options.sessionId,
-      })
-
-      // Should be created by startOneGraphCLISession
-      const oneGraphSessionId = loadCLISession(state)
-
-      await persistNewOperationsDocForSession({
-        config: liveConfig,
-        netlifyGraphConfig,
-        netlifyToken,
-        oneGraphSessionId,
-        operationsDoc: graphqlDocument,
-        siteId: site.id,
-        siteRoot: site.root,
-      })
-
-      return oneGraphSessionId
-    }
-
-    const configWatcher = new events.EventEmitter()
-
-    // Only set up a watcher if we know the config path.
-    const { configPath } = command.netlify.site
-    if (configPath) {
-      // chokidar handle
-      command.configWatcherHandle = await watchDebounced(configPath, {
-        depth: 1,
-        onChange: async () => {
-          const cwd = options.cwd || process.cwd()
-          const [token] = await getToken(options.auth)
-          const { config: newConfig } = await command.getConfig({ cwd, state, token, ...command.netlify.apiUrlOpts })
-
-          const normalizedNewConfig = normalizeConfig(newConfig)
-          configWatcher.emit('change', normalizedNewConfig)
-        },
-      })
-
-      processOnExit(async () => {
-        await command.configWatcherHandle.close()
-      })
-    }
-
-    // Set up a handler for config changes.
-    configWatcher.on('change', async (newConfig) => {
-      command.netlify.config = newConfig
-      liveConfig = newConfig
-      if (isRestartingSession) {
-        return
-      }
-      stopWatchingCLISessions && stopWatchingCLISessions()
-      isRestartingSession = true
-      await createOrResumeSession()
-      isRestartingSession = false
-    })
-
-    const oneGraphSessionId = await createOrResumeSession()
-    const cleanupSession = () => markCliSessionInactive({ netlifyToken, sessionId: oneGraphSessionId, siteId: site.id })
-
-    cleanupWork.push(cleanupSession)
-
-    const graphEditUrl = getGraphEditUrlBySiteId({ siteId: site.id, oneGraphSessionId })
-
-    log(
-      `Starting Netlify Graph session, to edit your library visit ${graphEditUrl} or run \`netlify graph:edit\` in another tab`,
-    )
-  }
+  await startNetlifyGraph({
+    command,
+    config,
+    options,
+    settings,
+    site,
+    startNetlifyGraphWatcher,
+    state,
+  })
 
   printBanner({ url })
 }
 
-const getBuildOptions = ({ cachedConfig, options: { context, cwd = process.cwd(), debug, dry, offline }, token }) => ({
-  cachedConfig,
-  token,
-  dry,
-  debug,
-  context,
-  mode: 'cli',
-  telemetry: false,
-  buffer: false,
-  offline,
-  cwd,
-})
-
 /**
  * Creates the `netlify dev` command
  * @param {import('../base-command.mjs').default} program
@@ -713,7 +217,6 @@ export const createDevCommand = (program) => {
       '--context <context>',
       'Specify a deploy context or branch for environment variables (contexts: "production", "deploy-preview", "branch-deploy", "dev")',
       normalizeContext,
-      'dev',
     )
     .option('-p ,--port <port>', 'port of netlify dev', (value) => Number.parseInt(value))
     .option('--targetPort <port>', 'port of target app server', (value) => Number.parseInt(value))
@@ -735,7 +238,7 @@ export const createDevCommand = (program) => {
       new Option(
         '--country <geoCountry>',
         'Two-letter country code (https://ntl.fyi/country-codes) to use as mock geolocation (enables --geo=mock automatically)',
-      ).argParser(validateGeoCountryCode),
+      ).argParser(getGeoCountryArgParser('netlify dev --geo=mock --country=FR')),
     )
     .addOption(
       new Option('--staticServerPort <port>', 'port of the static app server used when no framework is detected')

package/src/commands/functions/functions-serve.mjs

@@ -16,8 +16,11 @@ const functionsServe = async (options, command) => {
   const { api, config, site, siteInfo } = command.netlify
 
   const functionsDir = getFunctionsDir({ options, config }, join('netlify', 'functions'))
+  const { env } = command.netlify.cachedConfig
 
-  await injectEnvVariables({ devConfig: { ...config.dev }, env: command.netlify.cachedConfig.env, site })
+  env.NETLIFY_DEV = { sources: ['internal'], value: 'true' }
+
+  await injectEnvVariables({ devConfig: { ...config.dev }, env, site })
 
   const { capabilities, siteUrl, timeouts } = await getSiteInformation({
     offline: options.offline,
@@ -34,6 +37,7 @@ const functionsServe = async (options, command) => {
 
   await startFunctionsServer({
     config,
+    debug: options.debug,
     api,
     settings: { functions: functionsDir, functionsPort },
     site,

package/src/commands/main.mjs

@@ -28,6 +28,7 @@ import { createLoginCommand } from './login/index.mjs'
 import { createLogoutCommand } from './logout/index.mjs'
 import { createOpenCommand } from './open/index.mjs'
 import { createRecipesCommand } from './recipes/index.mjs'
+import { createServeCommand } from './serve/serve.mjs'
 import { createSitesCommand } from './sites/index.mjs'
 import { createStatusCommand } from './status/index.mjs'
 import { createSwitchCommand } from './switch/index.mjs'
@@ -173,6 +174,7 @@ export const createMainCommand = () => {
   createLoginCommand(program)
   createLogoutCommand(program)
   createOpenCommand(program)
+  createServeCommand(program)
   createSitesCommand(program)
   createStatusCommand(program)
   createSwitchCommand(program)