9 files changed, 171 insertions, 253 deletions

diff --git a/support/doc/api/embeds.md b/support/doc/api/embeds.md
index fd5507e38..989c8e98e 100644
--- a/support/doc/api/embeds.md
+++ b/support/doc/api/embeds.md
@@ -20,7 +20,7 @@ yarn add @peertube/embed-api
 Now just use the `PeerTubePlayer` class exported by the module:
 
 ```typescript
-import { PeerTubePlayer } from '@peertube/embed-api'
+import { PeerTubePlayer } from '@peertube/embed-api.js'
 
 ...
 ```
diff --git a/support/doc/api/openapi.yaml b/support/doc/api/openapi.yaml
index 0cbc58678..5d54a7a51 100644
--- a/support/doc/api/openapi.yaml
+++ b/support/doc/api/openapi.yaml
@@ -53,7 +53,7 @@ info:
     }
     ```
 
-    We provide error `type` values for [a growing number of cases](https://github.com/Chocobozzz/PeerTube/blob/develop/shared/models/server/server-error-code.enum.ts),
+    We provide error `type` values for [a growing number of cases](https://github.com/Chocobozzz/PeerTube/blob/develop/packages/models/server/server-error-code.enum.ts),
     but it is still optional. Types are used to disambiguate errors that bear the same status code
     and are non-obvious:
 
@@ -8752,7 +8752,7 @@ components:
         password:
           $ref: '#/components/schemas/password'
     UpdateMe:
-      # see shared/models/users/user-update-me.model.ts:
+      # see packages/models/users/user-update-me.model.ts:
       properties:
         password:
           $ref: '#/components/schemas/password'
diff --git a/support/doc/development/lib.md b/support/doc/development/lib.md
index 25fe3068e..1ea09f2bc 100644
--- a/support/doc/development/lib.md
+++ b/support/doc/development/lib.md
@@ -18,7 +18,7 @@ The complete types package is generated via:
 
 ```
 npm run generate-types-package 4.x.x
-cd packages/types/dist
+cd packages/types-generator/dist
 npm publish --access=public
 ```
 
diff --git a/support/doc/development/localization.md b/support/doc/development/localization.md
index a38ed6f55..4aca9b18b 100644
--- a/support/doc/development/localization.md
+++ b/support/doc/development/localization.md
@@ -26,7 +26,7 @@ Nothing to do here, Github will automatically send a webhook to Weblate that wil
 
 ## Support a new language
 
- * Add it to [/shared/models/i18n/i18n.ts](/shared/models/i18n/i18n.ts)
+ * Add it to [/packages/models/i18n/i18n.ts](/packages/models/i18n/i18n.ts)
  * Add it to [/scripts/build/client.sh](/scripts/build/client.sh)
  * Add it to [/client/angular.json](/client/angular.json)
  * Add it to [/scripts/i18n/update.sh](/scripts/i18n/update.sh)
diff --git a/support/doc/development/monitoring.md b/support/doc/development/monitoring.md
index 93fd1403e..023be9e92 100644
--- a/support/doc/development/monitoring.md
+++ b/support/doc/development/monitoring.md
@@ -13,11 +13,11 @@ npm run build -- --analyze-bundle && npm run client-report
 To benchmark the REST API and save result in `benchmark.json`:
 
 ```
-node dist/scripts/benchmark.js -o benchmark.json
+npm run benchmark-server -- -o benchmark.json
 ```
 
 You can also grep on a specific test:
 
 ```
