Replace CLI command

Author: tristanlee85

guides/angular.md

@@ -60,7 +60,7 @@ npm install -g {{ PACKAGE_NAME }}/cli
 #### 2. Run the following in the root folder of your project. This will configure your project for {{ PRODUCT_NAME }}.
 
 ```bash
-xdn init
+{{ CLI_NAME }} init
 ```
 
 This will automatically add all of the required dependencies and files to your project. These include:
@@ -73,14 +73,14 @@ This will automatically add all of the required dependencies and files to your p
 
 #### 3. Use the right angular project
 
-If you have several projects and the `defaultProject` as specified in `angular.json` is not the project with the SSR build, specify the correct project with the `ANGULAR_PROJECT` environment variable. For example: `ANGULAR_PROJECT=my-ssr-project xdn build`.
+If you have several projects and the `defaultProject` as specified in `angular.json` is not the project with the SSR build, specify the correct project with the `ANGULAR_PROJECT` environment variable. For example: `ANGULAR_PROJECT=my-ssr-project {{ CLI_NAME }} build`.
 
 ## Routing
 
-The default `routes.js` file created by `xdn init` sends all requests to Angular server via a fallback route.
+The default `routes.js` file created by `{{ CLI_NAME }} init` sends all requests to Angular server via a fallback route.
 
 ```js
-// This file was automatically added by xdn deploy.
+// This file was automatically added by {{ CLI_NAME }} deploy.
 // You should commit this file to source control.
 
 const { Router } = require('{{ PACKAGE_NAME }}/core/router')
@@ -116,39 +116,39 @@ new Router()
 To test your app locally, run:
 
 ```bash
-xdn run
+{{ CLI_NAME }} run
 ```
 
 You can do a production build of your app and test it locally using:
 
 ```bash
-xdn build && xdn run --production
+{{ CLI_NAME }} build && {{ CLI_NAME }} run --production
 ```
 
 Setting `--production` runs your app exactly as it will be when deployed to the Moovweb cloud.
 
-If you have several projects and the `defaultProject` in `angular.json` is not the project you would like to deploy, specify the correct project by setting the `ANGULAR_PROJECT` environment variable when running `xdn run`.
+If you have several projects and the `defaultProject` in `angular.json` is not the project you would like to deploy, specify the correct project by setting the `ANGULAR_PROJECT` environment variable when running `{{ CLI_NAME }} run`.
 
 For example:
 
 ```
-ANGULAR_PROJECT=my-project xdn run
+ANGULAR_PROJECT=my-project {{ CLI_NAME }} run
 ```
 
 ## Deploying
 
 Deploying requires an account on {{ PRODUCT_NAME }}. [Sign up here for free.](https://moovweb.app/signup) Once you have an account, you can deploy to {{ PRODUCT_NAME }} by running the following in the root folder of your project:
 
 ```bash
-xdn deploy
+{{ CLI_NAME }} deploy
 ```
 
-If you have several projects and the `defaultProject` in `angular.json` is not the project you would like to deploy, specify the correct project by setting the `ANGULAR_PROJECT` environment variable when running `xdn deploy`.
+If you have several projects and the `defaultProject` in `angular.json` is not the project you would like to deploy, specify the correct project by setting the `ANGULAR_PROJECT` environment variable when running `{{ CLI_NAME }} deploy`.
 
 For example:
 
 ```
-ANGULAR_PROJECT=my-project xdn deploy
+ANGULAR_PROJECT=my-project {{ CLI_NAME }} deploy
 ```
 
 See [deploying](deploying) for more information.

guides/caching.md

@@ -271,7 +271,7 @@ The response was not cached because it was received during the brief time (less
 By default, caching is turned off during development. This is done to ensure that developers don't see stale responses after making changes to their code or other upstream APIs. You can enable caching during development by running your app with:
 
 ```bash
-xdn dev --cache
+{{ CLI_NAME }} dev --cache
 ```
 
 The cache will automatically be cleared when you make changes to your router. A few aspects of caching are not yet supported during local development:
@@ -288,14 +288,14 @@ The cache is automatically cleared when you deploy to an environment. You can al
 The cache can be [cleared via the CLI](/guides/cli#section_cache_clear):
 
 ```bash
