@metaplay/metaplay-auth 1.4.2 → 1.6.0

package/src/deployment.ts

@@ -1,6 +1,17 @@
-import { KubeConfig, CoreV1Api, V1Pod } from '@kubernetes/client-node'
+import {
+  KubeConfig,
+  CoreV1Api,
+  type V1Pod,
+  type CoreV1ApiListNamespacedPodRequest,
+  type CoreV1ApiReadNamespacedPodLogRequest,
+} from '@kubernetes/client-node'
 import { logger } from './logging.js'
-import type { CoreV1ApiListNamespacedPodRequest, CoreV1ApiReadNamespacedPodLogRequest } from '@kubernetes/client-node'
+import { TargetEnvironment } from 'targetenvironment.js'
+import { exit } from 'process'
+import { unlink, writeFile } from 'fs/promises'
+import { executeCommand } from './utils.js'
+import os from 'os'
+import path from 'path'
 
 enum GameServerPodPhase {
   Ready = 'Ready', // Successfully started and ready to accept traffic
@@ -16,12 +27,12 @@ interface GameServerPodStatus {
   details?: any
 }
 
-async function fetchGameServerPods (k8sApi: CoreV1Api, namespace: string) {
+async function fetchGameServerPods(k8sApi: CoreV1Api, namespace: string): Promise<V1Pod[]> {
   // Define label selector for gameserver
   logger.debug(`Fetching game server pods from Kubernetes: namespace=${namespace}`)
   const param: CoreV1ApiListNamespacedPodRequest = {
     namespace,
-    labelSelector: 'app=metaplay-server'
+    labelSelector: 'app=metaplay-server',
   }
 
   try {
@@ -32,25 +43,30 @@ async function fetchGameServerPods (k8sApi: CoreV1Api, namespace: string) {
     return response.items
   } catch (error) {
     // \todo Better error handling ..
-    console.log('Failed to fetch pods from Kubernetes:', error)
+    console.error('Failed to fetch pods from Kubernetes:', error)
     throw new Error('Failed to fetch pods from Kubernetes')
   }
 }
 
-function resolvePodContainersConditions (pod: V1Pod): GameServerPodStatus {
+function resolvePodContainersConditions(pod: V1Pod): GameServerPodStatus {
   const containerStatuses = pod.status?.containerStatuses
   if (!containerStatuses || containerStatuses.length === 0) {
-    return { phase: GameServerPodPhase.Unknown, message: 'Unable to determine pod container statuses: pod.status.containerStatuses is empty' }
+    return {
+      phase: GameServerPodPhase.Unknown,
+      message: 'Unable to determine pod container statuses: pod.status.containerStatuses is empty',
+    }
   }
 
   // Find the shard-server container from the pod (ignore others)
-  const containerStatus = containerStatuses.find(status => status.name === 'shard-server')
+  const containerStatus = containerStatuses.find((status) => status.name === 'shard-server')
   if (!containerStatus) {
     return { phase: GameServerPodPhase.Unknown, message: 'Unable to find container shard-server from the pod' }
   }
 
   // Handle missing container state
-  logger.debug(`Container status for pod ${pod.metadata?.name ?? '<unnamed>'}: ${JSON.stringify(containerStatus, undefined, 2)}`)
+  logger.debug(
+    `Container status for pod ${pod.metadata?.name ?? '<unnamed>'}: ${JSON.stringify(containerStatus, undefined, 2)}`
+  )
   const containerState = containerStatus.state
   if (!containerState) {
     return { phase: GameServerPodPhase.Unknown, message: 'Unable to get container state' }
@@ -60,14 +76,31 @@ function resolvePodContainersConditions (pod: V1Pod): GameServerPodStatus {
   const containerName = containerStatus.name
   if (containerState.running) {
     if (containerStatus.ready) {
-      return { phase: GameServerPodPhase.Ready, message: `Container ${containerName} is in ready phase`, details: containerState.running }
+      return {
+        phase: GameServerPodPhase.Ready,
+        message: `Container ${containerName} is in ready phase`,
+        details: containerState.running,
+      }
     } else {
-      return { phase: GameServerPodPhase.Running, message: `Container ${containerName} is in running phase`, details: containerState.running }
+      return {
+        phase: GameServerPodPhase.Running,
+        message: `Container ${containerName} is in running phase`,
+        details: containerState.running,
+      }
     }
   }
 
   // \note these may not be complete (or completely accurate)
-  const knownContainerFailureReasons = ['CrashLoopBackOff', 'Error', 'ImagePullBackOff', 'CreateContainerConfigError', 'OOMKilled', 'ContainerCannotRun', 'BackOff', 'InvalidImageName']
+  const knownContainerFailureReasons = [
+    'CrashLoopBackOff',
+    'Error',
+    'ImagePullBackOff',
+    'CreateContainerConfigError',
+    'OOMKilled',
+    'ContainerCannotRun',
+    'BackOff',
+    'InvalidImageName',
+  ]
   const knownContainerPendingReasons = ['Init', 'Pending', 'PodInitializing']
 
   // Check if there's a previous terminated state (usually indicates a crash during server initialization)
@@ -77,22 +110,46 @@ function resolvePodContainersConditions (pod: V1Pod): GameServerPodStatus {
       // Try to detecth why the previous launch failed
       if (containerState.waiting) {
         const reason = containerState.waiting.reason
-        if (knownContainerFailureReasons.includes(reason as string)) {
-          return { phase: GameServerPodPhase.Failed, message: `Container ${containerName} is in waiting state, reason=${reason}`, details: containerState.waiting }
-        } else if (knownContainerPendingReasons.includes(reason as string)) {
-          return { phase: GameServerPodPhase.Pending, message: `Container ${containerName} is in waiting state, reason=${reason}`, details: containerState.waiting }
+        if (reason && knownContainerFailureReasons.includes(reason)) {
+          return {
+            phase: GameServerPodPhase.Failed,
+            message: `Container ${containerName} is in waiting state, reason=${reason}`,
+            details: containerState.waiting,
+          }
+        } else if (reason && knownContainerPendingReasons.includes(reason)) {
+          return {
+            phase: GameServerPodPhase.Pending,
+            message: `Container ${containerName} is in waiting state, reason=${reason}`,
+            details: containerState.waiting,
+          }
         } else {
-          return { phase: GameServerPodPhase.Unknown, message: `Container ${containerName} is in waiting state, reason=${reason}`, details: containerState.waiting }
+          return {
+            phase: GameServerPodPhase.Unknown,
+            message: `Container ${containerName} is in waiting state, reason=${reason}`,
+            details: containerState.waiting,
+          }
         }
       } else if (containerState.running) {
         // This happens when the container is still initializing
-        return { phase: GameServerPodPhase.Pending, message: `Container ${containerName} is in running state`, details: containerState.running }
+        return {
+          phase: GameServerPodPhase.Pending,
+          message: `Container ${containerName} is in running state`,
+          details: containerState.running,
+        }
       } else if (containerState.terminated) {
-        return { phase: GameServerPodPhase.Failed, message: `Container ${containerName} is in terminated state`, details: containerState.terminated }
+        return {
+          phase: GameServerPodPhase.Failed,
+          message: `Container ${containerName} is in terminated state`,
+          details: containerState.terminated,
+        }
       }
 
       // Unable to determine launch failure reason, just return previous launch
-      return { phase: GameServerPodPhase.Failed, message: `Container ${containerName} previous launch failed with exitCode=${lastState.terminated.exitCode} and reason=${lastState.terminated.reason}`, details: lastState.terminated }
+      return {
+        phase: GameServerPodPhase.Failed,
+        message: `Container ${containerName} previous launch failed with exitCode=${lastState.terminated.exitCode} and reason=${lastState.terminated.reason}`,
+        details: lastState.terminated,
+      }
     }
 
     // \todo handle containerState.running states (including various initialization states)
@@ -103,45 +160,102 @@ function resolvePodContainersConditions (pod: V1Pod): GameServerPodStatus {
   return { phase: GameServerPodPhase.Unknown, message: 'Container in unknown state', details: containerState }
 }
 
-function resolvePodStatusConditions (pod: V1Pod): GameServerPodStatus {
+function resolveRunningPodStatusConditions(pod: V1Pod): GameServerPodStatus {
   const conditions = pod.status?.conditions
   if (!conditions || conditions.length === 0) {
-    return { phase: GameServerPodPhase.Unknown, message: 'Unable to determine pod status: pod.status.conditions is empty', details: pod.status }
+    return {
+      phase: GameServerPodPhase.Unknown,
+      message: 'Unable to determine pod status: pod.status.conditions is empty',
+      details: pod.status,
+    }
   }
 
   // Bail if 'PodScheduled' is not yet true
-  const condPodScheduled = conditions.find(cond => cond.type === 'PodScheduled')
+  const condPodScheduled = conditions.find((cond) => cond.type === 'PodScheduled')
   if (condPodScheduled?.status !== 'True') {
-    return { phase: GameServerPodPhase.Pending, message: `Pod has not yet been scheduled on a node: ${condPodScheduled?.message}`, details: condPodScheduled }
+    return {
+      phase: GameServerPodPhase.Pending,
+      message: `Pod has not yet been scheduled on a node: ${condPodScheduled?.message}`,
+      details: condPodScheduled,
+    }
   }
 
   // Bail if 'Initialized' not is yet true
-  const condInitialized = conditions.find(cond => cond.type === 'Initialized')
+  const condInitialized = conditions.find((cond) => cond.type === 'Initialized')
   if (condInitialized?.status !== 'True') {
-    return { phase: GameServerPodPhase.Pending, message: `Pod has not yet been initialized: ${condInitialized?.message}`, details: condInitialized }
+    return {
+      phase: GameServerPodPhase.Pending,
+      message: `Pod has not yet been initialized: ${condInitialized?.message}`,
+      details: condInitialized,
+    }
   }
 
   // Bail if 'ContainersReady' is not yet true
-  const condContainersReady = conditions.find(cond => cond.type === 'ContainersReady')
+  const condContainersReady = conditions.find((cond) => cond.type === 'ContainersReady')
   if (condContainersReady?.status !== 'True') {
     if (condContainersReady?.reason === 'ContainersNotReady') {
       return resolvePodContainersConditions(pod)
     }
 
-    return { phase: GameServerPodPhase.Pending, message: `Pod containers are not yet ready: ${condContainersReady?.message}`, details: condContainersReady }
+    return {
+      phase: GameServerPodPhase.Pending,
+      message: `Pod containers are not yet ready: ${condContainersReady?.message}`,
+      details: condContainersReady,
+    }
   }
 
   // Bail if 'Ready' is not yet true
-  const condReady = conditions.find(cond => cond.type === 'Ready')
+  const condReady = conditions.find((cond) => cond.type === 'Ready')
   if (condReady?.status !== 'True') {
-    return { phase: GameServerPodPhase.Pending, message: `Pod is not yet ready: ${condReady?.message}`, details: condReady }
+    return {
+      phase: GameServerPodPhase.Pending,
+      message: `Pod is not yet ready: ${condReady?.message}`,
+      details: condReady,
+    }
   }
 
   // resolvePodContainersConditions(pod) // DEBUG DEBUG enable to print container state for running pods
   return { phase: GameServerPodPhase.Ready, message: 'Pod is ready to serve traffic' }
 }
 
-function resolvePodStatus (pod: V1Pod): GameServerPodStatus {
+/**
+ * Returns the reason why the pod's PodScheduled condition is false. If that is not the case
+ * or reason cannot be determined, returns null.
+ */
+function resolvePodScheduledConditionFailureReason(pod: V1Pod): string | null {
+  // We are only interested in status when PodScheduled hasn't completed yet.
+  const condPodScheduled = pod.status?.conditions?.find((cond) => cond.type === 'PodScheduled')
+  if (condPodScheduled?.status !== 'False') {
+    return null
+  }
+
+  return condPodScheduled?.reason ?? null
+}
+
+function resolvePendingPodStatusConditions(pod: V1Pod): GameServerPodStatus {
+  const pendingReason = resolvePodScheduledConditionFailureReason(pod)
+  if (pendingReason) {
+    return { phase: GameServerPodPhase.Pending, message: `Pod is still in Pending phase. Reason: ${pendingReason}` }
+  } else {
+    return { phase: GameServerPodPhase.Pending, message: 'Pod is still in Pending phase' }
+  }
+}
+
+function resolvePodGameServerImageTag(pod: V1Pod): string | null {
+  // Find the shard-server spec from the pod and extract image tag from spec
+  const containerSpec = pod.spec?.containers?.find((containerSpec) => containerSpec.name === 'shard-server')
+  if (!containerSpec) {
+    return null
+  }
+  if (!containerSpec.image) {
+    return null
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const [_, imageTag] = containerSpec.image.split(':')
+  return imageTag
+}
+
+function resolvePodStatus(pod: V1Pod, requiredImageTag: string | null): GameServerPodStatus {
   // logger.debug('resolvePodStatus(): pod =', JSON.stringify(pod, undefined, 2))
 
   if (!pod) {
@@ -152,26 +266,49 @@ function resolvePodStatus (pod: V1Pod): GameServerPodStatus {
     return { phase: GameServerPodPhase.Unknown, message: 'Unable to access pod.status from Kubernetes' }
   }
 
+  // Check the pod has the expected image.
+  if (requiredImageTag !== null) {
+    const podImageTag = resolvePodGameServerImageTag(pod)
+    if (podImageTag !== requiredImageTag) {
+      return {
+        phase: GameServerPodPhase.Unknown,
+        message: `Image tag is not (yet?) updated. Pod image is ${podImageTag ?? 'unknown'}, expecting ${requiredImageTag}.`,
+      }
+    }
+  }
+
   // Handle status.phase
   const podPhase = pod.status?.phase
   switch (podPhase) {
     case 'Pending':
       // Pod not yet scheduled
-      return { phase: GameServerPodPhase.Pending, message: 'Pod is still in Pending phase' }
+      return resolvePendingPodStatusConditions(pod)
 
     case 'Running':
       // Pod has been scheduled and start -- note that the containers may have failed!
-      return resolvePodStatusConditions(pod)
+      return resolveRunningPodStatusConditions(pod)
+
+    case 'Succeeded':
+      // Should not happen, the game server pods should never stop
+      return {
+        phase: GameServerPodPhase.Unknown,
+        message: 'Pod has unexpectedly terminated (with a clean exit status)',
+      }
+
+    case 'Failed':
+      // Should not happen, the game server pods should never stop
+      return {
+        phase: GameServerPodPhase.Unknown,
+        message: 'Pod has unexpectedly terminated (with a failure exit status)',
+      }
 
-    case 'Succeeded': // Should not happen, the game server pods should never stop
-    case 'Failed': // Should not happen, the game server pods should never stop
     case 'Unknown':
     default:
       return { phase: GameServerPodPhase.Unknown, message: `Invalid pod.status.phase: ${podPhase}` }
   }
 }
 
-async function fetchPodLogs (k8sApi: CoreV1Api, pod: V1Pod) {
+async function fetchPodLogs(k8sApi: CoreV1Api, pod: V1Pod): Promise<string> {
   const podName = pod.metadata?.name
   logger.debug(`Fetching logs for pod '${podName}'..`)
   const namespace = pod.metadata?.namespace
@@ -187,7 +324,7 @@ async function fetchPodLogs (k8sApi: CoreV1Api, pod: V1Pod) {
     pretty: 'true',
     previous: false,
     tailLines: 100,
-    timestamps: true
+    timestamps: true,
   }
 
   try {
@@ -200,11 +337,15 @@ async function fetchPodLogs (k8sApi: CoreV1Api, pod: V1Pod) {
   }
 }
 
-async function checkGameServerPod (k8sApi: CoreV1Api, pod: V1Pod) {
+async function checkGameServerPod(
+  k8sApi: CoreV1Api,
+  pod: V1Pod,
+  requiredImageTag: string | null
+): Promise<GameServerPodStatus> {
   // console.log('Pod:', JSON.stringify(pod, undefined, 2))
 
   // Classify game server status
-  const podStatus = resolvePodStatus(pod)
+  const podStatus = resolvePodStatus(pod, requiredImageTag)
   const podName = pod.metadata?.name ?? '<unable to resolve name>'
 
   // If game server launch failed, get the error logs
@@ -217,19 +358,23 @@ async function checkGameServerPod (k8sApi: CoreV1Api, pod: V1Pod) {
   return podStatus
 }
 
-async function delay (ms: number): Promise<void> {
-  return await new Promise<void>(resolve => setTimeout(resolve, ms))
+async function delay(ms: number): Promise<void> {
+  await new Promise<void>((resolve) => setTimeout(resolve, ms))
 }
 
-function anyPodsInPhase (podStatuses: GameServerPodStatus[], phase: GameServerPodPhase): boolean {
-  return podStatuses.some(status => status.phase === phase)
+function anyPodsInPhase(podStatuses: GameServerPodStatus[], phase: GameServerPodPhase): boolean {
+  return podStatuses.some((status) => status.phase === phase)
 }
 
-function allPodsInPhase (podStatuses: GameServerPodStatus[], phase: GameServerPodPhase): boolean {
-  return podStatuses.every(status => status.phase === phase)
+function allPodsInPhase(podStatuses: GameServerPodStatus[], phase: GameServerPodPhase): boolean {
+  return podStatuses.every((status) => status.phase === phase)
 }
 
-export async function checkGameServerDeployment (namespace: string, kubeconfig: KubeConfig): Promise<number> {
+export async function checkGameServerDeployment(
+  namespace: string,
+  kubeconfig: KubeConfig,
+  requiredImageTag: string | null
+): Promise<number> {
   const k8sApi = kubeconfig.makeApiClient(CoreV1Api)
 
   // Figure out when to stop
@@ -242,8 +387,10 @@ export async function checkGameServerDeployment (namespace: string, kubeconfig:
     logger.debug(`Found ${pods?.length} pod(s) deployed in Kubernetes`)
     if (pods.length > 0) {
       // Resolve status for all pods
-      const podStatuses = await Promise.all(pods.map(async pod => await checkGameServerPod(k8sApi, pod)))
-      logger.debug(`Pod phases: ${podStatuses.map(status => status.phase)}`)
+      const podStatuses = await Promise.all(
+        pods.map(async (pod) => await checkGameServerPod(k8sApi, pod, requiredImageTag))
+      )
+      logger.debug(`Pod phases: ${podStatuses.map((status) => status.phase).toString()}`)
 
       // Handle state of the deployment
       if (anyPodsInPhase(podStatuses, GameServerPodPhase.Failed)) {
@@ -251,15 +398,19 @@ export async function checkGameServerDeployment (namespace: string, kubeconfig:
         console.log('Gameserver failed to start due to the pods not starting properly! See above for details.')
         for (let ndx = 0; ndx < pods.length; ndx += 1) {
           const status = podStatuses[ndx]
-          const suffix = (status.phase !== GameServerPodPhase.Ready) ? ` -- ${status.message}` : ''
+          const suffix = status.phase !== GameServerPodPhase.Ready ? ` -- ${status.message}` : ''
           console.log(`  ${pods[ndx].metadata?.name}: ${status.phase}${suffix}`)
         }
         return 1
-      } else if (anyPodsInPhase(podStatuses, GameServerPodPhase.Unknown) || anyPodsInPhase(podStatuses, GameServerPodPhase.Pending) || anyPodsInPhase(podStatuses, GameServerPodPhase.Running)) {
+      } else if (
+        anyPodsInPhase(podStatuses, GameServerPodPhase.Unknown) ||
+        anyPodsInPhase(podStatuses, GameServerPodPhase.Pending) ||
+        anyPodsInPhase(podStatuses, GameServerPodPhase.Running)
+      ) {
         console.log('Waiting for gameserver(s) to be ready...')
         for (let ndx = 0; ndx < pods.length; ndx += 1) {
           const status = podStatuses[ndx]
-          const suffix = (status.phase !== GameServerPodPhase.Ready) ? ` -- ${status.message}` : ''
+          const suffix = status.phase !== GameServerPodPhase.Ready ? ` -- ${status.message}` : ''
           console.log(`  ${pods[ndx].metadata?.name}: ${status.phase}${suffix}`)
         }
       } else if (allPodsInPhase(podStatuses, GameServerPodPhase.Ready)) {
@@ -270,7 +421,7 @@ export async function checkGameServerDeployment (namespace: string, kubeconfig:
         console.log('Deployment in inconsistent state, waiting...')
         for (let ndx = 0; ndx < pods.length; ndx += 1) {
           const status = podStatuses[ndx]
-          const suffix = (status.phase !== GameServerPodPhase.Ready) ? ` -- ${status.message}` : ''
+          const suffix = status.phase !== GameServerPodPhase.Ready ? ` -- ${status.message}` : ''
           console.log(`  ${pods[ndx].metadata?.name}: ${status.phase}${suffix}`)
         }
       }
@@ -285,3 +436,85 @@ export async function checkGameServerDeployment (namespace: string, kubeconfig:
     await delay(2000)
   }
 }
+
+export async function debugGameServer(targetEnv: TargetEnvironment, targetPodName?: string): Promise<void> {
+  // Initialize kubeconfig for target environment
+  logger.debug('Get kubeconfig')
+  let kubeconfigPayload: string
+  const kubeconfig = new KubeConfig()
+  try {
+    kubeconfigPayload = await targetEnv.getKubeConfigWithEmbeddedCredentials()
+    kubeconfig.loadFromString(kubeconfigPayload)
+  } catch (error) {
+    const errMessage = error instanceof Error ? error.message : String(error)
+    console.error(`Failed to fetch kubeconfig for environment: ${errMessage}`)
+    exit(1)
+  }
+
+  // Fetch environment details
+  logger.debug('Get environment details')
+  const envInfo = await targetEnv.getEnvironmentDetails()
+  const kubernetesNamespace = envInfo.deployment.kubernetes_namespace
+
+  // Resolve which pods are running in the target environment
+  logger.debug('Get running game server pods')
+  const k8sApi = kubeconfig.makeApiClient(CoreV1Api)
+  const gameServerPods = await fetchGameServerPods(k8sApi, kubernetesNamespace)
+
+  // If no pod name is specified, automaticalyl target a singleton pod or fail if there are multiple
+  if (!targetPodName) {
+    if (gameServerPods.length === 1) {
+      const metadata = gameServerPods[0].metadata
+      if (!metadata?.name) {
+        throw new Error('Unable to resolve name for the Kubernetes pod!')
+      }
+      targetPodName = metadata.name
+    } else {
+      const podNames = gameServerPods.map((pod) => pod.metadata?.name).join(', ')
+      console.error(`Multiple game server pods running: ${podNames}\nPlease specify which you want to debug.`)
+      exit(1)
+    }
+  }
+
+  // Execute 'kubectl debug ..'
+  const tmpKubeconfigPath = path.join(os.tmpdir(), `temp-kubeconfig-${+Date.now()}`)
+  try {
+    // Write kubeconfig to a file
+    logger.debug(`Write temporary kubeconfig to ${tmpKubeconfigPath}`)
+    await writeFile(tmpKubeconfigPath, kubeconfigPayload)
+
+    // Run kubctl
+    // const args = [`--kubeconfig=${tmpKubeconfigPath}`, `--namespace=${kubernetesNamespace}`, 'get', 'pods']
+    const args = [
+      `--kubeconfig=${tmpKubeconfigPath}`,
+      `--namespace=${kubernetesNamespace}`,
+      'debug',
+      targetPodName,
+      '-it',
+      '--profile=general',
+      '--image=metaplay/diagnostics:latest',
+      '--target=shard-server',
+    ]
+    console.log(`Execute: kubectl ${args.join(' ')}`)
+    const execResult = await executeCommand('kubectl', args, { inheritStdio: true })
+
+    // Remove temporary kubeconfig
+    logger.debug('Delete temporary kubeconfig')
+    await unlink(tmpKubeconfigPath)
+
+    // Forward exit code
+    if (execResult?.exitCode !== 0) {
+      console.error(`kubectl failed failed with exit code ${execResult.exitCode}`)
+      exit(execResult.exitCode)
+    }
+  } catch (err) {
+    const errMessage = err instanceof Error ? err.message : String(err)
+    console.error(
+      `Failed to execute 'kubectl': ${errMessage}. You need to have kubectl installed to debug a game server with metaplay-auth.`
+    )
+
+    // Remove temporary kubeconfig
+    logger.debug('Delete temporary kubeconfig')
+    await unlink(tmpKubeconfigPath)
+  }
+}

package/src/logging.ts

@@ -5,15 +5,15 @@ import { Logger } from 'tslog'
  */
 export const logger = new Logger({
   overwrite: {
-    transportFormatted (logMetaMarkup, logArgs, logErrors, settings) {
+    transportFormatted(logMetaMarkup, logArgs, logErrors): void {
       console.error(`${logMetaMarkup} ${logArgs.join('')} ${logErrors.join('')}`)
-    }
-  }
+    },
+  },
 })
 
 /**
  * Set the log level. We use 0 and 10.
  */
-export function setLogLevel (level: number): void {
+export function setLogLevel(level: number): void {
   logger.settings.minLevel = level
 }

package/src/secret_store.ts

@@ -11,7 +11,7 @@ const salt: string = process.env.METAPLAY_AUTH_SALT ?? 'saltysalt'
 
 type Secrets = Record<string, string>
 
-async function loadSecrets (): Promise<Secrets> {
+async function loadSecrets(): Promise<Secrets> {
   try {
     logger.debug(`Loading secrets from ${filePath}...`)
 
@@ -37,11 +37,12 @@ async function loadSecrets (): Promise<Secrets> {
     if (password.length === 0) {
       throw new Error('The file is encrypted. Please set the METAPLAY_AUTH_PASSWORD environment variable.')
     }
+    // eslint-disable-next-line @typescript-eslint/only-throw-error
     throw error
   }
 }
 
-function encrypt (text: string): string {
+function encrypt(text: string): string {
   const key = scryptSync(password, salt, 32)
   const iv = randomBytes(16) // Generate a 16-byte IV
   const cipher = createCipheriv(algorithm, key, iv)
@@ -49,13 +50,14 @@ function encrypt (text: string): string {
   return iv.toString('hex') + ':' + encrypted.toString('hex') // Store IV with the encrypted data
 }
 
-function decrypt (text: string): string {
+function decrypt(text: string): string {
   const textParts = text.split(':')
   if (textParts.length !== 2) {
     throw new Error('Invalid encrypted data format.')
   }
   const iv = Buffer.from(textParts[0], 'hex')
-  if (iv.length !== 16) { // Ensure the IV is 16 bytes
+  if (iv.length !== 16) {
+    // Ensure the IV is 16 bytes
     throw new Error('Invalid IV length.')
   }
   const encryptedText = Buffer.from(textParts[1], 'hex')
@@ -65,7 +67,7 @@ function decrypt (text: string): string {
   return decrypted.toString()
 }
 
-export async function setSecret (key: string, value: any): Promise<void> {
+export async function setSecret(key: string, value: any): Promise<void> {
   logger.debug(`Setting secret ${key}...`)
 
   const secrets = await loadSecrets()
@@ -75,17 +77,18 @@ export async function setSecret (key: string, value: any): Promise<void> {
   await fs.writeFile(filePath, content)
 }
 
-export async function getSecret (key: string): Promise<any | undefined> {
+export async function getSecret(key: string): Promise<any | undefined> {
   logger.debug(`Getting secret ${key}...`)
 
   const secrets = await loadSecrets()
   return secrets[key]
 }
 
-export async function removeSecret (key: string): Promise<void> {
+export async function removeSecret(key: string): Promise<void> {
   logger.debug(`Removing secret ${key}...`)
 
   const currentSecrets = await loadSecrets()
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   const { [key]: _, ...secrets } = currentSecrets // remove key from secrets
 
   const secretJson = JSON.stringify(secrets)