-node dist/scripts/benchmark.js --grep homepage
+npm run benchmark-server -- --grep homepage
 ```
diff --git a/support/doc/development/server.md b/support/doc/development/server.md
index 7a9fa571f..5c83af704 100644
--- a/support/doc/development/server.md
+++ b/support/doc/development/server.md
@@ -1,11 +1,11 @@
-# Server code
+ # Server code
 
 ## Database model typing
 
 Sequelize models contain optional fields corresponding to table joins.
 For example, `VideoModel` has a `VideoChannel?: VideoChannelModel` field. It can be filled if the SQL query joined with the `videoChannel` table or empty if not.
 It can be difficult in TypeScript to understand if a function argument expects associations to be filled or not.
-To improve clarity and reduce bugs, PeerTube defines multiple versions of a database model depending on its associations in `server/types/models/`.
+To improve clarity and reduce bugs, PeerTube defines multiple versions of a database model depending on its associations in `server/server/types/models/`.
 These models start with `M` and by default do not include any association. `MVideo` for example corresponds to `VideoModel` without any association, where `VideoChannel` attribute doesn't exist. On the other hand, `MVideoWithChannel` is a `MVideo` that has a `VideoChannel` field. This way, a function that accepts `video: MVideoWithChannel` argument expects a video with channel populated. Main PeerTube code should never use `...Model` (`VideoModel`) database type, but always `M...` instead (`MVideo`, `MVideoChannel` etc).
 
 ## Add a new feature walkthrough
@@ -16,67 +16,67 @@ Some of these may be optional (for example your new endpoint may not need to sen
  * Configuration:
    - Add you new configuration key in `config/default.yaml` and `config/production.yaml`
    - If you configuration needs to be different in dev or tests environments, also update `config/dev.yaml` and `config/test.yaml`
-   - Load your configuration in `server/initializers/config.ts`
-   - Check new configuration keys are set in `server/initializers/checker-before-init.ts`
-   - You can also ensure configuration consistency in `server/initializers/checker-after-init.ts`
+   - Load your configuration in `server/server/initializers/config.ts`
+   - Check new configuration keys are set in `server/server/initializers/checker-before-init.ts`
+   - You can also ensure configuration consistency in `server/server/initializers/checker-after-init.ts`
    - If you want your configuration to be available in the client:
-     + Add your field in `shared/models/server/server-config.model.ts`
-     + Update `server/lib/server-config-manager.ts` to include your new configuration
+     + Add your field in `packages/models/server/server/server-config.model.ts`
+     + Update `server/server/lib/server-config-manager.ts` to include your new configuration
    - If you want your configuration to be updatable by the web admin in the client:
-     + Add your field in `shared/models/server/custom-config.model.ts`
-     + Add the configuration to the config object in the `server/controllers/api/config.ts` controller
+     + Add your field in `packages/models/server/server/custom-config.model.ts`
+     + Add the configuration to the config object in the `server/server/controllers/api/config.ts` controller
  * Controllers:
    - Create the controller file and fill it with your REST API routes
    - Import and use your controller in the parent controller
  * Middlewares:
-   - Create your validator middleware in `server/middlewares/validators` that will be used by your controllers
-   - Add your new middleware file `server/middlewares/validators/index.ts` so it's easier to import
-   - Create the entry in `server/types/express.d.ts` to attach the database model loaded by your middleware to the express response
+   - Create your validator middleware in `server/server/middlewares/validators` that will be used by your controllers
+   - Add your new middleware file `server/server/middlewares/validators/index.ts` so it's easier to import
+   - Create the entry in `server/server/types/express.d.ts` to attach the database model loaded by your middleware to the express response
  * Validators:
-   - Create your validators that will be used by your middlewares in `server/helpers/custom-validators`
+   - Create your validators that will be used by your middlewares in `server/server/helpers/custom-validators`
  * Typescript models:
-   - Create the API models (request parameters or response) in `shared/models`
+   - Create the API models (request parameters or response) in `packages/models`
    - Add your models in `index.ts` of current directory to facilitate the imports
  * Sequelize model (BDD):
    - If you need to create a new table:
-     + Create the Sequelize model in `server/models/`:
+     + Create the Sequelize model in `server/server/models/`:
        * Create the `@Column`
        * Add some indexes if you need
        * Create static methods to load a specific from the database `loadBy...`
        * Create static methods to load a list of models from the database `listBy...`
        * Create the instance method `toFormattedJSON` that creates the JSON to send to the REST API from the model
-     + Add your new Sequelize model to `server/initializers/database.ts`
-     + Create a new file in `server/types` to define multiple versions of your Sequelize model depending on database associations
-     + Add this new file to `server/types/*/index.ts` to facilitate the imports
+     + Add your new Sequelize model to `server/server/initializers/database.ts`
+     + Create a new file in `server/server/types` to define multiple versions of your Sequelize model depending on database associations
+     + Add this new file to `server/server/types/*/index.ts` to facilitate the imports
      + Create database migrations:
-       * Create the migration file in `server/initializers/migrations` using raw SQL (copy the same SQL query as at PeerTube startup)
-       * Update `LAST_MIGRATION_VERSION` in `server/initializers/constants.ts`
+       * Create the migration file in `server/server/initializers/migrations` using raw SQL (copy the same SQL query as at PeerTube startup)
+       * Update `LAST_MIGRATION_VERSION` in `server/server/initializers/constants.ts`
    - If updating database schema (adding/removing/renaming a column):
-     + Update the sequelize models in `server/models/`
+     + Update the sequelize models in `server/server/models/`
      + Add migrations:
        * Create the migration file in `initializers/migrations` using Sequelize Query Interface (`.addColumn`, `.dropTable`, `.changeColumn`)
-       * Update `LAST_MIGRATION_VERSION` in `server/initializers/constants.ts`
+       * Update `LAST_MIGRATION_VERSION` in `server/server/initializers/constants.ts`
  * Notifications:
-   - Create the new notification model in `shared/models/users/user-notification.model.ts`
-   - Create the notification logic in `server/lib/notifier/shared`:
+   - Create the new notification model in `packages/models/users/user-notification.model.ts`
+   - Create the notification logic in `server/server/lib/notifier/shared`:
      + Email subject has a common prefix (defined by the admin in PeerTube configuration)
-   - Add your notification to `server/lib/notifier/notifier.ts`
-   - Create the email template in `server/lib/emails`:
+   - Add your notification to `server/server/lib/notifier/notifier.ts`
+   - Create the email template in `server/server/lib/emails`:
      + A text version is automatically generated from the HTML
      + The template usually extends `../common/grettings` that already says "Hi" and "Cheers". You just have to write the title and the content blocks that will be inserted in the appropriate places in the HTML template
    - If you need to associate a new table with `userNotification`:
      + Associate the new table in `UserNotificationModel` (don't forget the index)
-     + Add the object property in the API model definition (`shared/models/users/user-notification.model.ts`)
+     + Add the object property in the API model definition (`packages/models/users/user-notification.model.ts`)
      + Add the object in `UserNotificationModel.toFormattedJSON`
      + Handle this new notification type in client (`UserNotificationsComponent`)
      + Handle the new object property in client model (`UserNotification`)
  * Tests:
-   - Create your command class in `shared/server-commands/` that will wrap HTTP requests to your new endpoint
+   - Create your command class in `packages/server-commands/` that will wrap HTTP requests to your new endpoint
    - Add your command file in `index.ts` of current directory
-   - Instantiate your command class in `shared/server-commands/server/server.ts`
-   - Create your test file in `server/tests/api/check-params` to test middleware validators/authentification/user rights (offensive tests)
-   - Add it to `server/tests/api/check-params/index.ts`
-   - Create your test file in `server/tests/api` to test your new endpoints
+   - Instantiate your command class in `packages/server-commands/server/server/server.ts`
+   - Create your test file in `server/server/tests/api/check-params` to test middleware validators/authentification/user rights (offensive tests)
+   - Add it to `server/server/tests/api/check-params/index.ts`
+   - Create your test file in `server/server/tests/api` to test your new endpoints
    - Add it to `index.ts` of current directory
-   - Add your notification test in `server/tests/api/notifications`
+   - Add your notification test in `server/server/tests/api/notifications`
  * Update REST API documentation in `support/doc/api/openapi.yaml`
diff --git a/support/doc/development/tests.md b/support/doc/development/tests.md
index 1c2589c8a..2e4c6ff6a 100644
--- a/support/doc/development/tests.md
+++ b/support/doc/development/tests.md
@@ -8,7 +8,7 @@ Prepare PostgreSQL user so PeerTube can delete/create the test databases:
 sudo -u postgres createuser you_username --createdb --superuser
 ```
 
