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)

14 files changed, 1326 insertions, 0 deletions

diff --git a/server/scripts/create-generate-storyboard-job.ts b/server/scripts/create-generate-storyboard-job.ts
new file mode 100644
index 000000000..1f70e4d15
--- /dev/null
+++ b/server/scripts/create-generate-storyboard-job.ts
@@ -0,0 +1,85 @@
+import { program } from 'commander'
+import { toCompleteUUID } from '@server/helpers/custom-validators/misc.js'
+import { initDatabaseModels } from '@server/initializers/database.js'
+import { JobQueue } from '@server/lib/job-queue/index.js'
+import { StoryboardModel } from '@server/models/video/storyboard.js'
+import { VideoModel } from '@server/models/video/video.js'
+
+program
+  .description('Generate videos storyboard')
+  .option('-v, --video [videoUUID]', 'Generate the storyboard of a specific video')
+  .option('-a, --all-videos', 'Generate missing storyboards of local videos')
+  .parse(process.argv)
+
+const options = program.opts()
+
+if (!options['video'] && !options['allVideos']) {
+  console.error('You need to choose videos for storyboard generation.')
+  process.exit(-1)
+}
+
+run()
+  .then(() => process.exit(0))
+  .catch(err => {
+    console.error(err)
+    process.exit(-1)
+  })
+
+async function run () {
+  await initDatabaseModels(true)
+
+  JobQueue.Instance.init()
+
+  let ids: number[] = []
+
+  if (options['video']) {
+    const video = await VideoModel.load(toCompleteUUID(options['video']))
+
+    if (!video) {
+      console.error('Unknown video ' + options['video'])
+      process.exit(-1)
+    }
+
+    if (video.remote === true) {
+      console.error('Cannot process a remote video')
+      process.exit(-1)
+    }
+
+    if (video.isLive) {
+      console.error('Cannot process live video')
+      process.exit(-1)
+    }
+
+    ids.push(video.id)
+  } else {
+    ids = await listLocalMissingStoryboards()
+  }
+
+  for (const id of ids) {
+    const videoFull = await VideoModel.load(id)
+
+    if (videoFull.isLive) continue
+
+    await JobQueue.Instance.createJob({
+      type: 'generate-video-storyboard',
+      payload: {
+        videoUUID: videoFull.uuid,
+        federate: true
+      }
+    })
+
+    console.log(`Created generate-storyboard job for ${videoFull.name}.`)
+  }
+}
+
+async function listLocalMissingStoryboards () {
+  const ids = await VideoModel.listLocalIds()
+  const results: number[] = []
+
+  for (const id of ids) {
+    const storyboard = await StoryboardModel.loadByVideo(id)
+    if (!storyboard) results.push(id)
+  }
+
+  return results
+}
diff --git a/server/scripts/create-import-video-file-job.ts b/server/scripts/create-import-video-file-job.ts
new file mode 100644
index 000000000..33a45fba1
--- /dev/null
+++ b/server/scripts/create-import-video-file-job.ts
@@ -0,0 +1,50 @@
+import { program } from 'commander'
+import { resolve } from 'path'
+import { isUUIDValid, toCompleteUUID } from '@server/helpers/custom-validators/misc.js'
+import { initDatabaseModels } from '../server/initializers/database.js'
+import { JobQueue } from '../server/lib/job-queue/index.js'
+import { VideoModel } from '../server/models/video/video.js'
+
+program
+  .option('-v, --video [videoUUID]', 'Video UUID')
+  .option('-i, --import [videoFile]', 'Video file')
+  .description('Import a video file to replace an already uploaded file or to add a new resolution')
+  .parse(process.argv)
+
+const options = program.opts()
+
+if (options.video === undefined || options.import === undefined) {
+  console.error('All parameters are mandatory.')
+  process.exit(-1)
+}
+
+run()
+  .then(() => process.exit(0))
+  .catch(err => {
+    console.error(err)
+    process.exit(-1)
+  })
+
+async function run () {
+  await initDatabaseModels(true)
+
+  const uuid = toCompleteUUID(options.video)
+
+  if (isUUIDValid(uuid) === false) {
+    console.error('%s is not a valid video UUID.', options.video)
+    return
+  }
+
+  const video = await VideoModel.load(uuid)
+  if (!video) throw new Error('Video not found.')
+  if (video.isOwned() === false) throw new Error('Cannot import files of a non owned video.')
+
+  const dataInput = {
+    videoUUID: video.uuid,
+    filePath: resolve(options.import)
+  }
+
+  JobQueue.Instance.init()
+  await JobQueue.Instance.createJob({ type: 'video-file-import', payload: dataInput })
+  console.log('Import job for video %s created.', video.uuid)
+}
diff --git a/server/scripts/create-move-video-storage-job.ts b/server/scripts/create-move-video-storage-job.ts
new file mode 100644
index 000000000..a615d1f44
--- /dev/null
+++ b/server/scripts/create-move-video-storage-job.ts
@@ -0,0 +1,99 @@
+import { program } from 'commander'
+import { toCompleteUUID } from '@server/helpers/custom-validators/misc.js'
+import { CONFIG } from '@server/initializers/config.js'
+import { initDatabaseModels } from '@server/initializers/database.js'
+import { JobQueue } from '@server/lib/job-queue/index.js'
+import { moveToExternalStorageState } from '@server/lib/video-state.js'
+import { VideoModel } from '@server/models/video/video.js'
+import { VideoState, VideoStorage } from '@peertube/peertube-models'
+
+program
+  .description('Move videos to another storage.')
+  .option('-o, --to-object-storage', 'Move videos in object storage')
+  .option('-v, --video [videoUUID]', 'Move a specific video')
+  .option('-a, --all-videos', 'Migrate all videos')
+  .parse(process.argv)
+
+const options = program.opts()
+
+if (!options['toObjectStorage']) {
+  console.error('You need to choose where to send video files.')
+  process.exit(-1)
+}
+
+if (!options['video'] && !options['allVideos']) {
+  console.error('You need to choose which videos to move.')
+  process.exit(-1)
+}
+
+if (options['toObjectStorage'] && !CONFIG.OBJECT_STORAGE.ENABLED) {
+  console.error('Object storage is not enabled on this instance.')
+  process.exit(-1)
+}
+
+run()
+  .then(() => process.exit(0))
+  .catch(err => {
+    console.error(err)
+    process.exit(-1)
+  })
+
+async function run () {
+  await initDatabaseModels(true)
+
+  JobQueue.Instance.init()
+
+  let ids: number[] = []
+
+  if (options['video']) {
+    const video = await VideoModel.load(toCompleteUUID(options['video']))
+
+    if (!video) {
+      console.error('Unknown video ' + options['video'])
+      process.exit(-1)
+    }
+
+    if (video.remote === true) {
+      console.error('Cannot process a remote video')
+      process.exit(-1)
+    }
+
+    if (video.isLive) {
+      console.error('Cannot process live video')
+      process.exit(-1)
+    }
+
+    if (video.state === VideoState.TO_MOVE_TO_EXTERNAL_STORAGE) {
+      console.error('This video is already being moved to external storage')
+      process.exit(-1)
+    }
+
+    ids.push(video.id)
+  } else {
+    ids = await VideoModel.listLocalIds()
+  }
+
+  for (const id of ids) {
+    const videoFull = await VideoModel.loadFull(id)
+
+    if (videoFull.isLive) continue
+
+    const files = videoFull.VideoFiles || []
+    const hls = videoFull.getHLSPlaylist()
+
+    if (files.some(f => f.storage === VideoStorage.FILE_SYSTEM) || hls?.storage === VideoStorage.FILE_SYSTEM) {
+      console.log('Processing video %s.', videoFull.name)
+
+      const success = await moveToExternalStorageState({ video: videoFull, isNewVideo: false, transaction: undefined })
+
+      if (!success) {
+        console.error(
+          'Cannot create move job for %s: job creation may have failed or there may be pending transcoding jobs for this video',
+          videoFull.name
+        )
+      }
+    }
+
+    console.log(`Created move-to-object-storage job for ${videoFull.name}.`)
+  }
+}
diff --git a/server/scripts/migrations/peertube-4.0.ts b/server/scripts/migrations/peertube-4.0.ts
new file mode 100644
index 000000000..619c1da71
--- /dev/null
+++ b/server/scripts/migrations/peertube-4.0.ts
@@ -0,0 +1,110 @@
+import Bluebird from 'bluebird'
+import { move } from 'fs-extra/esm'
+import { readFile, writeFile } from 'fs/promises'
+import { join } from 'path'
+import { initDatabaseModels } from '@server/initializers/database.js'
+import { federateVideoIfNeeded } from '@server/lib/activitypub/videos/index.js'
+import { JobQueue } from '@server/lib/job-queue/index.js'
+import {
+  generateHLSMasterPlaylistFilename,
+  generateHlsSha256SegmentsFilename,
+  getHlsResolutionPlaylistFilename
+} from '@server/lib/paths.js'
+import { VideoPathManager } from '@server/lib/video-path-manager.js'
+import { VideoStreamingPlaylistModel } from '@server/models/video/video-streaming-playlist.js'
+import { VideoModel } from '@server/models/video/video.js'
+
+run()
+  .then(() => process.exit(0))
+  .catch(err => {
+    console.error(err)
+    process.exit(-1)
+
+  })
+
+async function run () {
+  console.log('Migrate old HLS paths to new format.')
+
+  await initDatabaseModels(true)
+
+  JobQueue.Instance.init()
+
+  const ids = await VideoModel.listLocalIds()
+
+  await Bluebird.map(ids, async id => {
+    try {
+      await processVideo(id)
+    } catch (err) {
+      console.error('Cannot process video %s.', { err })
+    }
+  }, { concurrency: 5 })
+
+  console.log('Migration finished!')
+}
+
+async function processVideo (videoId: number) {
+  const video = await VideoModel.loadWithFiles(videoId)
+
+  const hls = video.getHLSPlaylist()
+  if (video.isLive || !hls || hls.playlistFilename !== 'master.m3u8' || hls.VideoFiles.length === 0) {
+    return
+  }
+
+  console.log(`Renaming HLS playlist files of video ${video.name}.`)
+
+  const playlist = await VideoStreamingPlaylistModel.loadHLSPlaylistByVideo(video.id)
+  const hlsDirPath = VideoPathManager.Instance.getFSHLSOutputPath(video)
+
+  const masterPlaylistPath = join(hlsDirPath, playlist.playlistFilename)
+  let masterPlaylistContent = await readFile(masterPlaylistPath, 'utf8')
+
+  for (const videoFile of hls.VideoFiles) {
+    const srcName = `${videoFile.resolution}.m3u8`
+    const dstName = getHlsResolutionPlaylistFilename(videoFile.filename)
+
+    const src = join(hlsDirPath, srcName)
+    const dst = join(hlsDirPath, dstName)
+
+    try {
+      await move(src, dst)
+
+      masterPlaylistContent = masterPlaylistContent.replace(new RegExp('^' + srcName + '$', 'm'), dstName)
+    } catch (err) {
+      console.error('Cannot move video file %s to %s.', src, dst, err)
+    }
+  }
+
+  await writeFile(masterPlaylistPath, masterPlaylistContent)
+
+  if (playlist.segmentsSha256Filename === 'segments-sha256.json') {
+    try {
+      const newName = generateHlsSha256SegmentsFilename(video.isLive)
+
+      const dst = join(hlsDirPath, newName)
+      await move(join(hlsDirPath, playlist.segmentsSha256Filename), dst)
+      playlist.segmentsSha256Filename = newName
+    } catch (err) {
+      console.error(`Cannot rename ${video.name} segments-sha256.json file to a new name`, err)
+    }
+  }
+
+  if (playlist.playlistFilename === 'master.m3u8') {
+    try {
+      const newName = generateHLSMasterPlaylistFilename(video.isLive)
+
+      const dst = join(hlsDirPath, newName)
+      await move(join(hlsDirPath, playlist.playlistFilename), dst)
+      playlist.playlistFilename = newName
+    } catch (err) {
+      console.error(`Cannot rename ${video.name} master.m3u8 file to a new name`, err)
+    }
+  }
+
+  // Everything worked, we can save the playlist now
+  await playlist.save()
+
+  const allVideo = await VideoModel.loadFull(video.id)
+  await federateVideoIfNeeded(allVideo, false)
+
+  console.log(`Successfully moved HLS files of ${video.name}.`)
+}
diff --git a/server/scripts/migrations/peertube-4.2.ts b/server/scripts/migrations/peertube-4.2.ts
new file mode 100644
index 000000000..6c89ee39e
--- /dev/null
+++ b/server/scripts/migrations/peertube-4.2.ts
@@ -0,0 +1,123 @@
+import { ActorImageType } from '@peertube/peertube-models'
+import { buildUUID, getLowercaseExtension } from '@peertube/peertube-node-utils'
+import { getImageSize, processImage } from '@server/helpers/image-utils.js'
+import { CONFIG } from '@server/initializers/config.js'
+import { ACTOR_IMAGES_SIZE } from '@server/initializers/constants.js'
+import { initDatabaseModels } from '@server/initializers/database.js'
+import { updateActorImages } from '@server/lib/activitypub/actors/index.js'
+import { sendUpdateActor } from '@server/lib/activitypub/send/index.js'
+import { getBiggestActorImage } from '@server/lib/actor-image.js'
+import { JobQueue } from '@server/lib/job-queue/index.js'
+import { AccountModel } from '@server/models/account/account.js'
+import { ActorModel } from '@server/models/actor/actor.js'
+import { VideoChannelModel } from '@server/models/video/video-channel.js'
+import { MAccountDefault, MActorDefault, MChannelDefault } from '@server/types/models/index.js'
+import minBy from 'lodash-es/minBy.js'
+import { join } from 'path'
+
+run()
+  .then(() => process.exit(0))
+  .catch(err => {
+    console.error(err)
+    process.exit(-1)
+  })
+
+async function run () {
+  console.log('Generate avatar miniatures from existing avatars.')
+
+  await initDatabaseModels(true)
+  JobQueue.Instance.init()
+
+  const accounts: AccountModel[] = await AccountModel.findAll({
+    include: [
+      {
+        model: ActorModel,
+        required: true,
+        where: {
+          serverId: null
+        }
+      },
+      {
+        model: VideoChannelModel,
+        include: [
+          {
+            model: AccountModel
+          }
+        ]
+      }
+    ]
+  })
+
+  for (const account of accounts) {
+    try {
+      await fillAvatarSizeIfNeeded(account)
+      await generateSmallerAvatarIfNeeded(account)
+    } catch (err) {
+      console.error(`Cannot process account avatar ${account.name}`, err)
+    }
+
+    for (const videoChannel of account.VideoChannels) {
+      try {
+        await fillAvatarSizeIfNeeded(videoChannel)
+        await generateSmallerAvatarIfNeeded(videoChannel)
+      } catch (err) {
+        console.error(`Cannot process channel avatar ${videoChannel.name}`, err)
+      }
+    }
+  }
+
+  console.log('Generation finished!')
+}
+
+async function fillAvatarSizeIfNeeded (accountOrChannel: MAccountDefault | MChannelDefault) {
+  const avatars = accountOrChannel.Actor.Avatars
+
+  for (const avatar of avatars) {
+    if (avatar.width && avatar.height) continue
+
+    console.log('Filling size of avatars of %s.', accountOrChannel.name)
+
+    const { width, height } = await getImageSize(join(CONFIG.STORAGE.ACTOR_IMAGES_DIR, avatar.filename))
+    avatar.width = width
+    avatar.height = height
+
+    await avatar.save()
+  }
+}
+
+async function generateSmallerAvatarIfNeeded (accountOrChannel: MAccountDefault | MChannelDefault) {
+  const avatars = accountOrChannel.Actor.Avatars
+  if (avatars.length !== 1) {
+    return
+  }
+
+  console.log(`Processing ${accountOrChannel.name}.`)
+
+  await generateSmallerAvatar(accountOrChannel.Actor)
+  accountOrChannel.Actor = Object.assign(accountOrChannel.Actor, { Server: null })
+
+  return sendUpdateActor(accountOrChannel, undefined)
+}
+
+async function generateSmallerAvatar (actor: MActorDefault) {
+  const bigAvatar = getBiggestActorImage(actor.Avatars)
+
+  const imageSize = minBy(ACTOR_IMAGES_SIZE[ActorImageType.AVATAR], 'width')
+  const sourceFilename = bigAvatar.filename
+
+  const newImageName = buildUUID() + getLowercaseExtension(sourceFilename)
+  const source = join(CONFIG.STORAGE.ACTOR_IMAGES_DIR, sourceFilename)
+  const destination = join(CONFIG.STORAGE.ACTOR_IMAGES_DIR, newImageName)
+
+  await processImage({ path: source, destination, newSize: imageSize, keepOriginal: true })
+
+  const actorImageInfo = {
+    name: newImageName,
+    fileUrl: null,
+    height: imageSize.height,
+    width: imageSize.width,
+    onDisk: true
+  }
+
+  await updateActorImages(actor, ActorImageType.AVATAR, [ actorImageInfo ], undefined)
+}
diff --git a/server/scripts/migrations/peertube-5.0.ts b/server/scripts/migrations/peertube-5.0.ts
new file mode 100644
index 000000000..6139abd08
--- /dev/null
+++ b/server/scripts/migrations/peertube-5.0.ts
@@ -0,0 +1,71 @@
+import { ensureDir } from 'fs-extra/esm'
+import { Op } from 'sequelize'
+import { updateTorrentMetadata } from '@server/helpers/webtorrent.js'
+import { DIRECTORIES } from '@server/initializers/constants.js'
+import { moveFilesIfPrivacyChanged } from '@server/lib/video-privacy.js'
+import { VideoModel } from '@server/models/video/video.js'
+import { MVideoFullLight } from '@server/types/models/index.js'
+import { VideoPrivacy } from '@peertube/peertube-models'
+import { initDatabaseModels } from '@server/initializers/database.js'
+
+run()
+  .then(() => process.exit(0))
+  .catch(err => {
+    console.error(err)
+    process.exit(-1)
+  })
+
+async function run () {
+  console.log('Moving private video files in dedicated folders.')
+
+  await ensureDir(DIRECTORIES.HLS_STREAMING_PLAYLIST.PRIVATE)
+  await ensureDir(DIRECTORIES.VIDEOS.PRIVATE)
+
+  await initDatabaseModels(true)
+
+  const videos = await VideoModel.unscoped().findAll({
+    attributes: [ 'uuid' ],
+    where: {
+      privacy: {
+        [Op.in]: [ VideoPrivacy.PRIVATE, VideoPrivacy.INTERNAL ]
+      }
+    }
+  })
+
+  for (const { uuid } of videos) {
+    try {
+      console.log('Moving files of video %s.', uuid)
+
+      const video = await VideoModel.loadFull(uuid)
+
+      try {
+        await moveFilesIfPrivacyChanged(video, VideoPrivacy.PUBLIC)
+      } catch (err) {
+        console.error('Cannot move files of video %s.', uuid, err)
+      }
+
+      try {
+        await updateTorrents(video)
+      } catch (err) {
+        console.error('Cannot regenerate torrents of video %s.', uuid, err)
+      }
+    } catch (err) {
+      console.error('Cannot process video %s.', uuid, err)
+    }
+  }
+}
+
+async function updateTorrents (video: MVideoFullLight) {
+  for (const file of video.VideoFiles) {
+    await updateTorrentMetadata(video, file)
+
+    await file.save()
+  }
+
+  const playlist = video.getHLSPlaylist()
+  for (const file of (playlist?.VideoFiles || [])) {
+    await updateTorrentMetadata(playlist, file)
+
+    await file.save()
+  }
+}
diff --git a/server/scripts/parse-log.ts b/server/scripts/parse-log.ts
new file mode 100755
index 000000000..e80c0d927
--- /dev/null
+++ b/server/scripts/parse-log.ts
@@ -0,0 +1,161 @@
+import { program } from 'commander'
+import { createReadStream } from 'fs'
+import { readdir } from 'fs/promises'
+import { join } from 'path'
+import { stdin } from 'process'
+import { createInterface } from 'readline'
+import { format as sqlFormat } from 'sql-formatter'
+import { inspect } from 'util'
+import * as winston from 'winston'
+import { labelFormatter, mtimeSortFilesDesc } from '@server/helpers/logger.js'
+import { CONFIG } from '@server/initializers/config.js'
+
+program
+  .option('-l, --level [level]', 'Level log (debug/info/warn/error)')
+  .option('-f, --files [file...]', 'Files to parse. If not provided, the script will parse the latest log file from config)')
+  .option('-t, --tags [tags...]', 'Display only lines with these tags')
+  .option('-nt, --not-tags [tags...]', 'Donrt display lines containing these tags')
+  .parse(process.argv)
+
+const options = program.opts()
+
+const excludedKeys = {
+  level: true,
+  message: true,
+  splat: true,
+  timestamp: true,
+  tags: true,
+  label: true,
+  sql: true
+}
+function keysExcluder (key, value) {
+  return excludedKeys[key] === true ? undefined : value
+}
+
+const loggerFormat = winston.format.printf((info) => {
+  let additionalInfos = JSON.stringify(info, keysExcluder, 2)
+  if (additionalInfos === '{}') additionalInfos = ''
+  else additionalInfos = ' ' + additionalInfos
+
+  if (info.sql) {
+    if (CONFIG.LOG.PRETTIFY_SQL) {
+      additionalInfos += '\n' + sqlFormat(info.sql, {
+        language: 'sql',
+        tabWidth: 2
+      })
+    } else {
+      additionalInfos += ' - ' + info.sql
+    }
+  }
+
+  return `[${info.label}] ${toTimeFormat(info.timestamp)} ${info.level}: ${info.message}${additionalInfos}`
+})
+
+const logger = winston.createLogger({
+  transports: [
+    new winston.transports.Console({
+      level: options.level || 'debug',
+      stderrLevels: [],
+      format: winston.format.combine(
+        winston.format.splat(),
+        labelFormatter(),
+        winston.format.colorize(),
+        loggerFormat
+      )
+    })
+  ],
+  exitOnError: true
+})
+
+const logLevels = {
+  error: logger.error.bind(logger),
+  warn: logger.warn.bind(logger),
+  info: logger.info.bind(logger),
+  debug: logger.debug.bind(logger)
+}
+
+run()
+  .then(() => process.exit(0))
+  .catch(err => console.error(err))
+
+async function run () {
+  const files = await getFiles()
+
+  for (const file of files) {
+    if (file === 'peertube-audit.log') continue
+
+    await readFile(file)
+  }
+}
+
+function readFile (file: string) {
+  console.log('Opening %s.', file)
+
+  const stream = file === '-' ? stdin : createReadStream(file)
+
+  const rl = createInterface({
+    input: stream
+  })
+
+  return new Promise<void>(res => {
+    rl.on('line', line => {
+      try {
+        const log = JSON.parse(line)
+        if (options.tags && !containsTags(log.tags, options.tags)) {
+          return
+        }
+
+        if (options.notTags && containsTags(log.tags, options.notTags)) {
+          return
+        }
+
+        // Don't know why but loggerFormat does not remove splat key
+        Object.assign(log, { splat: undefined })
+
+        logLevels[log.level](log)
+      } catch (err) {
+        console.error('Cannot parse line.', inspect(line))
+        throw err
+      }
+    })
+
+    stream.once('end', () => res())
+  })
+}
+
+// Thanks: https://stackoverflow.com/a/37014317
+async function getNewestFile (files: string[], basePath: string) {
+  const sorted = await mtimeSortFilesDesc(files, basePath)
+
+  return (sorted.length > 0) ? sorted[0].file : ''
+}
+
+async function getFiles () {
+  if (options.files) return options.files
+
+  const logFiles = await readdir(CONFIG.STORAGE.LOG_DIR)
+
+  const filename = await getNewestFile(logFiles, CONFIG.STORAGE.LOG_DIR)
+  return [ join(CONFIG.STORAGE.LOG_DIR, filename) ]
+}
+
+function toTimeFormat (time: string) {
+  const timestamp = Date.parse(time)
+
+  if (isNaN(timestamp) === true) return 'Unknown date'
+
+  const d = new Date(timestamp)
+  return d.toLocaleString() + `.${d.getMilliseconds()}`
+}
+
+function containsTags (loggerTags: string[], optionsTags: string[]) {
+  if (!loggerTags) return false
+
+  for (const lt of loggerTags) {
+    for (const ot of optionsTags) {
+      if (lt === ot) return true
+    }
+  }
+
+  return false
+}
diff --git a/server/scripts/plugin/install.ts b/server/scripts/plugin/install.ts
new file mode 100755
index 000000000..3b13120ff
--- /dev/null
+++ b/server/scripts/plugin/install.ts
@@ -0,0 +1,41 @@
+import { program } from 'commander'
+import { isAbsolute } from 'path'
+import { initDatabaseModels } from '../../server/initializers/database.js'
+import { PluginManager } from '../../server/lib/plugins/plugin-manager.js'
+
+program
+  .option('-n, --npm-name [npmName]', 'Plugin to install')
+  .option('-v, --plugin-version [pluginVersion]', 'Plugin version to install')
+  .option('-p, --plugin-path [pluginPath]', 'Path of the plugin you want to install')
+  .parse(process.argv)
+
+const options = program.opts()
+
+if (!options.npmName && !options.pluginPath) {
+  console.error('You need to specify a plugin name with the desired version, or a plugin path.')
+  process.exit(-1)
+}
+
+if (options.pluginPath && !isAbsolute(options.pluginPath)) {
+  console.error('Plugin path should be absolute.')
+  process.exit(-1)
+}
+
+run()
+  .then(() => process.exit(0))
+  .catch(err => {
+    console.error(err)
+    process.exit(-1)
+  })
+
+async function run () {
+  await initDatabaseModels(true)
+
+  const toInstall = options.npmName || options.pluginPath
+  await PluginManager.Instance.install({
+    toInstall,
+    version: options.pluginVersion,
+    fromDisk: !!options.pluginPath,
+    register: false
+  })
+}
diff --git a/server/scripts/plugin/uninstall.ts b/server/scripts/plugin/uninstall.ts
new file mode 100755
index 000000000..baf0422c4
--- /dev/null
+++ b/server/scripts/plugin/uninstall.ts
@@ -0,0 +1,29 @@
+import { program } from 'commander'
+import { initDatabaseModels } from '@server/initializers/database.js'
+import { PluginManager } from '@server/lib/plugins/plugin-manager.js'
+
+program
+  .option('-n, --npm-name [npmName]', 'Package name to install')
+  .parse(process.argv)
+
+const options = program.opts()
+
+if (!options.npmName) {
+  console.error('You need to specify the plugin name.')
+  process.exit(-1)
+}
+
+run()
+  .then(() => process.exit(0))
+  .catch(err => {
+    console.error(err)
+    process.exit(-1)
+  })
+
+async function run () {
+
+  await initDatabaseModels(true)
+
+  const toUninstall = options.npmName
+  await PluginManager.Instance.uninstall({ npmName: toUninstall, unregister: false })
+}
diff --git a/server/scripts/prune-storage.ts b/server/scripts/prune-storage.ts
new file mode 100755
index 000000000..9309724b9
--- /dev/null
+++ b/server/scripts/prune-storage.ts
@@ -0,0 +1,187 @@
+import Bluebird from 'bluebird'
+import { remove } from 'fs-extra/esm'
+import { readdir, stat } from 'fs/promises'
+import { basename, join } from 'path'
+import prompt from 'prompt'
+import { uniqify } from '@peertube/peertube-core-utils'
+import { ThumbnailType, ThumbnailType_Type } from '@peertube/peertube-models'
+import { DIRECTORIES } from '@server/initializers/constants.js'
+import { VideoFileModel } from '@server/models/video/video-file.js'
+import { VideoStreamingPlaylistModel } from '@server/models/video/video-streaming-playlist.js'
+import { getUUIDFromFilename } from '../server/helpers/utils.js'
+import { CONFIG } from '../server/initializers/config.js'
+import { initDatabaseModels } from '../server/initializers/database.js'
+import { ActorImageModel } from '../server/models/actor/actor-image.js'
+import { VideoRedundancyModel } from '../server/models/redundancy/video-redundancy.js'
+import { ThumbnailModel } from '../server/models/video/thumbnail.js'
+import { VideoModel } from '../server/models/video/video.js'
+
+run()
+  .then(() => process.exit(0))
+  .catch(err => {
+    console.error(err)
+    process.exit(-1)
+  })
+
+async function run () {
+  const dirs = Object.values(CONFIG.STORAGE)
+
+  if (uniqify(dirs).length !== dirs.length) {
+    console.error('Cannot prune storage because you put multiple storage keys in the same directory.')
+    process.exit(0)
+  }
+
+  await initDatabaseModels(true)
+
+  let toDelete: string[] = []
+
+  console.log('Detecting files to remove, it could take a while...')
+
+  toDelete = toDelete.concat(
+    await pruneDirectory(DIRECTORIES.VIDEOS.PUBLIC, doesWebVideoFileExist()),
+    await pruneDirectory(DIRECTORIES.VIDEOS.PRIVATE, doesWebVideoFileExist()),
+
+    await pruneDirectory(DIRECTORIES.HLS_STREAMING_PLAYLIST.PRIVATE, doesHLSPlaylistExist()),
+    await pruneDirectory(DIRECTORIES.HLS_STREAMING_PLAYLIST.PUBLIC, doesHLSPlaylistExist()),
+
+    await pruneDirectory(CONFIG.STORAGE.TORRENTS_DIR, doesTorrentFileExist()),
+
+    await pruneDirectory(CONFIG.STORAGE.REDUNDANCY_DIR, doesRedundancyExist),
+
+    await pruneDirectory(CONFIG.STORAGE.PREVIEWS_DIR, doesThumbnailExist(true, ThumbnailType.PREVIEW)),
+    await pruneDirectory(CONFIG.STORAGE.THUMBNAILS_DIR, doesThumbnailExist(false, ThumbnailType.MINIATURE)),
+
+    await pruneDirectory(CONFIG.STORAGE.ACTOR_IMAGES_DIR, doesActorImageExist)
+  )
+
+  const tmpFiles = await readdir(CONFIG.STORAGE.TMP_DIR)
+  toDelete = toDelete.concat(tmpFiles.map(t => join(CONFIG.STORAGE.TMP_DIR, t)))
+
+  if (toDelete.length === 0) {
+    console.log('No files to delete.')
+    return
+  }
+
+  console.log('Will delete %d files:\n\n%s\n\n', toDelete.length, toDelete.join('\n'))
+
+  const res = await askConfirmation()
+  if (res === true) {
+    console.log('Processing delete...\n')
+
+    for (const path of toDelete) {
+      await remove(path)
+    }
+
+    console.log('Done!')
+  } else {
+    console.log('Exiting without deleting files.')
+  }
+}
+
+type ExistFun = (file: string) => Promise<boolean> | boolean
+async function pruneDirectory (directory: string, existFun: ExistFun) {
+  const files = await readdir(directory)
+
+  const toDelete: string[] = []
+  await Bluebird.map(files, async file => {
+    const filePath = join(directory, file)
+
+    if (await existFun(filePath) !== true) {
+      toDelete.push(filePath)
+    }
+  }, { concurrency: 20 })
+
+  return toDelete
+}
+
+function doesWebVideoFileExist () {
+  return (filePath: string) => {
+    // Don't delete private directory
+    if (filePath === DIRECTORIES.VIDEOS.PRIVATE) return true
+
+    return VideoFileModel.doesOwnedWebVideoFileExist(basename(filePath))
+  }
+}
+
+function doesHLSPlaylistExist () {
+  return (hlsPath: string) => {
+    // Don't delete private directory
+    if (hlsPath === DIRECTORIES.HLS_STREAMING_PLAYLIST.PRIVATE) return true
+
+    return VideoStreamingPlaylistModel.doesOwnedHLSPlaylistExist(basename(hlsPath))
+  }
+}
+
+function doesTorrentFileExist () {
+  return (filePath: string) => VideoFileModel.doesOwnedTorrentFileExist(basename(filePath))
+}
+
+function doesThumbnailExist (keepOnlyOwned: boolean, type: ThumbnailType_Type) {
+  return async (filePath: string) => {
+    const thumbnail = await ThumbnailModel.loadByFilename(basename(filePath), type)
+    if (!thumbnail) return false
+
+    if (keepOnlyOwned) {
+      const video = await VideoModel.load(thumbnail.videoId)
+      if (video.isOwned() === false) return false
+    }
+
+    return true
+  }
+}
+
+async function doesActorImageExist (filePath: string) {
+  const image = await ActorImageModel.loadByName(basename(filePath))
+
+  return !!image
+}
+
+async function doesRedundancyExist (filePath: string) {
+  const isPlaylist = (await stat(filePath)).isDirectory()
+
+  if (isPlaylist) {
+    // Don't delete HLS redundancy directory
+    if (filePath === DIRECTORIES.HLS_REDUNDANCY) return true
+
+    const uuid = getUUIDFromFilename(filePath)
+    const video = await VideoModel.loadWithFiles(uuid)
+    if (!video) return false
+
+    const p = video.getHLSPlaylist()
+    if (!p) return false
+
+    const redundancy = await VideoRedundancyModel.loadLocalByStreamingPlaylistId(p.id)
+    return !!redundancy
+  }
+
+  const file = await VideoFileModel.loadByFilename(basename(filePath))
+  if (!file) return false
+
+  const redundancy = await VideoRedundancyModel.loadLocalByFileId(file.id)
+  return !!redundancy
+}
+
+async function askConfirmation () {
+  return new Promise((res, rej) => {
+    prompt.start()
+
+    const schema = {
+      properties: {
+        confirm: {
+          type: 'string',
+          description: 'These following unused files can be deleted, but please check your backups first (bugs happen).' +
+            ' Notice PeerTube must have been stopped when your ran this script.' +
+            ' Can we delete these files?',
+          default: 'n',
+          required: true
+        }
+      }
+    }
+
+    prompt.get(schema, function (err, result) {
+      if (err) return rej(err)
+
+      return res(result.confirm?.match(/y/) !== null)
+    })
+  })
+}
diff --git a/server/scripts/regenerate-thumbnails.ts b/server/scripts/regenerate-thumbnails.ts
new file mode 100644
index 000000000..d4346ce40
--- /dev/null
+++ b/server/scripts/regenerate-thumbnails.ts
@@ -0,0 +1,64 @@
+import Bluebird from 'bluebird'
+import { program } from 'commander'
+import { pathExists, remove } from 'fs-extra/esm'
+import { generateImageFilename, processImage } from '@server/helpers/image-utils.js'
+import { THUMBNAILS_SIZE } from '@server/initializers/constants.js'
+import { initDatabaseModels } from '@server/initializers/database.js'
+import { VideoModel } from '@server/models/video/video.js'
+
+program
+  .description('Regenerate local thumbnails using preview files')
+  .parse(process.argv)
+
+run()
+  .then(() => process.exit(0))
+  .catch(err => console.error(err))
+
+async function run () {
+  await initDatabaseModels(true)
+
+  const ids = await VideoModel.listLocalIds()
+
+  await Bluebird.map(ids, id => {
+    return processVideo(id)
+      .catch(err => console.error('Cannot process video %d.', id, err))
+  }, { concurrency: 20 })
+}
+
+async function processVideo (id: number) {
+  const video = await VideoModel.loadWithFiles(id)
+
+  console.log('Processing video %s.', video.name)
+
+  const thumbnail = video.getMiniature()
+  const preview = video.getPreview()
+
+  const previewPath = preview.getPath()
+
+  if (!await pathExists(previewPath)) {
+    throw new Error(`Preview ${previewPath} does not exist on disk`)
+  }
+
+  const size = {
+    width: THUMBNAILS_SIZE.width,
+    height: THUMBNAILS_SIZE.height
+  }
+
+  const oldPath = thumbnail.getPath()
+
+  // Update thumbnail
+  thumbnail.filename = generateImageFilename()
+  thumbnail.width = size.width
+  thumbnail.height = size.height
+
+  const thumbnailPath = thumbnail.getPath()
+  await processImage({ path: previewPath, destination: thumbnailPath, newSize: size, keepOriginal: true })
+
+  // Save new attributes
+  await thumbnail.save()
+
+  // Remove old thumbnail
+  await remove(oldPath)
+
+  // Don't federate, remote instances will refresh the thumbnails after a while
+}
diff --git a/server/scripts/reset-password.ts b/server/scripts/reset-password.ts
new file mode 100755
index 000000000..96e301ba9
--- /dev/null
+++ b/server/scripts/reset-password.ts
@@ -0,0 +1,58 @@
+import { program } from 'commander'
+import readline from 'readline'
+import { Writable } from 'stream'
+import { isUserPasswordValid } from '@server/helpers/custom-validators/users.js'
+import { initDatabaseModels } from '@server/initializers/database.js'
+import { UserModel } from '@server/models/user/user.js'
+
+program
+  .option('-u, --user [user]', 'User')
+  .parse(process.argv)
+
+const options = program.opts()
+
+if (options.user === undefined) {
+  console.error('All parameters are mandatory.')
+  process.exit(-1)
+}
+
+initDatabaseModels(true)
+  .then(() => {
+    return UserModel.loadByUsername(options.user)
+  })
+  .then(user => {
+    if (!user) {
+      console.error('Unknown user.')
+      process.exit(-1)
+    }
+
+    const mutableStdout = new Writable({
+      write: function (_chunk, _encoding, callback) {
+        callback()
+      }
+    })
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: mutableStdout,
+      terminal: true
+    })
+
+    console.log('New password?')
+    rl.on('line', function (password) {
+      if (!isUserPasswordValid(password)) {
+        console.error('New password is invalid.')
+        process.exit(-1)
+      }
+
+      user.password = password
+
+      user.save()
+        .then(() => console.log('User password updated.'))
+        .catch(err => console.error(err))
+        .finally(() => process.exit(0))
+    })
+  })
+  .catch(err => {
+    console.error(err)
+    process.exit(-1)
+  })
diff --git a/server/scripts/update-host.ts b/server/scripts/update-host.ts
new file mode 100755
index 000000000..52ac4947a
--- /dev/null
+++ b/server/scripts/update-host.ts
@@ -0,0 +1,140 @@
+import { updateTorrentMetadata } from '@server/helpers/webtorrent.js'
+import { getServerActor } from '@server/models/application/application.js'
+import { WEBSERVER } from '@server/initializers/constants.js'
+import { initDatabaseModels } from '@server/initializers/database.js'
+import {
+  getLocalAccountActivityPubUrl,
+  getLocalVideoActivityPubUrl,
+  getLocalVideoAnnounceActivityPubUrl,
+  getLocalVideoChannelActivityPubUrl,
+  getLocalVideoCommentActivityPubUrl
+} from '@server/lib/activitypub/url.js'
+import { AccountModel } from '@server/models/account/account.js'
+import { ActorFollowModel } from '@server/models/actor/actor-follow.js'
+import { ActorModel } from '@server/models/actor/actor.js'
+import { VideoChannelModel } from '@server/models/video/video-channel.js'
+import { VideoCommentModel } from '@server/models/video/video-comment.js'
+import { VideoShareModel } from '@server/models/video/video-share.js'
+import { VideoModel } from '@server/models/video/video.js'
+
+run()
+  .then(() => process.exit(0))
+  .catch(err => {
+    console.error(err)
+    process.exit(-1)
+  })
+
+async function run () {
+  await initDatabaseModels(true)
+
+  const serverAccount = await getServerActor()
+
+  {
+    const res = await ActorFollowModel.listAcceptedFollowingUrlsForApi([ serverAccount.id ], undefined)
+    const hasFollowing = res.total > 0
+
+    if (hasFollowing === true) {
+      throw new Error('Cannot update host because you follow other servers!')
+    }
+  }
+
+  console.log('Updating actors.')
+
+  const actors: ActorModel[] = await ActorModel.unscoped().findAll({
+    include: [
+      {
+        model: VideoChannelModel.unscoped(),
+        required: false
+      },
+      {
+        model: AccountModel.unscoped(),
+        required: false
+      }
+    ]
+  })
+  for (const actor of actors) {
+    if (actor.isOwned() === false) continue
+
+    console.log('Updating actor ' + actor.url)
+
+    const newUrl = actor.Account
+      ? getLocalAccountActivityPubUrl(actor.preferredUsername)
+      : getLocalVideoChannelActivityPubUrl(actor.preferredUsername)
+
+    actor.url = newUrl
+    actor.inboxUrl = newUrl + '/inbox'
+    actor.outboxUrl = newUrl + '/outbox'
+    actor.sharedInboxUrl = WEBSERVER.URL + '/inbox'
+    actor.followersUrl = newUrl + '/followers'
+    actor.followingUrl = newUrl + '/following'
+
+    await actor.save()
+  }
+
+  console.log('Updating video shares.')
+
+  const videoShares: VideoShareModel[] = await VideoShareModel.findAll({
+    include: [ VideoModel.unscoped(), ActorModel.unscoped() ]
+  })
+  for (const videoShare of videoShares) {
+    if (videoShare.Video.isOwned() === false) continue
+
+    console.log('Updating video share ' + videoShare.url)
+
+    videoShare.url = getLocalVideoAnnounceActivityPubUrl(videoShare.Actor, videoShare.Video)
+    await videoShare.save()
+  }
+
+  console.log('Updating video comments.')
+  const videoComments: VideoCommentModel[] = await VideoCommentModel.findAll({
+    include: [
+      {
+        model: VideoModel.unscoped()
+      },
+      {
+        model: AccountModel.unscoped(),
+        include: [
+          {
+            model: ActorModel.unscoped()
+          }
+        ]
+      }
+    ]
+  })
+  for (const comment of videoComments) {
+    if (comment.isOwned() === false) continue
+
+    console.log('Updating comment ' + comment.url)
+
+    comment.url = getLocalVideoCommentActivityPubUrl(comment.Video, comment)
+    await comment.save()
+  }
+
+  console.log('Updating video and torrent files.')
+
+  const ids = await VideoModel.listLocalIds()
+  for (const id of ids) {
+    const video = await VideoModel.loadFull(id)
+
+    console.log('Updating video ' + video.uuid)
+
+    video.url = getLocalVideoActivityPubUrl(video)
+    await video.save()
+
+    for (const file of video.VideoFiles) {
+      console.log('Updating torrent file %s of video %s.', file.resolution, video.uuid)
+      await updateTorrentMetadata(video, file)
+
+      await file.save()
+    }
+
+    const playlist = video.getHLSPlaylist()
+    for (const file of (playlist?.VideoFiles || [])) {
+      console.log('Updating fragmented torrent file %s of video %s.', file.resolution, video.uuid)
+
+      await updateTorrentMetadata(playlist, file)
+
+      await file.save()
+    }
+  }
+}
diff --git a/server/scripts/upgrade.sh b/server/scripts/upgrade.sh
new file mode 100755
index 000000000..64c7e1581
--- /dev/null
+++ b/server/scripts/upgrade.sh
@@ -0,0 +1,108 @@
+#!/bin/sh
+
+set -eu
+
+PEERTUBE_PATH=${1:-/var/www/peertube}
+
+if [ ! -e "$PEERTUBE_PATH" ]; then
+  echo "Error - path \"$PEERTUBE_PATH\" wasn't found"
+  echo ""
+  echo "If peertube was installed in another path, you can specify it with"
+  echo "    ./upgrade.sh <PATH>"
+  exit 1
+fi
+
+if [ ! -e "$PEERTUBE_PATH/versions" -o ! -e "$PEERTUBE_PATH/config/production.yaml" ]; then
+  echo "Error - Couldn't find peertube installation in \"$PEERTUBE_PATH\""
+  echo ""
+  echo "If peertube was installed in another path, you can specify it with"
+  echo "    ./upgrade.sh <PATH>"
+  exit 1
+fi
+
+if [ -x "$(command -v awk)" ] && [ -x "$(command -v sed)" ]; then
+    REMAINING=$(df -k $PEERTUBE_PATH | awk '{ print $4}' | sed -n 2p)
+    ONE_GB=$((1024 * 1024))
+
+    if [ "$REMAINING" -lt "$ONE_GB" ]; then
+      echo "Error - not enough free space for upgrading"
+      echo ""
+      echo "Make sure you have at least 1 GB of free space in $PEERTUBE_PATH"
+      exit 1
+    fi
+fi
+
+# Backup database
+if [ -x "$(command -v pg_dump)" ]; then
+  mkdir -p $PEERTUBE_PATH/backup
+
+  SQL_BACKUP_PATH="$PEERTUBE_PATH/backup/sql-peertube_prod-$(date +"%Y%m%d-%H%M").bak"
+
+  echo "Backing up PostgreSQL database in $SQL_BACKUP_PATH"
+
+  DB_USER=$(node -e "console.log(require('js-yaml').load(fs.readFileSync('$PEERTUBE_PATH/config/production.yaml', 'utf8'))['database']['username'])")
+  DB_PASS=$(node -e "console.log(require('js-yaml').load(fs.readFileSync('$PEERTUBE_PATH/config/production.yaml', 'utf8'))['database']['password'])")
+  DB_HOST=$(node -e "console.log(require('js-yaml').load(fs.readFileSync('$PEERTUBE_PATH/config/production.yaml', 'utf8'))['database']['hostname'])")
+  DB_PORT=$(node -e "console.log(require('js-yaml').load(fs.readFileSync('$PEERTUBE_PATH/config/production.yaml', 'utf8'))['database']['port'])")
+  DB_SUFFIX=$(node -e "console.log(require('js-yaml').load(fs.readFileSync('$PEERTUBE_PATH/config/production.yaml', 'utf8'))['database']['suffix'])")
+  DB_NAME=$(node -e "console.log(require('js-yaml').load(fs.readFileSync('$PEERTUBE_PATH/config/production.yaml', 'utf8'))['database']['name'] || '')")
+
+  PGPASSWORD=$DB_PASS pg_dump -U $DB_USER -p $DB_PORT -h $DB_HOST -F c "${DB_NAME:-peertube${DB_SUFFIX}}" -f "$SQL_BACKUP_PATH"
+else
+  echo "pg_dump not found. Cannot make a SQL backup!"
+fi
+
+# If there is a pre-release, give the user a choice which one to install.
+RELEASE_VERSION=$(curl -s https://api.github.com/repos/chocobozzz/peertube/releases/latest | grep tag_name | cut -d '"' -f 4)
+PRE_RELEASE_VERSION=$(curl -s https://api.github.com/repos/chocobozzz/peertube/releases | grep tag_name | head -1 | cut -d '"' -f 4)
+
+if [ "$RELEASE_VERSION" != "$PRE_RELEASE_VERSION" ]; then
+  echo -e "Which version do you want to install?\n[1] $RELEASE_VERSION (stable) \n[2] $PRE_RELEASE_VERSION (pre-release)"
+  read choice
+  case $choice in
+      [1]* ) VERSION="$RELEASE_VERSION";;
+      [2]* ) VERSION="$PRE_RELEASE_VERSION";;
+      * ) exit;
+  esac
+else
+  VERSION="$RELEASE_VERSION"
+fi
+
+echo "Installing Peertube version $VERSION"
+wget -q "https://github.com/Chocobozzz/PeerTube/releases/download/${VERSION}/peertube-${VERSION}.zip" -O "$PEERTUBE_PATH/versions/peertube-${VERSION}.zip"
+cd $PEERTUBE_PATH/versions
+unzip -o "peertube-${VERSION}.zip"
+rm -f "peertube-${VERSION}.zip"
+
+RELEASE_PAGE_URL="https://github.com/Chocobozzz/PeerTube/releases/tag/${VERSION}"
+LATEST_VERSION_DIRECTORY="$PEERTUBE_PATH/versions/peertube-${VERSION}"
+cd "$LATEST_VERSION_DIRECTORY"
+
+# Launch yarn to check if we have all required dependencies
+NOCLIENT=1 yarn install --production --pure-lockfile
+
+# Switch to latest code version
+rm -rf $PEERTUBE_PATH/peertube-latest
+ln -s "$LATEST_VERSION_DIRECTORY" $PEERTUBE_PATH/peertube-latest
+cp $PEERTUBE_PATH/peertube-latest/config/default.yaml $PEERTUBE_PATH/config/default.yaml
+
+echo ""
+echo "=========================================================="
+echo ""
+
+if [ -x "$(command -v git)" ]; then
+  cd /var/www/peertube
+
+  git merge-file -p config/production.yaml "$LATEST_VERSION_DIRECTORY/config/production.yaml.example" "peertube-latest/config/production.yaml.example" | tee "config/production.yaml.new" > /dev/null
+  echo "/var/www/peertube/config/production.yaml.new generated"
+  echo "You can review it and replace your existing production.yaml configuration"
+else
+  echo "git command not found: unable to generate config/production.yaml.new configuration file based on your existing production.yaml configuration"
+fi
+
+echo ""
+echo "=========================================================="
+echo ""
+echo "Please read the IMPORTANT NOTES on $RELEASE_PAGE_URL"
+echo ""
+echo "Then restart PeerTube!"