Migrate server to ESM

Sorry for the very big commit that may lead to git log issues and merge
conflicts, but it's a major step forward:

 * Server can be faster at startup because imports() are async and we can
   easily lazy import big modules
 * Angular doesn't seem to support ES import (with .js extension), so we
   had to correctly organize peertube into a monorepo:
    * Use yarn workspace feature
    * Use typescript reference projects for dependencies
    * Shared projects have been moved into "packages", each one is now a
      node module (with a dedicated package.json/tsconfig.json)
    * server/tools have been moved into apps/ and is now a dedicated app
      bundled and published on NPM so users don't have to build peertube
      cli tools manually
    * server/tests have been moved into packages/ so we don't compile
      them every time we want to run the server
 * Use isolatedModule option:
   * Had to move from const enum to const
     (https://www.typescriptlang.org/docs/handbook/enums.html#objects-vs-enums)
   * Had to explictely specify "type" imports when used in decorators
 * Prefer tsx (that uses esbuild under the hood) instead of ts-node to
   load typescript files (tests with mocha or scripts):
     * To reduce test complexity as esbuild doesn't support decorator
       metadata, we only test server files that do not import server
       models
     * We still build tests files into js files for a faster CI
 * Remove unmaintained peertube CLI import script
 * Removed some barrels to speed up execution (less imports)

10 files changed, 1263 insertions, 0 deletions

diff --git a/packages/tests/src/cli/create-generate-storyboard-job.ts b/packages/tests/src/cli/create-generate-storyboard-job.ts
new file mode 100644
index 000000000..5a1c61ef1
--- /dev/null
+++ b/packages/tests/src/cli/create-generate-storyboard-job.ts
@@ -0,0 +1,121 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { remove } from 'fs-extra/esm'
+import { readdir } from 'fs/promises'
+import { join } from 'path'
+import { HttpStatusCode } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  makeGetRequest,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+import { SQLCommand } from '../shared/sql-command.js'
+
+function listStoryboardFiles (server: PeerTubeServer) {
+  const storage = server.getDirectoryPath('storyboards')
+
+  return readdir(storage)
+}
+
+describe('Test create generate storyboard job', function () {
+  let servers: PeerTubeServer[] = []
+  const uuids: string[] = []
+  let sql: SQLCommand
+  let existingStoryboardName: string
+
+  before(async function () {
+    this.timeout(120000)
+
+    // Run server 2 to have transcoding enabled
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+
+    await doubleFollow(servers[0], servers[1])
+
+    for (let i = 0; i < 3; i++) {
+      const { uuid } = await servers[0].videos.quickUpload({ name: 'video ' + i })
+      uuids.push(uuid)
+    }
+
+    await waitJobs(servers)
+
+    const storage = servers[0].getDirectoryPath('storyboards')
+    for (const storyboard of await listStoryboardFiles(servers[0])) {
+      await remove(join(storage, storyboard))
+    }
+
+    sql = new SQLCommand(servers[0])
+    await sql.deleteAll('storyboard')
+
+    const { uuid } = await servers[0].videos.quickUpload({ name: 'video 4' })
+    uuids.push(uuid)
+
+    await waitJobs(servers)
+
+    const storyboards = await listStoryboardFiles(servers[0])
+    existingStoryboardName = storyboards[0]
+  })
+
+  it('Should create a storyboard of a video', async function () {
+    this.timeout(120000)
+
+    for (const uuid of [ uuids[0], uuids[3] ]) {
+      const command = `npm run create-generate-storyboard-job -- -v ${uuid}`
+      await servers[0].cli.execWithEnv(command)
+    }
+
+    await waitJobs(servers)
+
+    {
+      const storyboards = await listStoryboardFiles(servers[0])
+      expect(storyboards).to.have.lengthOf(2)
+      expect(storyboards).to.not.include(existingStoryboardName)
+
+      existingStoryboardName = storyboards[0]
+    }
+
+    for (const server of servers) {
+      for (const uuid of [ uuids[0], uuids[3] ]) {
+        const { storyboards } = await server.storyboard.list({ id: uuid })
+        expect(storyboards).to.have.lengthOf(1)
+
+        await makeGetRequest({ url: server.url, path: storyboards[0].storyboardPath, expectedStatus: HttpStatusCode.OK_200 })
+      }
+    }
+  })
+
+  it('Should create missing storyboards', async function () {
+    this.timeout(120000)
+
+    const command = `npm run create-generate-storyboard-job -- -a`
+    await servers[0].cli.execWithEnv(command)
+
+    await waitJobs(servers)
+
+    {
+      const storyboards = await listStoryboardFiles(servers[0])
+      expect(storyboards).to.have.lengthOf(4)
+      expect(storyboards).to.include(existingStoryboardName)
+    }
+
+    for (const server of servers) {
+      for (const uuid of uuids) {
+        const { storyboards } = await server.storyboard.list({ id: uuid })
+        expect(storyboards).to.have.lengthOf(1)
+
+        await makeGetRequest({ url: server.url, path: storyboards[0].storyboardPath, expectedStatus: HttpStatusCode.OK_200 })
+      }
+    }
+  })
+
+  after(async function () {
+    await sql.cleanup()
+
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/cli/create-import-video-file-job.ts b/packages/tests/src/cli/create-import-video-file-job.ts
new file mode 100644
index 000000000..fa934510c
--- /dev/null
+++ b/packages/tests/src/cli/create-import-video-file-job.ts
@@ -0,0 +1,168 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { HttpStatusCode, VideoDetails, VideoFile, VideoInclude } from '@peertube/peertube-models'
+import { areMockObjectStorageTestsDisabled, buildAbsoluteFixturePath } from '@peertube/peertube-node-utils'
+import {
+  ObjectStorageCommand,
+  PeerTubeServer,
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  makeRawRequest,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+import { expect } from 'chai'
+import { expectStartWith } from '../shared/checks.js'
+
+function assertVideoProperties (video: VideoFile, resolution: number, extname: string, size?: number) {
+  expect(video).to.have.nested.property('resolution.id', resolution)
+  expect(video).to.have.property('torrentUrl').that.includes(`-${resolution}.torrent`)
+  expect(video).to.have.property('fileUrl').that.includes(`.${extname}`)
+  expect(video).to.have.property('magnetUri').that.includes(`.${extname}`)
+  expect(video).to.have.property('size').that.is.above(0)
+
+  if (size) expect(video.size).to.equal(size)
+}
+
+async function checkFiles (video: VideoDetails, objectStorage: ObjectStorageCommand) {
+  for (const file of video.files) {
+    if (objectStorage) expectStartWith(file.fileUrl, objectStorage.getMockWebVideosBaseUrl())
+
+    await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 })
+  }
+}
+
+function runTests (enableObjectStorage: boolean) {
+  let video1ShortId: string
+  let video2UUID: string
+
+  let servers: PeerTubeServer[] = []
+
+  const objectStorage = new ObjectStorageCommand()
+
+  before(async function () {
+    this.timeout(90000)
+
+    const config = enableObjectStorage
+      ? objectStorage.getDefaultMockConfig()
+      : {}
+
+    // Run server 2 to have transcoding enabled
+    servers = await createMultipleServers(2, config)
+    await setAccessTokensToServers(servers)
+
+    await doubleFollow(servers[0], servers[1])
+
+    if (enableObjectStorage) await objectStorage.prepareDefaultMockBuckets()
+
+    // Upload two videos for our needs
+    {
+      const { shortUUID } = await servers[0].videos.upload({ attributes: { name: 'video1' } })
+      video1ShortId = shortUUID
+    }
+
+    {
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video2' } })
+      video2UUID = uuid
+    }
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      await server.config.enableTranscoding()
+    }
+  })
+
+  it('Should run a import job on video 1 with a lower resolution', async function () {
+    const command = `npm run create-import-video-file-job -- -v ${video1ShortId} -i ${buildAbsoluteFixturePath('video_short_480.webm')}`
+    await servers[0].cli.execWithEnv(command)
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const { data: videos } = await server.videos.list()
+      expect(videos).to.have.lengthOf(2)
+
+      const video = videos.find(({ shortUUID }) => shortUUID === video1ShortId)
+      const videoDetails = await server.videos.get({ id: video.shortUUID })
+
+      expect(videoDetails.files).to.have.lengthOf(2)
+      const [ originalVideo, transcodedVideo ] = videoDetails.files
+      assertVideoProperties(originalVideo, 720, 'webm', 218910)
+      assertVideoProperties(transcodedVideo, 480, 'webm', 69217)
+
+      await checkFiles(videoDetails, enableObjectStorage && objectStorage)
+    }
+  })
+
+  it('Should run a import job on video 2 with the same resolution and a different extension', async function () {
+    const command = `npm run create-import-video-file-job -- -v ${video2UUID} -i ${buildAbsoluteFixturePath('video_short.ogv')}`
+    await servers[1].cli.execWithEnv(command)
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const { data: videos } = await server.videos.listWithToken({ include: VideoInclude.NOT_PUBLISHED_STATE })
+      expect(videos).to.have.lengthOf(2)
+
+      const video = videos.find(({ uuid }) => uuid === video2UUID)
+      const videoDetails = await server.videos.get({ id: video.uuid })
+
+      expect(videoDetails.files).to.have.lengthOf(4)
+      const [ originalVideo, transcodedVideo420, transcodedVideo320, transcodedVideo240 ] = videoDetails.files
+      assertVideoProperties(originalVideo, 720, 'ogv', 140849)
+      assertVideoProperties(transcodedVideo420, 480, 'mp4')
+      assertVideoProperties(transcodedVideo320, 360, 'mp4')
+      assertVideoProperties(transcodedVideo240, 240, 'mp4')
+
+      await checkFiles(videoDetails, enableObjectStorage && objectStorage)
+    }
+  })
+
+  it('Should run a import job on video 2 with the same resolution and the same extension', async function () {
+    const command = `npm run create-import-video-file-job -- -v ${video1ShortId} -i ${buildAbsoluteFixturePath('video_short2.webm')}`
+    await servers[0].cli.execWithEnv(command)
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const { data: videos } = await server.videos.listWithToken({ include: VideoInclude.NOT_PUBLISHED_STATE })
+      expect(videos).to.have.lengthOf(2)
+
+      const video = videos.find(({ shortUUID }) => shortUUID === video1ShortId)
+      const videoDetails = await server.videos.get({ id: video.uuid })
+
+      expect(videoDetails.files).to.have.lengthOf(2)
+      const [ video720, video480 ] = videoDetails.files
+      assertVideoProperties(video720, 720, 'webm', 942961)
+      assertVideoProperties(video480, 480, 'webm', 69217)
+
+      await checkFiles(videoDetails, enableObjectStorage && objectStorage)
+    }
+  })
+
+  it('Should not have run transcoding after an import job', async function () {
+    const { data } = await servers[0].jobs.list({ jobType: 'video-transcoding' })
+    expect(data).to.have.lengthOf(0)
+  })
+
+  after(async function () {
+    await objectStorage.cleanupMock()
+
+    await cleanupTests(servers)
+  })
+}
+
+describe('Test create import video jobs', function () {
+
+  describe('On filesystem', function () {
+    runTests(false)
+  })
+
+  describe('On object storage', function () {
+    if (areMockObjectStorageTestsDisabled()) return
+
+    runTests(true)
+  })
+})
diff --git a/packages/tests/src/cli/create-move-video-storage-job.ts b/packages/tests/src/cli/create-move-video-storage-job.ts
new file mode 100644
index 000000000..1bee7414f
--- /dev/null
+++ b/packages/tests/src/cli/create-move-video-storage-job.ts
@@ -0,0 +1,125 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { join } from 'path'
+import { areMockObjectStorageTestsDisabled } from '@peertube/peertube-node-utils'
+import { HttpStatusCode, VideoDetails } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  makeRawRequest,
+  ObjectStorageCommand,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+import { expectStartWith } from '../shared/checks.js'
+import { checkDirectoryIsEmpty } from '@tests/shared/directories.js'
+
+async function checkFiles (origin: PeerTubeServer, video: VideoDetails, objectStorage?: ObjectStorageCommand) {
+  for (const file of video.files) {
+    const start = objectStorage
+      ? objectStorage.getMockWebVideosBaseUrl()
+      : origin.url
+
+    expectStartWith(file.fileUrl, start)
+
+    await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 })
+  }
+
+  const start = objectStorage
+    ? objectStorage.getMockPlaylistBaseUrl()
+    : origin.url
+
+  const hls = video.streamingPlaylists[0]
+  expectStartWith(hls.playlistUrl, start)
+  expectStartWith(hls.segmentsSha256Url, start)
+
+  for (const file of hls.files) {
+    expectStartWith(file.fileUrl, start)
+
+    await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 })
+  }
+}
+
+describe('Test create move video storage job', function () {
+  if (areMockObjectStorageTestsDisabled()) return
+
+  let servers: PeerTubeServer[] = []
+  const uuids: string[] = []
+  const objectStorage = new ObjectStorageCommand()
+
+  before(async function () {
+    this.timeout(360000)
+
+    // Run server 2 to have transcoding enabled
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+
+    await doubleFollow(servers[0], servers[1])
+
+    await objectStorage.prepareDefaultMockBuckets()
+
+    await servers[0].config.enableTranscoding()
+
+    for (let i = 0; i < 3; i++) {
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video' + i } })
+      uuids.push(uuid)
+    }
+
+    await waitJobs(servers)
+
+    await servers[0].kill()
+    await servers[0].run(objectStorage.getDefaultMockConfig())
+  })
+
+  it('Should move only one file', async function () {
+    this.timeout(120000)
+
+    const command = `npm run create-move-video-storage-job -- --to-object-storage -v ${uuids[1]}`
+    await servers[0].cli.execWithEnv(command, objectStorage.getDefaultMockConfig())
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const video = await server.videos.get({ id: uuids[1] })
+
+      await checkFiles(servers[0], video, objectStorage)
+
+      for (const id of [ uuids[0], uuids[2] ]) {
+        const video = await server.videos.get({ id })
+
+        await checkFiles(servers[0], video)
+      }
+    }
+  })
+
+  it('Should move all files', async function () {
+    this.timeout(120000)
+
+    const command = `npm run create-move-video-storage-job -- --to-object-storage --all-videos`
+    await servers[0].cli.execWithEnv(command, objectStorage.getDefaultMockConfig())
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      for (const id of [ uuids[0], uuids[2] ]) {
+        const video = await server.videos.get({ id })
+
+        await checkFiles(servers[0], video, objectStorage)
+      }
+    }
+  })
+
+  it('Should not have files on disk anymore', async function () {
+    await checkDirectoryIsEmpty(servers[0], 'web-videos', [ 'private' ])
+    await checkDirectoryIsEmpty(servers[0], join('web-videos', 'private'))
+
+    await checkDirectoryIsEmpty(servers[0], join('streaming-playlists', 'hls'), [ 'private' ])
+    await checkDirectoryIsEmpty(servers[0], join('streaming-playlists', 'hls', 'private'))
+  })
+
+  after(async function () {
+    await objectStorage.cleanupMock()
+
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/cli/index.ts b/packages/tests/src/cli/index.ts
new file mode 100644
index 000000000..94444ace3
--- /dev/null
+++ b/packages/tests/src/cli/index.ts
@@ -0,0 +1,10 @@
+// Order of the tests we want to execute
+import './create-import-video-file-job'
+import './create-generate-storyboard-job'
+import './create-move-video-storage-job'
+import './peertube'
+import './plugins'
+import './prune-storage'
+import './regenerate-thumbnails'
+import './reset-password'
+import './update-host'
diff --git a/packages/tests/src/cli/peertube.ts b/packages/tests/src/cli/peertube.ts
new file mode 100644
index 000000000..2c66b7a18
--- /dev/null
+++ b/packages/tests/src/cli/peertube.ts
@@ -0,0 +1,257 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { buildAbsoluteFixturePath } from '@peertube/peertube-node-utils'
+import {
+  cleanupTests,
+  CLICommand,
+  createSingleServer,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+import { testHelloWorldRegisteredSettings } from '../shared/plugins.js'
+
+describe('Test CLI wrapper', function () {
+  let server: PeerTubeServer
+  let userAccessToken: string
+
+  let cliCommand: CLICommand
+
+  const cmd = 'node ./apps/peertube-cli/dist/peertube.js'
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await createSingleServer(1, {
+      rates_limit: {
+        login: {
+          max: 30
+        }
+      }
+    })
+    await setAccessTokensToServers([ server ])
+
+    await server.users.create({ username: 'user_1', password: 'super_password' })
+
+    userAccessToken = await server.login.getAccessToken({ username: 'user_1', password: 'super_password' })
+
+    {
+      const attributes = { name: 'user_channel', displayName: 'User channel', support: 'super support text' }
+      await server.channels.create({ token: userAccessToken, attributes })
+    }
+
+    cliCommand = server.cli
+  })
+
+  describe('Authentication and instance selection', function () {
+
+    it('Should get an access token', async function () {
+      const stdout = await cliCommand.execWithEnv(`${cmd} token --url ${server.url} --username user_1 --password super_password`)
+      const token = stdout.trim()
+
+      const body = await server.users.getMyInfo({ token })
+      expect(body.username).to.equal('user_1')
+    })
+
+    it('Should display no selected instance', async function () {
+      this.timeout(60000)
+
+      const stdout = await cliCommand.execWithEnv(`${cmd} --help`)
+      expect(stdout).to.contain('no instance selected')
+    })
+
+    it('Should add a user', async function () {
+      this.timeout(60000)
+
+      await cliCommand.execWithEnv(`${cmd} auth add -u ${server.url} -U user_1 -p super_password`)
+    })
+
+    it('Should not fail to add a user if there is a slash at the end of the instance URL', async function () {
+      this.timeout(60000)
+
+      let fullServerURL = server.url + '/'
+
+      await cliCommand.execWithEnv(`${cmd} auth add -u ${fullServerURL} -U user_1 -p super_password`)
+
+      fullServerURL = server.url + '/asdfasdf'
+      await cliCommand.execWithEnv(`${cmd} auth add -u ${fullServerURL} -U user_1 -p super_password`)
+    })
+
+    it('Should default to this user', async function () {
+      this.timeout(60000)
+
+      const stdout = await cliCommand.execWithEnv(`${cmd} --help`)
+      expect(stdout).to.contain(`instance ${server.url} selected`)
+    })
+
+    it('Should remember the user', async function () {
+      this.timeout(60000)
+
+      const stdout = await cliCommand.execWithEnv(`${cmd} auth list`)
+      expect(stdout).to.contain(server.url)
+    })
+  })
+
+  describe('Video upload', function () {
+
+    it('Should upload a video', async function () {
+      this.timeout(60000)
+
+      const fixture = buildAbsoluteFixturePath('60fps_720p_small.mp4')
+      const params = `-f ${fixture} --video-name 'test upload' --channel-name user_channel --support 'support_text'`
+
+      await cliCommand.execWithEnv(`${cmd} upload ${params}`)
+    })
+
+    it('Should have the video uploaded', async function () {
+      const { total, data } = await server.videos.list()
+      expect(total).to.equal(1)
+
+      const video = await server.videos.get({ id: data[0].uuid })
+      expect(video.name).to.equal('test upload')
+      expect(video.support).to.equal('support_text')
+      expect(video.channel.name).to.equal('user_channel')
+    })
+  })
+
+  describe('Admin auth', function () {
+
+    it('Should remove the auth user', async function () {
+      await cliCommand.execWithEnv(`${cmd} auth del ${server.url}`)
+
+      const stdout = await cliCommand.execWithEnv(`${cmd} --help`)
+      expect(stdout).to.contain('no instance selected')
+    })
+
+    it('Should add the admin user', async function () {
+      await cliCommand.execWithEnv(`${cmd} auth add -u ${server.url} -U root -p test${server.internalServerNumber}`)
+    })
+  })
+
+  describe('Manage plugins', function () {
+
+    it('Should install a plugin', async function () {
+      this.timeout(60000)
+
+      await cliCommand.execWithEnv(`${cmd} plugins install --npm-name peertube-plugin-hello-world`)
+    })
+
+    it('Should have registered settings', async function () {
+      await testHelloWorldRegisteredSettings(server)
+    })
+
+    it('Should list installed plugins', async function () {
+      const res = await cliCommand.execWithEnv(`${cmd} plugins list`)
+
+      expect(res).to.contain('peertube-plugin-hello-world')
+    })
+
+    it('Should uninstall the plugin', async function () {
+      const res = await cliCommand.execWithEnv(`${cmd} plugins uninstall --npm-name peertube-plugin-hello-world`)
+
+      expect(res).to.not.contain('peertube-plugin-hello-world')
+    })
+
+    it('Should install a plugin in requested version', async function () {
+      this.timeout(60000)
+
+      await cliCommand.execWithEnv(`${cmd} plugins install --npm-name peertube-plugin-hello-world --plugin-version 0.0.17`)
+    })
+
+    it('Should list installed plugins, in correct version', async function () {
+      const res = await cliCommand.execWithEnv(`${cmd} plugins list`)
+
+      expect(res).to.contain('peertube-plugin-hello-world')
+      expect(res).to.contain('0.0.17')
+    })
+
+    it('Should uninstall the plugin again', async function () {
+      const res = await cliCommand.execWithEnv(`${cmd} plugins uninstall --npm-name peertube-plugin-hello-world`)
+
+      expect(res).to.not.contain('peertube-plugin-hello-world')
+    })
+
+    it('Should install a plugin in requested beta version', async function () {
+      this.timeout(60000)
+
+      await cliCommand.execWithEnv(`${cmd} plugins install --npm-name peertube-plugin-hello-world --plugin-version 0.0.21-beta.1`)
+
+      const res = await cliCommand.execWithEnv(`${cmd} plugins list`)
+
+      expect(res).to.contain('peertube-plugin-hello-world')
+      expect(res).to.contain('0.0.21-beta.1')
+
+      await cliCommand.execWithEnv(`${cmd} plugins uninstall --npm-name peertube-plugin-hello-world`)
+    })
+  })
+
+  describe('Manage video redundancies', function () {
+    let anotherServer: PeerTubeServer
+    let video1Server2: number
+    let servers: PeerTubeServer[]
+
+    before(async function () {
+      this.timeout(120000)
+
+      anotherServer = await createSingleServer(2)
+      await setAccessTokensToServers([ anotherServer ])
+
+      await doubleFollow(server, anotherServer)
+
+      servers = [ server, anotherServer ]
+      await waitJobs(servers)
+
+      const { uuid } = await anotherServer.videos.quickUpload({ name: 'super video' })
+      await waitJobs(servers)
+
+      video1Server2 = await server.videos.getId({ uuid })
+    })
+
+    it('Should add a redundancy', async function () {
+      this.timeout(60000)
+
+      const params = `add --video ${video1Server2}`
+      await cliCommand.execWithEnv(`${cmd} redundancy ${params}`)
+
+      await waitJobs(servers)
+    })
+
+    it('Should list redundancies', async function () {
+      this.timeout(60000)
+
+      {
+        const params = 'list-my-redundancies'
+        const stdout = await cliCommand.execWithEnv(`${cmd} redundancy ${params}`)
+
+        expect(stdout).to.contain('super video')
+        expect(stdout).to.contain(server.host)
+      }
+    })
+
+    it('Should remove a redundancy', async function () {
+      this.timeout(60000)
+
+      const params = `remove --video ${video1Server2}`
+      await cliCommand.execWithEnv(`${cmd} redundancy ${params}`)
+
+      await waitJobs(servers)
+
+      {
+        const params = 'list-my-redundancies'
+        const stdout = await cliCommand.execWithEnv(`${cmd} redundancy ${params}`)
+
+        expect(stdout).to.not.contain('super video')
+      }
+    })
+
+    after(async function () {
+      await cleanupTests([ anotherServer ])
+    })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/cli/plugins.ts b/packages/tests/src/cli/plugins.ts
new file mode 100644
index 000000000..ab7f7dd85
--- /dev/null
+++ b/packages/tests/src/cli/plugins.ts
@@ -0,0 +1,76 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import {
+  cleanupTests,
+  createSingleServer,
+  killallServers,
+  PeerTubeServer,
+  PluginsCommand,
+  setAccessTokensToServers
+} from '@peertube/peertube-server-commands'
+
+describe('Test plugin scripts', function () {
+  let server: PeerTubeServer
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await createSingleServer(1)
+    await setAccessTokensToServers([ server ])
+  })
+
+  it('Should install a plugin from stateless CLI', async function () {
+    this.timeout(60000)
+
+    const packagePath = PluginsCommand.getPluginTestPath()
+
+    await server.cli.execWithEnv(`npm run plugin:install -- --plugin-path ${packagePath}`)
+  })
+
+  it('Should install a theme from stateless CLI', async function () {
+    this.timeout(60000)
+
+    await server.cli.execWithEnv(`npm run plugin:install -- --npm-name peertube-theme-background-red`)
+  })
+
+  it('Should have the theme and the plugin registered when we restart peertube', async function () {
+    this.timeout(30000)
+
+    await killallServers([ server ])
+    await server.run()
+
+    const config = await server.config.getConfig()
+
+    const plugin = config.plugin.registered
+                         .find(p => p.name === 'test')
+    expect(plugin).to.not.be.undefined
+
+    const theme = config.theme.registered
+                        .find(t => t.name === 'background-red')
+    expect(theme).to.not.be.undefined
+  })
+
+  it('Should uninstall a plugin from stateless CLI', async function () {
+    this.timeout(60000)
+
+    await server.cli.execWithEnv(`npm run plugin:uninstall -- --npm-name peertube-plugin-test`)
+  })
+
+  it('Should have removed the plugin on another peertube restart', async function () {
+    this.timeout(30000)
+
+    await killallServers([ server ])
+    await server.run()
+
+    const config = await server.config.getConfig()
+
+    const plugin = config.plugin.registered
+                         .find(p => p.name === 'test')
+    expect(plugin).to.be.undefined
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/cli/prune-storage.ts b/packages/tests/src/cli/prune-storage.ts
new file mode 100644
index 000000000..c07a2a975
--- /dev/null
+++ b/packages/tests/src/cli/prune-storage.ts
@@ -0,0 +1,224 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { createFile } from 'fs-extra/esm'
+import { readdir } from 'fs/promises'
+import { join } from 'path'
+import { wait } from '@peertube/peertube-core-utils'
+import { buildUUID } from '@peertube/peertube-node-utils'
+import { HttpStatusCode, VideoPlaylistPrivacy, VideoPrivacy } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  CLICommand,
+  createMultipleServers,
+  doubleFollow,
+  killallServers,
+  makeGetRequest,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+async function assertNotExists (server: PeerTubeServer, directory: string, substring: string) {
+  const files = await readdir(server.servers.buildDirectory(directory))
+
+  for (const f of files) {
+    expect(f).to.not.contain(substring)
+  }
+}
+
+async function assertCountAreOkay (servers: PeerTubeServer[]) {
+  for (const server of servers) {
+    const videosCount = await server.servers.countFiles('web-videos')
+    expect(videosCount).to.equal(9) // 2 videos with 4 resolutions + private directory
+
+    const privateVideosCount = await server.servers.countFiles('web-videos/private')
+    expect(privateVideosCount).to.equal(4)
+
+    const torrentsCount = await server.servers.countFiles('torrents')
+    expect(torrentsCount).to.equal(24)
+
+    const previewsCount = await server.servers.countFiles('previews')
+    expect(previewsCount).to.equal(3)
+
+    const thumbnailsCount = await server.servers.countFiles('thumbnails')
+    expect(thumbnailsCount).to.equal(5) // 3 local videos, 1 local playlist, 2 remotes videos (lazy downloaded) and 1 remote playlist
+
+    const avatarsCount = await server.servers.countFiles('avatars')
+    expect(avatarsCount).to.equal(4)
+
+    const hlsRootCount = await server.servers.countFiles(join('streaming-playlists', 'hls'))
+    expect(hlsRootCount).to.equal(3) // 2 videos + private directory
+
+    const hlsPrivateRootCount = await server.servers.countFiles(join('streaming-playlists', 'hls', 'private'))
+    expect(hlsPrivateRootCount).to.equal(1)
+  }
+}
+
+describe('Test prune storage scripts', function () {
+  let servers: PeerTubeServer[]
+  const badNames: { [directory: string]: string[] } = {}
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(2, { transcoding: { enabled: true } })
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    for (const server of servers) {
+      await server.videos.upload({ attributes: { name: 'video 1', privacy: VideoPrivacy.PUBLIC } })
+      await server.videos.upload({ attributes: { name: 'video 2', privacy: VideoPrivacy.PUBLIC } })
+
+      await server.videos.upload({ attributes: { name: 'video 3', privacy: VideoPrivacy.PRIVATE } })
+
+      await server.users.updateMyAvatar({ fixture: 'avatar.png' })
+
+      await server.playlists.create({
+        attributes: {
+          displayName: 'playlist',
+          privacy: VideoPlaylistPrivacy.PUBLIC,
+          videoChannelId: server.store.channel.id,
+          thumbnailfile: 'custom-thumbnail.jpg'
+        }
+      })
+    }
+
+    await doubleFollow(servers[0], servers[1])
+
+    // Lazy load the remote avatars
+    {
+      const account = await servers[0].accounts.get({ accountName: 'root@' + servers[1].host })
+
+      for (const avatar of account.avatars) {
+        await makeGetRequest({
+          url: servers[0].url,
+          path: avatar.path,
+          expectedStatus: HttpStatusCode.OK_200
+        })
+      }
+    }
+
+    {
+      const account = await servers[1].accounts.get({ accountName: 'root@' + servers[0].host })
+      for (const avatar of account.avatars) {
+        await makeGetRequest({
+          url: servers[1].url,
+          path: avatar.path,
+          expectedStatus: HttpStatusCode.OK_200
+        })
+      }
+    }
+
+    await wait(1000)
+
+    await waitJobs(servers)
+    await killallServers(servers)
+
+    await wait(1000)
+  })
+
+  it('Should have the files on the disk', async function () {
+    await assertCountAreOkay(servers)
+  })
+
+  it('Should create some dirty files', async function () {
+    for (let i = 0; i < 2; i++) {
+      {
+        const basePublic = servers[0].servers.buildDirectory('web-videos')
+        const basePrivate = servers[0].servers.buildDirectory(join('web-videos', 'private'))
+
+        const n1 = buildUUID() + '.mp4'
+        const n2 = buildUUID() + '.webm'
+
+        await createFile(join(basePublic, n1))
+        await createFile(join(basePublic, n2))
+        await createFile(join(basePrivate, n1))
+        await createFile(join(basePrivate, n2))
+
+        badNames['web-videos'] = [ n1, n2 ]
+      }
+
+      {
+        const base = servers[0].servers.buildDirectory('torrents')
+
+        const n1 = buildUUID() + '-240.torrent'
+        const n2 = buildUUID() + '-480.torrent'
+
+        await createFile(join(base, n1))
+        await createFile(join(base, n2))
+
+        badNames['torrents'] = [ n1, n2 ]
+      }
+
+      {
+        const base = servers[0].servers.buildDirectory('thumbnails')
+
+        const n1 = buildUUID() + '.jpg'
+        const n2 = buildUUID() + '.jpg'
+
+        await createFile(join(base, n1))
+        await createFile(join(base, n2))
+
+        badNames['thumbnails'] = [ n1, n2 ]
+      }
+
+      {
+        const base = servers[0].servers.buildDirectory('previews')
+
+        const n1 = buildUUID() + '.jpg'
+        const n2 = buildUUID() + '.jpg'
+
+        await createFile(join(base, n1))
+        await createFile(join(base, n2))
+
+        badNames['previews'] = [ n1, n2 ]
+      }
+
+      {
+        const base = servers[0].servers.buildDirectory('avatars')
+
+        const n1 = buildUUID() + '.png'
+        const n2 = buildUUID() + '.jpg'
+
+        await createFile(join(base, n1))
+        await createFile(join(base, n2))
+
+        badNames['avatars'] = [ n1, n2 ]
+      }
+
+      {
+        const directory = join('streaming-playlists', 'hls')
+        const basePublic = servers[0].servers.buildDirectory(directory)
+        const basePrivate = servers[0].servers.buildDirectory(join(directory, 'private'))
+
+        const n1 = buildUUID()
+        await createFile(join(basePublic, n1))
+        await createFile(join(basePrivate, n1))
+        badNames[directory] = [ n1 ]
+      }
+    }
+  })
+
+  it('Should run prune storage', async function () {
+    this.timeout(30000)
+
+    const env = servers[0].cli.getEnv()
+    await CLICommand.exec(`echo y | ${env} npm run prune-storage`)
+  })
+
+  it('Should have removed files', async function () {
+    await assertCountAreOkay(servers)
+
+    for (const directory of Object.keys(badNames)) {
+      for (const name of badNames[directory]) {
+        await assertNotExists(servers[0], directory, name)
+      }
+    }
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/cli/regenerate-thumbnails.ts b/packages/tests/src/cli/regenerate-thumbnails.ts
new file mode 100644
index 000000000..1448e5cfc
--- /dev/null
+++ b/packages/tests/src/cli/regenerate-thumbnails.ts
@@ -0,0 +1,122 @@
+import { expect } from 'chai'
+import { writeFile } from 'fs/promises'
+import { basename, join } from 'path'
+import { HttpStatusCode, Video } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  makeGetRequest,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+async function testThumbnail (server: PeerTubeServer, videoId: number | string) {
+  const video = await server.videos.get({ id: videoId })
+
+  const requests = [
+    makeGetRequest({ url: server.url, path: video.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 }),
+    makeGetRequest({ url: server.url, path: video.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
+  ]
+
+  for (const req of requests) {
+    const res = await req
+    expect(res.body).to.not.have.lengthOf(0)
+  }
+}
+
+describe('Test regenerate thumbnails script', function () {
+  let servers: PeerTubeServer[]
+
+  let video1: Video
+  let video2: Video
+  let remoteVideo: Video
+
+  let thumbnail1Path: string
+  let thumbnailRemotePath: string
+
+  before(async function () {
+    this.timeout(60000)
+
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+
+    await doubleFollow(servers[0], servers[1])
+
+    {
+      const videoUUID1 = (await servers[0].videos.quickUpload({ name: 'video 1' })).uuid
+      video1 = await servers[0].videos.get({ id: videoUUID1 })
+
+      thumbnail1Path = join(servers[0].servers.buildDirectory('thumbnails'), basename(video1.thumbnailPath))
+
+      const videoUUID2 = (await servers[0].videos.quickUpload({ name: 'video 2' })).uuid
+      video2 = await servers[0].videos.get({ id: videoUUID2 })
+    }
+
+    {
+      const videoUUID = (await servers[1].videos.quickUpload({ name: 'video 3' })).uuid
+      await waitJobs(servers)
+
+      remoteVideo = await servers[0].videos.get({ id: videoUUID })
+
+      // Load remote thumbnail on disk
+      await makeGetRequest({ url: servers[0].url, path: remoteVideo.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
+
+      thumbnailRemotePath = join(servers[0].servers.buildDirectory('thumbnails'), basename(remoteVideo.thumbnailPath))
+    }
+
+    await writeFile(thumbnail1Path, '')
+    await writeFile(thumbnailRemotePath, '')
+  })
+
+  it('Should have empty thumbnails', async function () {
+    {
+      const res = await makeGetRequest({ url: servers[0].url, path: video1.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
+      expect(res.body).to.have.lengthOf(0)
+    }
+
+    {
+      const res = await makeGetRequest({ url: servers[0].url, path: video2.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
+      expect(res.body).to.not.have.lengthOf(0)
+    }
+
+    {
+      const res = await makeGetRequest({ url: servers[0].url, path: remoteVideo.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
+      expect(res.body).to.have.lengthOf(0)
+    }
+  })
+
+  it('Should regenerate local thumbnails from the CLI', async function () {
+    this.timeout(15000)
+
+    await servers[0].cli.execWithEnv(`npm run regenerate-thumbnails`)
+  })
+
+  it('Should have generated new thumbnail files', async function () {
+    await testThumbnail(servers[0], video1.uuid)
+    await testThumbnail(servers[0], video2.uuid)
+
+    const res = await makeGetRequest({ url: servers[0].url, path: remoteVideo.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
+    expect(res.body).to.have.lengthOf(0)
+  })
+
+  it('Should have deleted old thumbnail files', async function () {
+    {
+      await makeGetRequest({ url: servers[0].url, path: video1.thumbnailPath, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+    }
+
+    {
+      await makeGetRequest({ url: servers[0].url, path: video2.thumbnailPath, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+    }
+
+    {
+      const res = await makeGetRequest({ url: servers[0].url, path: remoteVideo.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
+      expect(res.body).to.have.lengthOf(0)
+    }
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/cli/reset-password.ts b/packages/tests/src/cli/reset-password.ts
new file mode 100644
index 000000000..62e1a37a0
--- /dev/null
+++ b/packages/tests/src/cli/reset-password.ts
@@ -0,0 +1,26 @@
+import { cleanupTests, CLICommand, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '@peertube/peertube-server-commands'
+
+describe('Test reset password scripts', function () {
+  let server: PeerTubeServer
+
+  before(async function () {
+    this.timeout(30000)
+    server = await createSingleServer(1)
+    await setAccessTokensToServers([ server ])
+
+    await server.users.create({ username: 'user_1', password: 'super password' })
+  })
+
+  it('Should change the user password from CLI', async function () {
+    this.timeout(60000)
+
+    const env = server.cli.getEnv()
+    await CLICommand.exec(`echo coucou | ${env} npm run reset-password -- -u user_1`)
+
+    await server.login.login({ user: { username: 'user_1', password: 'coucou' } })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/cli/update-host.ts b/packages/tests/src/cli/update-host.ts
new file mode 100644
index 000000000..e5f165e5e
--- /dev/null
+++ b/packages/tests/src/cli/update-host.ts
@@ -0,0 +1,134 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { getAllFiles } from '@peertube/peertube-core-utils'
+import {
+  cleanupTests,
+  createSingleServer,
+  killallServers,
+  makeActivityPubGetRequest,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+import { parseTorrentVideo } from '@tests/shared/webtorrent.js'
+
+describe('Test update host scripts', function () {
+  let server: PeerTubeServer
+
+  before(async function () {
+    this.timeout(60000)
+
+    const overrideConfig = {
+      webserver: {
+        port: 9256
+      }
+    }
+    // Run server 2 to have transcoding enabled
+    server = await createSingleServer(2, overrideConfig)
+    await setAccessTokensToServers([ server ])
+
+    // Upload two videos for our needs
+    const { uuid: video1UUID } = await server.videos.upload()
+    await server.videos.upload()
+
+    // Create a user
+    await server.users.create({ username: 'toto', password: 'coucou' })
+
+    // Create channel
+    const videoChannel = {
+      name: 'second_channel',
+      displayName: 'second video channel',
+      description: 'super video channel description'
+    }
+    await server.channels.create({ attributes: videoChannel })
+
+    // Create comments
+    const text = 'my super first comment'
+    await server.comments.createThread({ videoId: video1UUID, text })
+
+    await waitJobs(server)
+  })
+
+  it('Should run update host', async function () {
+    this.timeout(30000)
+
+    await killallServers([ server ])
+    // Run server with standard configuration
+    await server.run()
+
+    await server.cli.execWithEnv(`npm run update-host`)
+  })
+
+  it('Should have updated videos url', async function () {
+    const { total, data } = await server.videos.list()
+    expect(total).to.equal(2)
+
+    for (const video of data) {
+      const { body } = await makeActivityPubGetRequest(server.url, '/videos/watch/' + video.uuid)
+
+      expect(body.id).to.equal('http://127.0.0.1:9002/videos/watch/' + video.uuid)
+
+      const videoDetails = await server.videos.get({ id: video.uuid })
+
+      expect(videoDetails.trackerUrls[0]).to.include(server.host)
+      expect(videoDetails.streamingPlaylists[0].playlistUrl).to.include(server.host)
+      expect(videoDetails.streamingPlaylists[0].segmentsSha256Url).to.include(server.host)
+    }
+  })
+
+  it('Should have updated video channels url', async function () {
+    const { data, total } = await server.channels.list({ sort: '-name' })
+    expect(total).to.equal(3)
+
+    for (const channel of data) {
+      const { body } = await makeActivityPubGetRequest(server.url, '/video-channels/' + channel.name)
+
+      expect(body.id).to.equal('http://127.0.0.1:9002/video-channels/' + channel.name)
+    }
+  })
+
+  it('Should have updated accounts url', async function () {
+    const body = await server.accounts.list()
+    expect(body.total).to.equal(3)
+
+    for (const account of body.data) {
+      const usernameWithDomain = account.name
+      const { body } = await makeActivityPubGetRequest(server.url, '/accounts/' + usernameWithDomain)
+
+      expect(body.id).to.equal('http://127.0.0.1:9002/accounts/' + usernameWithDomain)
+    }
+  })
+
+  it('Should have updated torrent hosts', async function () {
+    this.timeout(30000)
+
+    const { data } = await server.videos.list()
+    expect(data).to.have.lengthOf(2)
+
+    for (const video of data) {
+      const videoDetails = await server.videos.get({ id: video.id })
+      const files = getAllFiles(videoDetails)
+
+      expect(files).to.have.lengthOf(8)
+
+      for (const file of files) {
+        expect(file.magnetUri).to.contain('127.0.0.1%3A9002%2Ftracker%2Fsocket')
+        expect(file.magnetUri).to.contain('127.0.0.1%3A9002%2Fstatic%2F')
+
+        const torrent = await parseTorrentVideo(server, file)
+        const announceWS = torrent.announce.find(a => a === 'ws://127.0.0.1:9002/tracker/socket')
+        expect(announceWS).to.not.be.undefined
+
+        const announceHttp = torrent.announce.find(a => a === 'http://127.0.0.1:9002/tracker/announce')
+        expect(announceHttp).to.not.be.undefined
+
+        expect(torrent.urlList[0]).to.contain('http://127.0.0.1:9002/static/')
+      }
+    }
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})