-Prepare databases:
+Prepare the databases:
 
 ```bash
 npm run clean:server:test
@@ -45,22 +45,19 @@ sudo apt-get install parallel libimage-exiftool-perl
 
 ### Test
 
-To run all test suites:
+To run all test suites (can be long!):
 
 ```bash
 npm run test # See scripts/test.sh to run a particular suite
 ```
 
-Most of tests can be run using:
+To run a specific test:
 
 ```bash
-TS_NODE_TRANSPILE_ONLY=true npm run mocha -- --timeout 30000 --exit -r ts-node/register -r tsconfig-paths/register --bail server/tests/api/videos/video-transcoder.ts
-```
-
-`server/tests/api/activitypub` tests will need different options:
+npm run mocha -- --exit --bail packages/tests/src/your-test.ts
 
-```
-TS_NODE_FILES=true mocha -- --timeout 30000 --exit -r ts-node/register -r tsconfig-paths/register --bail server/tests/api/activitypub/security.ts
+# For example
+npm run mocha -- --exit --bail packages/tests/src/api/videos/single-server.ts
 ```
 
 ### Configuration
diff --git a/support/doc/plugins/guide.md b/support/doc/plugins/guide.md
index ff08ce8c4..07f484934 100644
--- a/support/doc/plugins/guide.md
+++ b/support/doc/plugins/guide.md
@@ -387,7 +387,7 @@ function register (...) {
       displayName: 'User display name',
 
       // Custom admin flags (bypass video auto moderation etc.)
-      // https://github.com/Chocobozzz/PeerTube/blob/develop/shared/models/users/user-flag.model.ts
+      // https://github.com/Chocobozzz/PeerTube/blob/develop/packages/models/users/user-flag.model.ts
       // PeerTube >= 5.1
       adminFlags: 0,
       // Quota in bytes
@@ -977,7 +977,7 @@ npm install --save-dev @peertube/peertube-types
 
 This package exposes *server* definition files by default:
 ```ts
