@meith/cli 0.33.4 → 0.35.0

package/src/board-eject.ts

@@ -244,6 +244,7 @@ export async function boardEject(args: readonly string[]): Promise<number> {
     '  # to the pushed image (or docker-compose.yaml instead, which builds on the server)',
   )
   console.log('  # redeploy — same database, same uploads, same secrets, new image source')
+  console.log('  # no panel? docker-compose.byhand.yaml is the same board without Coolify')
   console.log('')
   console.log(
     'See docs/customization/marketplace.md, "Moving to a custom board", for the full walkthrough.',

package/src/commands.ts

@@ -61,11 +61,13 @@ export async function userCreate(args: readonly string[]): Promise<number> {
   const password = await readPassword(flags)
 
   const ctx = await createContext()
-  const result = await ctx.identity.register({ username, email, password })
 
   const groupRef = optional(flags, 'group')
-  if (groupRef !== undefined) {
-    const group = await findGroup(ctx, groupRef)
+  const group = groupRef === undefined ? null : await findGroup(ctx, groupRef)
+
+  const result = await ctx.identity.register({ username, email, password })
+
+  if (group !== null) {
     await ctx.admin.setPrimaryGroup(result.account.id, group.id)
     console.log(`Created user ${username} (id ${result.account.id}) in group ${group.key}.`)
   } else {

package/src/import-files.ts

@@ -76,22 +76,24 @@ export class UploadsDirCopier implements ImportFileCopier {
       return { outcome: 'failed', reason: `avatar ${input.path} is not a png or jpeg` }
     }
 
+    let processed: Awaited<ReturnType<ImageProcessor['process']>>
     try {
-      const processed = await this.images.process({
+      processed = await this.images.process({
         bytes,
         codec: type.codec,
         fit: AVATAR_BOX,
         thumbnail: false,
       })
-      const key = storageKey('avatars', input.legacyUserId, EXTENSIONS[processed.contentType] ?? '')
-      await this.files.put(key, processed.bytes, {
-        contentType: processed.contentType,
-        visibility: 'public',
-      })
-      return { outcome: 'ready', key, width: processed.width, height: processed.height }
     } catch {
       return { outcome: 'failed', reason: `avatar ${input.path} could not be decoded` }
     }
+
+    const key = storageKey('avatars', input.legacyUserId, EXTENSIONS[processed.contentType] ?? '')
+    await this.files.put(key, processed.bytes, {
+      contentType: processed.contentType,
+      visibility: 'public',
+    })
+    return { outcome: 'ready', key, width: processed.width, height: processed.height }
   }
 
   async #reencode(
@@ -104,34 +106,36 @@ export class UploadsDirCopier implements ImportFileCopier {
       return { outcome: 'failed', reason: `file ${path} could not be decoded` }
     }
 
+    let processed: Awaited<ReturnType<ImageProcessor['process']>>
     try {
-      const processed = await this.images.process({ bytes, codec: type.codec })
-      const key = storageKey('attachments', legacyId, EXTENSIONS[processed.contentType] ?? '')
-      await this.files.put(key, processed.bytes, {
-        contentType: processed.contentType,
+      processed = await this.images.process({ bytes, codec: type.codec })
+    } catch {
+      return { outcome: 'failed', reason: `file ${path} could not be decoded` }
+    }
+
+    const key = storageKey('attachments', legacyId, EXTENSIONS[processed.contentType] ?? '')
+    await this.files.put(key, processed.bytes, {
+      contentType: processed.contentType,
+      visibility: 'private',
+    })
+
+    let thumbnailKey: string | null = null
+    if (processed.thumbnail !== undefined) {
+      thumbnailKey = storageKey('attachments', legacyId, '.thumb.jpg')
+      await this.files.put(thumbnailKey, processed.thumbnail.bytes, {
+        contentType: processed.thumbnail.contentType,
         visibility: 'private',
       })
+    }
 
-      let thumbnailKey: string | null = null
-      if (processed.thumbnail !== undefined) {
-        thumbnailKey = storageKey('attachments', legacyId, '.thumb.jpg')
-        await this.files.put(thumbnailKey, processed.thumbnail.bytes, {
-          contentType: processed.thumbnail.contentType,
-          visibility: 'private',
-        })
-      }
-
-      return {
-        outcome: 'ready',
-        storageKey: key,
-        thumbnailKey,
-        contentType: processed.contentType,
-        sizeBytes: processed.bytes.byteLength,
-        width: processed.width,
-        height: processed.height,
-      }
-    } catch {
-      return { outcome: 'failed', reason: `file ${path} could not be decoded` }
+    return {
+      outcome: 'ready',
+      storageKey: key,
+      thumbnailKey,
+      contentType: processed.contentType,
+      sizeBytes: processed.bytes.byteLength,
+      width: processed.width,
+      height: processed.height,
     }
   }
 

package/src/index.ts

@@ -113,6 +113,10 @@ const commands: Command[] = [
       )
 
       const { runMigrations } = await import('@meith/db')
+      const { backupBeforeMigrating } = await import('@meith/runtime')
+      if ((await backupBeforeMigrating()) === 'taken') {
+        console.log('Took the backup the settings ask for before a migration.')
+      }
       const applied = await runMigrations()
       console.log(applied === 0 ? 'Already up to date.' : `Applied ${applied} migration(s).`)
       return 0
@@ -182,7 +186,12 @@ const commands: Command[] = [
   {
     name: 'backup:list',
     summary: 'List the backup bundles on local disk and at the off-site destination.',
-    usage: 'meith backup:list [--dir <dir>]',
+    usage: [
+      'meith backup:list [--dir <dir>]',
+      '',
+      '--dir defaults to BACKUP_DIR, the ring the admin panel and the scheduler use',
+      '(/backups in the shipped image).',
+    ].join('\n'),
     run: backupListCommand,
   },
 

package/src/redaction.ts

@@ -11,6 +11,7 @@ export const SECRET_ENV_KEYS: ReadonlySet<string> = new Set([
   'REDIS_URL',
   'S3_SECRET_ACCESS_KEY',
   'BACKUP_S3_SECRET_ACCESS_KEY',
+  'BACKUP_WEBDAV_PASSWORD',
   'BLOB_READ_WRITE_TOKEN',
 ])
 
@@ -22,6 +23,7 @@ export const NOT_SECRET_DESPITE_THE_NAME: ReadonlySet<string> = new Set([
   'S3_ACCESS_KEY_ID',
   'BACKUP_S3_ACCESS_KEY_ID',
   'BACKUP_S3_ENDPOINT',
+  'BACKUP_WEBDAV_URL',
   'MAIL_SMTP_USERNAME',
 ])
 

package/src/upgrade.ts

@@ -9,10 +9,10 @@ import {
   runMigrations,
 } from '@meith/db'
 import { type PluginDefinition, pluginNavigationPlacements } from '@meith/plugin-kit'
-import { runPluginLifecycle } from '@meith/runtime'
+import { backupBeforeMigrating, runPluginLifecycle } from '@meith/runtime'
 import { type PluginUpgrade, planUpgrade, upgradeNotice } from '@meith/upgrade'
 
-export const CODE_VERSION = '0.33.4'
+export const CODE_VERSION = '0.35.0'
 
 export function pluginUpgrades(plugins: readonly PluginDefinition[]): readonly PluginUpgrade[] {
   return plugins.map((plugin) => ({
@@ -88,6 +88,9 @@ export async function upgrade(options: UpgradeOptions): Promise<number> {
     return 0
   }
 
+  if ((await backupBeforeMigrating()) === 'taken') {
+    options.log('Core: took the backup the settings ask for before a migration.')
+  }
   const count = await runMigrations()
   options.log(count === 0 ? 'Core: already up to date.' : `Core: applied ${count} migration(s).`)
 

package/src/backup-store.ts

@@ -1,221 +0,0 @@
-import { createReadStream, createWriteStream } from 'node:fs'
-import { pipeline } from 'node:stream/promises'
-
-import {
-  DeleteObjectCommand,
-  GetObjectCommand,
-  ListObjectsV2Command,
-  PutObjectCommand,
-  S3Client,
-} from '@aws-sdk/client-s3'
-
-import { ConfigurationError, ValidationError } from '@meith/core'
-
-export const BUNDLE_NAME_PATTERN = /^meith-backup-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}Z\.tar\.gz$/
-
-export function isBundleName(name: string): boolean {
-  return BUNDLE_NAME_PATTERN.test(name)
-}
-
-export function pruneCandidates(names: readonly string[], keep: number): readonly string[] {
-  return names
-    .filter((name) => isBundleName(name))
-    .sort()
-    .reverse()
-    .slice(keep)
-}
-
-export const DEFAULT_KEEP = 7
-
-export function resolveKeep(flag: string | undefined): number {
-  if (flag === undefined) return DEFAULT_KEEP
-  if (!/^\d+$/.test(flag) || Number(flag) < 1 || !Number.isSafeInteger(Number(flag))) {
-    throw new ValidationError(`--keep must be a whole number of bundles, 1 or more, got "${flag}".`)
-  }
-  return Number(flag)
-}
-
-export interface BackupDestinationConfig {
-  readonly bucket: string
-  readonly region: string
-  readonly accessKeyId: string
-  readonly secretAccessKey: string
-  readonly endpoint?: string | undefined
-  readonly prefix?: string | undefined
-}
-
-const BACKUP_DESTINATION_KEYS = [
-  'BACKUP_S3_BUCKET',
-  'BACKUP_S3_REGION',
-  'BACKUP_S3_ACCESS_KEY_ID',
-  'BACKUP_S3_SECRET_ACCESS_KEY',
-] as const
-
-export function backupDestinationFromEnv(
-  environment: NodeJS.ProcessEnv,
-): BackupDestinationConfig | undefined {
-  const set = BACKUP_DESTINATION_KEYS.filter(
-    (key) => environment[key] !== undefined && environment[key] !== '',
-  )
-  if (set.length === 0) return undefined
-  if (set.length < BACKUP_DESTINATION_KEYS.length) {
-    const missing = BACKUP_DESTINATION_KEYS.filter((key) => !set.includes(key))
-    throw new ConfigurationError(
-      `An off-site backup destination is partly configured: ${set.join(', ')} without ` +
-        `${missing.join(', ')}. Set all four, or none.`,
-    )
-  }
-
-  const prefix = environment.BACKUP_S3_PREFIX?.replace(/^\/+|\/+$/g, '')
-  if (
-    prefix !== undefined &&
-    prefix !== '' &&
-    prefix.split('/').some((segment) => !/^[\w!.*'()-]+$/.test(segment) || /^\.+$/.test(segment))
-  ) {
-    throw new ConfigurationError(
-      'BACKUP_S3_PREFIX must be one or more path segments of unreserved characters.',
-    )
-  }
-
-  return {
-    bucket: environment.BACKUP_S3_BUCKET as string,
-    region: environment.BACKUP_S3_REGION as string,
-    accessKeyId: environment.BACKUP_S3_ACCESS_KEY_ID as string,
-    secretAccessKey: environment.BACKUP_S3_SECRET_ACCESS_KEY as string,
-    endpoint: environment.BACKUP_S3_ENDPOINT || undefined,
-    prefix: prefix === '' ? undefined : prefix,
-  }
-}
-
-export interface S3Like {
-  send(command: unknown): Promise<unknown>
-}
-
-function isNotFound(error: unknown): boolean {
-  const name = (error as { name?: string } | null)?.name
-  const status = (error as { $metadata?: { httpStatusCode?: number } } | null)?.$metadata
-    ?.httpStatusCode
-
-  return name === 'NoSuchKey' || name === 'NotFound' || status === 404
-}
-
-export interface RemoteBundle {
-  readonly name: string
-  readonly size: number
-}
-
-export class BackupStore {
-  private readonly sender: S3Like
-
-  constructor(
-    private readonly config: BackupDestinationConfig,
-    sender?: S3Like,
-  ) {
-    this.sender =
-      sender ??
-      new S3Client({
-        region: config.region,
-        credentials: {
-          accessKeyId: config.accessKeyId,
-          secretAccessKey: config.secretAccessKey,
-        },
-        ...(config.endpoint === undefined
-          ? {}
-          : ({
-              endpoint: config.endpoint,
-              forcePathStyle: true,
-              requestChecksumCalculation: 'WHEN_REQUIRED',
-            } as const)),
-      })
-  }
-
-  get destination(): string {
-    return this.config.prefix === undefined
-      ? `the ${this.config.bucket} bucket`
-      : `the ${this.config.bucket} bucket under ${this.config.prefix}/`
-  }
-
-  private key(name: string): string {
-    if (!isBundleName(name)) {
-      throw new ValidationError(`Not a backup bundle name: ${JSON.stringify(name)}`)
-    }
-    return this.config.prefix === undefined ? name : `${this.config.prefix}/${name}`
-  }
-
-  async putFile(name: string, filePath: string, size: number): Promise<void> {
-    await this.sender.send(
-      new PutObjectCommand({
-        Bucket: this.config.bucket,
-        Key: this.key(name),
-        Body: createReadStream(filePath),
-        ContentLength: size,
-        ContentType: 'application/gzip',
-      }),
-    )
-  }
-
-  async list(): Promise<readonly RemoteBundle[]> {
-    const prefix = this.config.prefix === undefined ? '' : `${this.config.prefix}/`
-    const bundles: RemoteBundle[] = []
-    let continuationToken: string | undefined
-
-    do {
-      const response = (await this.sender.send(
-        new ListObjectsV2Command({
-          Bucket: this.config.bucket,
-          ...(prefix === '' ? {} : { Prefix: prefix }),
-          ...(continuationToken === undefined ? {} : { ContinuationToken: continuationToken }),
-        }),
-      )) as {
-        Contents?: readonly { Key?: string; Size?: number }[]
-        IsTruncated?: boolean
-        NextContinuationToken?: string
-      }
-
-      for (const object of response.Contents ?? []) {
-        if (object.Key === undefined || !object.Key.startsWith(prefix)) continue
-        const name = object.Key.slice(prefix.length)
-        if (isBundleName(name)) bundles.push({ name, size: object.Size ?? 0 })
-      }
-
-      continuationToken = response.IsTruncated ? response.NextContinuationToken : undefined
-    } while (continuationToken !== undefined)
-
-    return bundles.sort((a, b) => a.name.localeCompare(b.name))
-  }
-
-  async getToFile(name: string, outPath: string): Promise<void> {
-    let response: { Body?: NodeJS.ReadableStream }
-    try {
-      response = (await this.sender.send(
-        new GetObjectCommand({ Bucket: this.config.bucket, Key: this.key(name) }),
-      )) as { Body?: NodeJS.ReadableStream }
-    } catch (error) {
-      if (isNotFound(error)) {
-        throw new ValidationError(
-          `${this.destination} has no bundle named ${name}. meith backup:list names what it holds.`,
-        )
-      }
-      throw error
-    }
-    if (response.Body === undefined) {
-      throw new ConfigurationError(`${this.destination} answered without a body for ${name}.`)
-    }
-    await pipeline(response.Body, createWriteStream(outPath, { mode: 0o600 }))
-  }
-
-  async delete(name: string): Promise<void> {
-    await this.sender.send(
-      new DeleteObjectCommand({ Bucket: this.config.bucket, Key: this.key(name) }),
-    )
-  }
-
-  async prune(keep: number): Promise<readonly string[]> {
-    const stale = pruneCandidates(
-      (await this.list()).map((bundle) => bundle.name),
-      keep,
-    )
-    for (const name of stale) await this.delete(name)
-    return stale
-  }
-}