-$ xdn cache-clear --team=my-team --site=my-site --environment=production --path=/p/*
+$ {{ CLI_NAME }} cache-clear --team=my-team --site=my-site --environment=production --path=/p/*
 ```
 
 The cache can also be [cleared via the REST API](/guides/rest_api#section_clear_cache).
 
 ## Static prerendering after clearing the cache
 
-If you have [static prerendering] enabled, the cache will automatically be repopulated when you clear all entries from the cache (when you select "Purge all entries" in {{ PRODUCT_NAME }} Developer Console or run `xdn cache-clear` without providing `--path` or `--surrogate-key`). You can view the prerendering progress by clicking on the active deployment for the environment that was cleared.
+If you have [static prerendering] enabled, the cache will automatically be repopulated when you clear all entries from the cache (when you select "Purge all entries" in {{ PRODUCT_NAME }} Developer Console or run `{{ CLI_NAME }} cache-clear` without providing `--path` or `--surrogate-key`). You can view the prerendering progress by clicking on the active deployment for the environment that was cleared.
 
 ## Preserving the cache when deploying a new version of your site
 
@@ -343,11 +343,11 @@ These scripts assume that you have created environments called "production", "st
 ```js
   "scripts": {
     ...
-    "clearcache:dev": "xdn cache-clear --team=myTeam --site=my{{ PRODUCT_NAME }}App --environment=development --token=${{ PRODUCT_NAME_LOWER }}_deploy_token",
-    "clearcache:stage": "xdn cache-clear --team=myTeam --site=my{{ PRODUCT_NAME }}App --environment=staging --token=${{ PRODUCT_NAME_LOWER }}_deploy_token",
-    "clearcache:prod": "xdn cache-clear --team=myTeam --site=my{{ PRODUCT_NAME }}App --environment=production --token=${{ PRODUCT_NAME_LOWER }}_deploy_token",
-    "clearcache:prod:pdps": "xdn cache-clear --team=myTeam --site=my{{ PRODUCT_NAME }}App --environment=production --surrogate-key=pdp --token=${{ PRODUCT_NAME_LOWER }}_deploy_token",
-    "clearcache:prod:plps": "xdn cache-clear --team=myTeam --site=my{{ PRODUCT_NAME }}App --environment=production --surrogate-key=plp --token=${{ PRODUCT_NAME_LOWER }}_deploy_token",
+    "clearcache:dev": "{{ CLI_NAME }} cache-clear --team=myTeam --site=my{{ PRODUCT_NAME }}App --environment=development --token=${{ PRODUCT_NAME_LOWER }}_deploy_token",
+    "clearcache:stage": "{{ CLI_NAME }} cache-clear --team=myTeam --site=my{{ PRODUCT_NAME }}App --environment=staging --token=${{ PRODUCT_NAME_LOWER }}_deploy_token",
+    "clearcache:prod": "{{ CLI_NAME }} cache-clear --team=myTeam --site=my{{ PRODUCT_NAME }}App --environment=production --token=${{ PRODUCT_NAME_LOWER }}_deploy_token",
+    "clearcache:prod:pdps": "{{ CLI_NAME }} cache-clear --team=myTeam --site=my{{ PRODUCT_NAME }}App --environment=production --surrogate-key=pdp --token=${{ PRODUCT_NAME_LOWER }}_deploy_token",
+    "clearcache:prod:plps": "{{ CLI_NAME }} cache-clear --team=myTeam --site=my{{ PRODUCT_NAME }}App --environment=production --surrogate-key=plp --token=${{ PRODUCT_NAME_LOWER }}_deploy_token",
     ...
   },
 ```

guides/cli.md

@@ -33,7 +33,7 @@ Creates a build of your app optimized for production
 #### Example
 
 ```bash
-xdn build
+{{ CLI_NAME }} build
 ```
 
 ### cache-clear
@@ -54,7 +54,7 @@ specified environment will be cleared.
 #### Example
 
 ```bash
-xdn cache-clear --team=my-team --site=my-site --environment=production --path=/p/*
+{{ CLI_NAME }} cache-clear --team=my-team --site=my-site --environment=production --path=/p/*
 ```
 
 ### completion
@@ -64,19 +64,19 @@ Creates a script that provides autocompletion for {{ PRODUCT_NAME }} CLI command
 #### Example
 
 ```bash
-xdn completion
+{{ CLI_NAME }} completion
 ```
 
 #### Using ZSH
 
 ```bash
-xdn completion >> ~/.zshrc
+{{ CLI_NAME }} completion >> ~/.zshrc
 ```
 
 #### Using BASH
 
 ```bash
-xdn completion >> ~/.bashrc
+{{ CLI_NAME }} completion >> ~/.bashrc
 ```
 
 ### deploy
@@ -105,7 +105,7 @@ Builds and deploys your site on {{ PRODUCT_NAME }}.
 #### Example
 
 ```bash
-xdn deploy my-team --environment=production
+{{ CLI_NAME }} deploy my-team --environment=production
 ```
 
 ### docs
@@ -115,12 +115,12 @@ Open the {{ PRODUCT_NAME }} documentation in your browser.
 #### Example
 
 ```bash
-xdn docs
+{{ CLI_NAME }} docs
 ```
 
 ### dev
 
-Runs your project in development mode, simulating the {{ PRODUCT_NAME }} cloud environment. This command is a simplified version of `xdn run`, with only the --cache option being supported.
+Runs your project in development mode, simulating the {{ PRODUCT_NAME }} cloud environment. This command is a simplified version of `{{ CLI_NAME }} run`, with only the --cache option being supported.
 
 #### Options
 
@@ -131,7 +131,7 @@ Runs your project in development mode, simulating the {{ PRODUCT_NAME }} cloud e
 #### Example
 
 ```bash
-xdn dev
+{{ CLI_NAME }} dev
 ```
 
 ### init
@@ -141,7 +141,7 @@ Run in an existing app to add all required packages and files need to publish yo
 #### Example
 
 ```bash
-xdn init
+{{ CLI_NAME }} init
 ```
 
 #### Options
@@ -157,7 +157,7 @@ Logs into {{ PRODUCT_NAME }} via the developer console.
 #### Example
 
 ```bash
-xdn login
+{{ CLI_NAME }} login
 ```
 
 ### logout
@@ -167,30 +167,30 @@ Logs out of {{ PRODUCT_NAME }}
 #### Example
 
 ```bash
-xdn logout
+{{ CLI_NAME }} logout
 ```
 
 ### run
 
-Runs your app locally. Uses port 3000 by default. You can change this by setting the `PORT` environment variable. For example: `PORT=5000 xdn run`.
+Runs your app locally. Uses port 3000 by default. You can change this by setting the `PORT` environment variable. For example: `PORT=5000 {{ CLI_NAME }} run`.
 
 #### Options
 
 | Name           | Description                                                                                                                                                                                                                     |
 | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `--production` | Runs a production build of your app, simulating the cloud environment. This can also be achieved by setting the NODE_ENV environment variable to `true`. You need to run `xdn build` first.                                     |
+| `--production` | Runs a production build of your app, simulating the cloud environment. This can also be achieved by setting the NODE_ENV environment variable to `true`. You need to run `{{ CLI_NAME }} build` first.                          |
 | `--cache`      | Enables caching during local development so that you can test the caching logic in your router. By default caching is turned off in local development to ensure you don't see stale responses as you make changes to your code. |
 
 #### Example
 
 ```bash
-xdn run --production
+{{ CLI_NAME }} run --production
 ```
 
 Or to run a deployment bundle downloaded from {{ PRODUCT_NAME }} Developer Console, use:
 
 ```bash
-xdn run /path/to/bundle.zip
+{{ CLI_NAME }} run /path/to/bundle.zip
 ```
 
 Production mode is always used whe running downloaded bundles.
@@ -204,17 +204,17 @@ Switches the version of all {{ PACKAGE_NAME }}/\* packages in your project.
 To install a particular version:
 
 ```bash
-xdn use 1.45.0
+{{ CLI_NAME }} use 1.45.0
 ```
 
 To install the latest stable:
 
 ```bash
-xdn use latest
+{{ CLI_NAME }} use latest
 ```
 
 To install the latest preview:
 
 ```bash
-xdn use next
+{{ CLI_NAME }} use next
 ```

guides/connectors.md

@@ -1,23 +1,23 @@
 # Connectors
 
-Connector packages help build and run your app within {{ PRODUCT_NAME }}. When you run `xdn init`, {{ PRODUCT_NAME }} CLI detects the framework used by your app and installs the corresponding connector package. For example, if you use Next.js, `{{ PACKAGE_NAME }}/next` will be installed. If no connector package exists for the framework that you use, you can still deploy to {{ PRODUCT_NAME }} by implementing the connector interface directly in your app.
+Connector packages help build and run your app within {{ PRODUCT_NAME }}. When you run `{{ CLI_NAME }} init`, {{ PRODUCT_NAME }} CLI detects the framework used by your app and installs the corresponding connector package. For example, if you use Next.js, `{{ PACKAGE_NAME }}/next` will be installed. If no connector package exists for the framework that you use, you can still deploy to {{ PRODUCT_NAME }} by implementing the connector interface directly in your app.
 
 ## Writing a connector
 
 A {{ PRODUCT_NAME }} connector consists of four entry points:
 
-- `init.js` - Called when the user runs `xdn init`, adding resources to the project necessary for deploying on {{ PRODUCT_NAME }}. May also modify existing files with the project.
-- `dev.js` - Called when the user runs `xdn dev` to run their app in development mode.
-- `build.js` - Called when the user runs `xdn build` or `xdn deploy`. Builds the application, copying resources into the `.{{ PRODUCT_NAME_LOWER }}` directory, which is ultimately zipped and uploaded to {{ PRODUCT_NAME }}.
+- `init.js` - Called when the user runs `{{ CLI_NAME }} init`, adding resources to the project necessary for deploying on {{ PRODUCT_NAME }}. May also modify existing files with the project.
+- `dev.js` - Called when the user runs `{{ CLI_NAME }} dev` to run their app in development mode.
+- `build.js` - Called when the user runs `{{ CLI_NAME }} build` or `{{ CLI_NAME }} deploy`. Builds the application, copying resources into the `.{{ PRODUCT_NAME_LOWER }}` directory, which is ultimately zipped and uploaded to {{ PRODUCT_NAME }}.
 - `prod.js` - Starts the application server in {{ PRODUCT_NAME }} cloud's serverless environment.
 
 These files should be placed in the root directory of your connector package.
 
 ## init.js
 
-Called when the user runs `xdn init`. This entry point adds resources to the project necessary for deploying on {{ PRODUCT_NAME }}. It may also modify existing files within the project.
+Called when the user runs `{{ CLI_NAME }} init`. This entry point adds resources to the project necessary for deploying on {{ PRODUCT_NAME }}. It may also modify existing files within the project.
 
-_Optional, if not provided, xdn init will add a default router and {{ CONFIG_FILE }} to the user's project._
+_Optional, if not provided, {{ CLI_NAME }} init will add a default router and {{ CONFIG_FILE }} to the user's project._
 
 Example:
 
@@ -27,7 +27,7 @@ const { join } = require('path')
 const { DeploymentBuilder } = require('{{ PACKAGE_NAME }}/core/deploy')
 
 /**
- * Called when the user runs xdn init.
+ * Called when the user runs {{ CLI_NAME }} init.
  */
 export default async function init() {
   new DeploymentBuilder(process.cwd())
@@ -57,9 +57,9 @@ Additional files can be added beyond the ones listed above. They will be copied
 
 ## dev.js
 
-Called when the user runs `xdn dev`. This entry point is responsible for starting the user's application in development mode. The `{{ PACKAGE_NAME }}/core` library provides a `createDevServer` function to help with this.
+Called when the user runs `{{ CLI_NAME }} dev`. This entry point is responsible for starting the user's application in development mode. The `{{ PACKAGE_NAME }}/core` library provides a `createDevServer` function to help with this.
 
-_Optional, if not provided, xdn dev will simply start {{ PRODUCT_NAME }} in local development mode, but will not start a framework application server._
+_Optional, if not provided, {{ CLI_NAME }} dev will simply start {{ PRODUCT_NAME }} in local development mode, but will not start a framework application server._
 
 Example:
 
@@ -87,9 +87,9 @@ module.exports = function() {
 
 ## build.js
 
-Exports a function that is called when you run `xdn build`. It is responsible for constructing the bundle that is deployed to the {{ PRODUCT_NAME }} cloud. This function typically uses `{{ PACKAGE_NAME }}/core/deploy/DeploymentBuilder` to stage the exploded bundle in the `.xdn` directory.
+Exports a function that is called when you run `{{ CLI_NAME }} build`. It is responsible for constructing the bundle that is deployed to the {{ PRODUCT_NAME }} cloud. This function typically uses `{{ PACKAGE_NAME }}/core/deploy/DeploymentBuilder` to stage the exploded bundle in the `.xdn` directory.
 
-_Optional, and not needed in most cases. The xdn build command automatically creates a bundle that includes all static assets referenced in your routes file as well as the `prod` entry point mentioned above._
+_Optional, and not needed in most cases. The {{ CLI_NAME }} build command automatically creates a bundle that includes all static assets referenced in your routes file as well as the `prod` entry point mentioned above._
 
 Example:
 
@@ -170,7 +170,7 @@ To test your connector locally without publishing it to NPM:
 2. Create an `{{ CONFIG_FILE }}` file in the root directory of your project.
 3. Set the `connector` property to name of the connector package.
 
-Now `xdn init`, `xdn dev`, `xdn build`, and `xdn deploy` commands will use the entry points in the connector, and your `prod.js` entrypoint will be used to serve requests in the {{ PRODUCT_NAME }} cloud.
+Now `{{ CLI_NAME }} init`, `{{ CLI_NAME }} dev`, `{{ CLI_NAME }} build`, and `{{ CLI_NAME }} deploy` commands will use the entry points in the connector, and your `prod.js` entrypoint will be used to serve requests in the {{ PRODUCT_NAME }} cloud.
 
 ## Implementing a connector directly within your project
 
@@ -201,4 +201,4 @@ module.exports = {
 }
 ```
 
-Once the connector is in place, `xdn dev`, `xdn build`, and `xdn deploy` commands will use the entry points in the connector, and your `prod.js` entrypoint will be used to serve requests in the {{ PRODUCT_NAME }} cloud.
+Once the connector is in place, `{{ CLI_NAME }} dev`, `{{ CLI_NAME }} build`, and `{{ CLI_NAME }} deploy` commands will use the entry points in the connector, and your `prod.js` entrypoint will be used to serve requests in the {{ PRODUCT_NAME }} cloud.