-import { RegisterServerOptions } from '@peertube/peertube-types'
+import { RegisterServerOptions } from '@peertube/peertube-types.js'
 
 export async function register ({ registerHook }: RegisterServerOptions) {
   registerHook({
@@ -989,8 +989,8 @@ export async function register ({ registerHook }: RegisterServerOptions) {
 
 But it also exposes client types and various models used in __PeerTube__:
 ```ts
-import { Video } from '@peertube/peertube-types';
-import { RegisterClientOptions } from '@peertube/peertube-types/client';
+import { Video } from '@peertube/peertube-types.js';
+import { RegisterClientOptions } from '@peertube/peertube-types/client.js';
 
 function register({ registerHook, peertubeHelpers }: RegisterClientOptions) {
   registerHook({
@@ -1032,7 +1032,7 @@ If you want to translate strings of your plugin (like labels of your registered
 }
 ```
 
-The key should be one of the locales defined in [i18n.ts](https://github.com/Chocobozzz/PeerTube/blob/develop/shared/models/i18n/i18n.ts).
+The key should be one of the locales defined in [i18n.ts](https://github.com/Chocobozzz/PeerTube/blob/develop/packages/models/i18n/i18n.ts).
 
 Translation files are just objects, with the english sentence as the key and the translation as the value.
 `fr.json` could contain for example:
@@ -1070,40 +1070,25 @@ You built files are in the `dist/` directory. Check `package.json` to correctly
 
 ### Test your plugin/theme
 
-PeerTube dev server (ran with `npm run dev` on `localhost:3000`) can't inject plugin CSS.
-It's the reason why we don't use the dev mode but build PeerTube instead.
+You need to have a running PeerTube instance with an administrator account.
+If you're using dev server on your local computer, test your plugin on `localhost:9000` using `npm run dev` because plugin CSS is not injected in Angular webserver (`localhost:3000`).
 
-You'll need to have a local PeerTube instance:
- * Follow the [dev prerequisites](https://github.com/Chocobozzz/PeerTube/blob/develop/.github/CONTRIBUTING.md#prerequisites)
- (to clone the repository, install dependencies and prepare the database)
- * Build PeerTube:
+Install PeerTube CLI (can be installed on another computer/server than the PeerTube instance):
 
-```sh
-npm run build
-```
-
- * Build the CLI:
-
-```sh
-npm run setup:cli
-```
-
- * Run PeerTube (you can access to your instance on `localhost:9000`):
-
-```sh
-NODE_ENV=dev npm start
+```bash
+npm install -g @peertube/peertube-cli
 ```
 
- * Register the instance via the CLI:
+Register the PeerTube instance via the CLI:
 
 ```sh
-node ./dist/server/tools/peertube.js auth add -u 'http://localhost:9000' -U 'root' --password 'test'
+peertube-cli auth add -u 'https://peertube.example.com' -U 'root' --password 'test'
 ```
 
-Then, you can install or reinstall your local plugin/theme by running:
+Then, you can install your local plugin/theme by running:
 
 ```sh
-node ./dist/server/tools/peertube.js plugins install --path /your/absolute/plugin-or-theme/path
+peertube-cli plugins install --path /your/absolute/plugin-or-theme/path
 ```
 
 ### Publish
diff --git a/support/doc/tools.md b/support/doc/tools.md
index 2b3ebf159..40d9ec66a 100644
--- a/support/doc/tools.md
+++ b/support/doc/tools.md
@@ -4,59 +4,48 @@
 
 ## Remote PeerTube CLI
 
-You need at least 512MB RAM to run the script.
-Scripts can be launched directly from a PeerTube server, or from a separate server, even a desktop PC.
-You need to follow all the following steps even if you are on a PeerTube server (including cloning the git repository in a different directory than your production installation because the scripts utilize non-production dependencies).
-
-### Dependencies
-
-Install the [PeerTube dependencies](/support/doc/dependencies.md) except PostgreSQL and Redis.
+`peertube-cli` is a tool that communicates with a PeerTube instance using its [REST API](https://docs.joinpeertube.org/api-rest-reference.html).
+It can be launched from a remote server/computer to easily upload videos, manage plugins, redundancies etc.
 
 ### Installation
 
-Clone the PeerTube repo to get the latest version (even if you are on your PeerTube server):
+Ensure you have `node` installed on your system:
 
 ```bash
-git clone https://github.com/Chocobozzz/PeerTube.git
-CLONE="$(pwd)/PeerTube"
-cd ${CLONE}
+node --version # Should be >= 16.x
 ```
 
-Install dependencies and build CLI tools:
+Then install the CLI:
 
 ```bash
-NOCLIENT=1 yarn install --pure-lockfile
-npm run setup:cli
+sudo npm install -g @peertube/peertube-cli
 ```
 
 ### CLI wrapper
 
-The wrapper provides a convenient interface to the following scripts.
-You can access it as `peertube` via an alias in your `.bashrc` like `alias peertube="cd /your/peertube/directory/ && node ./dist/server/tools/peertube.js"` (you have to keep the `cd` command):
+The wrapper provides a convenient interface to the following sub-commands.
 
 ```
-  Usage: peertube [command] [options]
-
-  Options:
+Usage: peertube-cli [command] [options]
 
-    -v, --version         output the version number
-    -h, --help            output usage information
+Options:
+  -v, --version                     output the version number
+  -h, --help                        display help for command
 
-  Commands:
-
-    auth [action]         register your accounts on remote instances to use them with other commands
-    upload|up             upload a video
-    import-videos|import  import a video from a streaming platform
-    plugins|p [action]    manage instance plugins
-    redundancy|r [action] manage video redundancies
-    help [cmd]            display help for [cmd]
+Commands:
+  auth                              Register your accounts on remote instances to use them with other commands
+  upload|up [options]               Upload a video on a PeerTube instance
+  redundancy|r                      Manage instance redundancies
+  plugins|p                         Manage instance plugins/themes
+  get-access-token|token [options]  Get a peertube access token
+  help [command]                    display help for command
 ```
 
 The wrapper can keep track of instances you have an account on. We limit to one account per instance for now.
 
 ```bash
-peertube auth add -u 'PEERTUBE_URL' -U 'PEERTUBE_USER' --password 'PEERTUBE_PASSWORD'
-peertube auth list
+peertube-cli auth add -u 'PEERTUBE_URL' -U 'PEERTUBE_USER' --password 'PEERTUBE_PASSWORD'
+peertube-cli auth list
 ┌──────────────────────────────┬──────────────────────────────┐
 │ instance                     │ login                        │
 ├──────────────────────────────┼──────────────────────────────┤
@@ -64,124 +53,142 @@ peertube auth list
 └──────────────────────────────┴──────────────────────────────┘
 ```
 
-You can now use that account to upload videos without feeding the same parameters again.
+You can now use that account to execute sub-commands without feeding the `--url`, `--username` and `--password` parameters:
 
 ```bash
-peertube up <videoFile>
+peertube-cli upload <videoFile>
+peertube-cli plugins list
+...
 ```
 
-To list, install, uninstall dynamically plugins/themes of an instance:
+#### peertube-cli upload
+
+You can use this script to upload videos directly from the CLI.
+
+Videos will be publicly available after transcoding (you can see them before that in your account on the web interface).
 
 ```bash
-peertube plugins list
-peertube plugins install --path /local/plugin/path
-peertube plugins install --npm-name peertube-plugin-myplugin
-peertube plugins uninstall --npm-name peertube-plugin-myplugin
+cd ${CLONE}
+peertube-cli upload --help
 ```
 
-#### peertube-import-videos.js
+#### peertube-cli plugins
+
+Install/update/uninstall or list local or NPM PeerTube plugins:
 
-You can use this script to import videos from all [supported sites of youtube-dl](https://rg3.github.io/youtube-dl/supportedsites.html) into PeerTube.
-Be sure you own the videos or have the author's authorization to do so.
+```bash
+cd ${CLONE}
+peertube-cli plugins --help
+peertube-cli plugins list --help
+peertube-cli plugins install --help
+peertube-cli plugins update --help
+peertube-cli plugins uninstall --help
 
-```sh
-node dist/server/tools/peertube-import-videos.js \
-    -u 'PEERTUBE_URL' \
-    -U 'PEERTUBE_USER' \
-    --password 'PEERTUBE_PASSWORD' \
-    --target-url 'TARGET_URL'
+peertube-cli plugins install --path /my/plugin/path
+peertube-cli plugins install --npm-name peertube-theme-example
 ```
 
-* `PEERTUBE_URL` : the full URL of your PeerTube server where you want to import, eg: https://peertube.cpy.re
-* `PEERTUBE_USER` : your PeerTube account where videos will be uploaded
-* `PEERTUBE_PASSWORD` : password of your PeerTube account (if `--password PEERTUBE_PASSWORD` is omitted, you will be prompted for it)
-* `TARGET_URL` : the target url you want to import. Examples:
-  * YouTube:
-    * Channel: https://www.youtube.com/channel/ChannelId
-    * User https://www.youtube.com/c/UserName or https://www.youtube.com/user/UserName
-    * Video https://www.youtube.com/watch?v=blabla
-  * Vimeo: https://vimeo.com/xxxxxx
-  * Dailymotion: https://www.dailymotion.com/xxxxx
+#### peertube-cli redundancy
 
-The script will get all public videos from Youtube, download them and upload to PeerTube.
-Already downloaded videos will not be uploaded twice, so you can run and re-run the script in case of crash, disconnection...
+Manage (list/add/remove) video redundancies:
 
-Videos will be publicly available after transcoding (you can see them before that in your account on the web interface).
+To list your videos that are duplicated by remote instances:
+
+```bash
+peertube-cli redundancy list-remote-redundancies
+```
 
-**NB**: If you want to synchronize a Youtube channel to your PeerTube instance (ensure you have the agreement from the author),
-you can add a [crontab rule](https://help.ubuntu.com/community/CronHowto) (or an equivalent of your OS) and insert
-these rules (ensure to customize them to your needs):
+To list remote videos that your instance duplicated:
 
+```bash
+peertube-cli redundancy list-my-redundancies
+```
+
+To duplicate a specific video in your redundancy system:
+
+```bash
+peertube-cli redundancy add --video 823
 ```
-# Update youtube-dl every day at midnight
-0 0 * * * /usr/bin/npm rebuild youtube-dl --prefix /PATH/TO/PEERTUBE/
 
-# Synchronize the YT channel every sunday at 22:00 all the videos published since last monday included
-0 22 * * 0 /usr/bin/node /PATH/TO/PEERTUBE/dist/server/tools/peertube-import-videos.js -u '__PEERTUBE_URL__' -U '__USER__' --password '__PASSWORD__' --target-url 'https://www.youtube.com/channel/___CHANNEL__' --since $(date --date="-6 days" +\%Y-\%m-\%d)
+To remove a video redundancy:
+
+```bash
+peertube-cli redundancy remove --video 823
 ```
 
-Also you may want to subscribe to the PeerTube channel in order to manually check the synchronization is successful.
 
-#### peertube-upload.js
+## PeerTube runner
 
-You can use this script to import videos directly from the CLI.
+PeerTube >= 5.2 supports VOD or Live transcoding by a remote PeerTube runner.
 
-Videos will be publicly available after transcoding (you can see them before that in your account on the web interface).
+### Installation
+
+Ensure you have `node`, `ffmpeg` and `ffprobe` installed on your system:
 
 ```bash
-cd ${CLONE}
-node dist/server/tools/peertube-upload.js --help
+node --version # Should be >= 16.x
+ffprobe -version # Should be >= 4.3
+ffmpeg -version # Should be >= 4.3
 ```
 
-#### peertube-plugins.js
-
-Install/update/uninstall or list local or NPM PeerTube plugins:
+Then install the CLI:
 
 ```bash
-cd ${CLONE}
-node dist/server/tools/peertube-plugins.js --help
-node dist/server/tools/peertube-plugins.js list --help
-node dist/server/tools/peertube-plugins.js install --help
-node dist/server/tools/peertube-plugins.js update --help
-node dist/server/tools/peertube-plugins.js uninstall --help
+sudo npm install -g @peertube/peertube-runner
+```
+
+### Configuration
+
+The runner uses env paths like `~/.config`, `~/.cache` and `~/.local/share` directories to store runner configuration or temporary files.
+
+Multiple PeerTube runners can run on the same OS by using the `--id` CLI option (each runner uses its own config/tmp directories):
 
-node dist/server/tools/peertube-plugins.js install --path /my/plugin/path
-node dist/server/tools/peertube-plugins.js install --npm-name peertube-theme-example
+```bash
+peertube-runner [commands] --id instance-1
+peertube-runner [commands] --id instance-2
+peertube-runner [commands] --id instance-3
 ```
 
-#### peertube-redundancy.js
+You can change the runner configuration (jobs concurrency, ffmpeg threads/nice etc) by editing `~/.config/peertube-runner-nodejs/[id]/config.toml`.
 
-Manage (list/add/remove) video redundancies:
+### Run the server
 
-To list your videos that are duplicated by remote instances:
+You need to run the runner in server mode first so it can run transcoding jobs of registered PeerTube instances:
 
 ```bash
-node dist/server/tools/peertube.js redundancy list-remote-redundancies
+peertube-runner server
 ```
 
-To list remote videos that your instance duplicated:
+### Register
+
+Then, you can register the runner to process transcoding job of a remote PeerTube instance:
 
 ```bash
-node dist/server/tools/peertube.js redundancy list-my-redundancies
+peertube-runner register --url http://peertube.example.com --registration-token ptrrt-... --runner-name my-runner-name
 ```
 
-To duplicate a specific video in your redundancy system:
+The runner will then use a websocket connection with the PeerTube instance to be notified about new available transcoding jobs.
+
+### Unregister
+
+To unregister a PeerTube instance:
 
 ```bash
-node dist/server/tools/peertube.js redundancy add --video 823
+peertube-runner unregister --url http://peertube.example.com --runner-name my-runner-name
 ```
 
-To remove a video redundancy:
+### List registered instances
 
 ```bash
-node dist/server/tools/peertube.js redundancy remove --video 823
+peertube-runner list-registered
 ```
 
 ## Server tools
 
-These scripts should be run on the server, in `peertube-latest` directory.
+Server tools are scripts that interect directly with the code of your PeerTube instance.
+They must be run on the server, in `peertube-latest` directory.
 
-### parse-log
+### Parse logs
 
 To parse PeerTube last log file:
 
@@ -209,9 +216,7 @@ cd /var/www/peertube-docker
 docker-compose exec -u peertube peertube npm run parse-log -- --level debug --not-tags http sql
 ```
 
-### regenerate-thumbnails.js
-
-**PeerTube >= 3.2**
+### Regenerate video thumbnails
 
 Regenerating local video thumbnails could be useful because new PeerTube releases may increase thumbnail sizes:
 
@@ -225,7 +230,7 @@ cd /var/www/peertube-docker
 docker-compose exec -u peertube peertube npm run regenerate-thumbnails
 ```
 
-### create-import-video-file-job.js
+### Add or replace specific video file
 
 You can use this script to import a video file to replace an already uploaded file or to add a new web compatible resolution to a video. PeerTube needs to be running.
 You can then create a transcoding job using the web interface if you need to optimize your file or create an HLS version of it.
@@ -240,9 +245,7 @@ cd /var/www/peertube-docker
 docker-compose exec -u peertube peertube npm run create-import-video-file-job -- -v [videoUUID] -i [videoFile]
 ```
 
-### create-move-video-storage-job.js
-
-**PeerTube >= 4.0**
+### Move video files to object storage
 
 Use this script to move all video files or a specific video file to object storage.
 
@@ -269,7 +272,7 @@ docker-compose exec -u peertube peertube npm run create-move-video-storage-job -
 ```
 
 <!-- TODO: uncomment when PeerTube 6 is released
-### create-generate-storyboard-job
+### Generate storyboard
 
 **PeerTube >= 6.0**
 
@@ -298,7 +301,7 @@ docker-compose exec -u peertube peertube npm run create-generate-storyboard-job
 ```
 -->
 
-### prune-storage.js
+### Prune filesystem storage
 
 Some transcoded videos or shutdown at a bad time can leave some unused files on your storage.
 Stop PeerTube and delete these files (a confirmation will be demanded first):
@@ -308,8 +311,7 @@ cd /var/www/peertube/peertube-latest
 sudo systemctl stop peertube && sudo -u peertube NODE_CONFIG_DIR=/var/www/peertube/config NODE_ENV=production npm run prune-storage
 ```
 
-
-### update-host.js
+### Update PeerTube instance domain name
 
 **Changing the hostname is unsupported and may be a risky operation, especially if you have already federated.**
 If you started PeerTube with a domain, and then changed it you will have
@@ -326,7 +328,7 @@ cd /var/www/peertube-docker
 docker-compose exec -u peertube peertube npm run update-host
 ```
 
-### reset-password.js
+### Reset user password
 
 To reset a user password from CLI, run:
 
@@ -341,7 +343,7 @@ docker-compose exec -u peertube peertube npm run reset-password -- -u target_use
 ```
 
 
-### plugin install/uninstall
+### Install or uninstall plugins
 
 The difference with `peertube plugins` CLI is that these scripts can be used even if PeerTube is not running.
 If PeerTube is running, you need to restart it for the changes to take effect (whereas with `peertube plugins` CLI, plugins/themes are dynamically loaded on the server).
@@ -378,69 +380,3 @@ sudo -u peertube NODE_CONFIG_DIR=/var/www/peertube/config NODE_ENV=production np
 cd /var/www/peertube-docker
 docker-compose exec -u peertube peertube npm run plugin:uninstall -- --npm-name peertube-plugin-myplugin
 ```
-
-## PeerTube runner
-
-PeerTube >= 5.2 supports VOD or Live transcoding by a remote PeerTube runner.
-
-
-### Installation
-
-Ensure you have `ffmpeg` and `ffprobe` installed on your system:
-
-```bash
-ffprobe -version # Should be >= 4.3
-ffmpeg -version # Should be >= 4.3
-```
-
-Then install the CLI:
-
-```bash
-sudo npm install -g @peertube/peertube-runner
-```
-
-### Configuration
-
-The runner uses env paths like `~/.config`, `~/.cache` and `~/.local/share` directories to store runner configuration or temporary files.
-
-Multiple PeerTube runners can run on the same OS by using the `--id` CLI option (each runner uses its own config/tmp directories):
-
-```bash
-peertube-runner [commands] --id instance-1
-peertube-runner [commands] --id instance-2
-peertube-runner [commands] --id instance-3
-```
-
-You can change the runner configuration (jobs concurrency, ffmpeg threads/nice etc) by editing `~/.config/peertube-runner-nodejs/[id]/config.toml`.
-
-### Run the server
-
-You need to run the runner in server mode first so it can run transcoding jobs of registered PeerTube instances:
-
-```bash
-peertube-runner server
-```
-
-### Register
-
-Then, you can register the runner to process transcoding job of a remote PeerTube instance:
-
-```bash
-peertube-runner register --url http://peertube.example.com --registration-token ptrrt-... --runner-name my-runner-name
-```
-
-The runner will then use a websocket connection with the PeerTube instance to be notified about new available transcoding jobs.
-
-### Unregister
-
-To unregister a PeerTube instance:
-
-```bash
-peertube-runner unregister --url http://peertube.example.com --runner-name my-runner-name
-```
-
-### List registered instances
-
-```bash
-peertube-runner list-registered
-```