@metaplay/metaplay-auth 1.5.0 → 1.6.0

package/src/deployment.ts

@@ -1,9 +1,15 @@
-import { KubeConfig, CoreV1Api, type V1Pod, type CoreV1ApiListNamespacedPodRequest, type CoreV1ApiReadNamespacedPodLogRequest } from '@kubernetes/client-node'
+import {
+  KubeConfig,
+  CoreV1Api,
+  type V1Pod,
+  type CoreV1ApiListNamespacedPodRequest,
+  type CoreV1ApiReadNamespacedPodLogRequest,
+} from '@kubernetes/client-node'
 import { logger } from './logging.js'
 import { TargetEnvironment } from 'targetenvironment.js'
 import { exit } from 'process'
 import { unlink, writeFile } from 'fs/promises'
-import { executeCommand, type ExecuteCommandResult } from './utils.js'
+import { executeCommand } from './utils.js'
 import os from 'os'
 import path from 'path'
 
@@ -21,12 +27,12 @@ interface GameServerPodStatus {
   details?: any
 }
 
-async function fetchGameServerPods (k8sApi: CoreV1Api, namespace: string): Promise<V1Pod[]> {
+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 {
@@ -42,20 +48,25 @@ async function fetchGameServerPods (k8sApi: CoreV1Api, namespace: string): Promi
   }
 }
 
-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' }
@@ -65,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)
@@ -83,21 +111,45 @@ function resolvePodContainersConditions (pod: V1Pod): GameServerPodStatus {
       if (containerState.waiting) {
         const reason = containerState.waiting.reason
         if (reason && knownContainerFailureReasons.includes(reason)) {
-          return { phase: GameServerPodPhase.Failed, message: `Container ${containerName} is in waiting state, reason=${reason}`, details: containerState.waiting }
+          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 }
+          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)
@@ -108,58 +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 resolvePodGameServerImageTag (pod: V1Pod): string | null {
+/**
+ * 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')
+  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 {
+function resolvePodStatus(pod: V1Pod, requiredImageTag: string | null): GameServerPodStatus {
   // logger.debug('resolvePodStatus(): pod =', JSON.stringify(pod, undefined, 2))
 
   if (!pod) {
@@ -174,7 +270,10 @@ function resolvePodStatus (pod: V1Pod, requiredImageTag: string | null): GameSer
   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}.` }
+      return {
+        phase: GameServerPodPhase.Unknown,
+        message: `Image tag is not (yet?) updated. Pod image is ${podImageTag ?? 'unknown'}, expecting ${requiredImageTag}.`,
+      }
     }
   }
 
@@ -183,19 +282,25 @@ function resolvePodStatus (pod: V1Pod, requiredImageTag: string | null): GameSer
   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)' }
+      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)' }
+      return {
+        phase: GameServerPodPhase.Unknown,
+        message: 'Pod has unexpectedly terminated (with a failure exit status)',
+      }
 
     case 'Unknown':
     default:
@@ -203,7 +308,7 @@ function resolvePodStatus (pod: V1Pod, requiredImageTag: string | null): GameSer
   }
 }
 
-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
@@ -219,7 +324,7 @@ async function fetchPodLogs (k8sApi: CoreV1Api, pod: V1Pod) {
     pretty: 'true',
     previous: false,
     tailLines: 100,
-    timestamps: true
+    timestamps: true,
   }
 
   try {
@@ -232,7 +337,11 @@ async function fetchPodLogs (k8sApi: CoreV1Api, pod: V1Pod) {
   }
 }
 
-async function checkGameServerPod (k8sApi: CoreV1Api, pod: V1Pod, requiredImageTag: string | null) {
+async function checkGameServerPod(
+  k8sApi: CoreV1Api,
+  pod: V1Pod,
+  requiredImageTag: string | null
+): Promise<GameServerPodStatus> {
   // console.log('Pod:', JSON.stringify(pod, undefined, 2))
 
   // Classify game server status
@@ -249,19 +358,23 @@ async function checkGameServerPod (k8sApi: CoreV1Api, pod: V1Pod, requiredImageT
   return podStatus
 }
 
-async function delay (ms: number): Promise<void> {
-  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, requiredImageTag: string | null): 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
@@ -274,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, requiredImageTag)))
-      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)) {
@@ -283,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)) {
@@ -302,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}`)
         }
       }
@@ -318,16 +437,17 @@ export async function checkGameServerDeployment (namespace: string, kubeconfig:
   }
 }
 
-export async function debugGameServer (targetEnv: TargetEnvironment, targetPodName?: string) {
+export async function debugGameServer(targetEnv: TargetEnvironment, targetPodName?: string): Promise<void> {
   // Initialize kubeconfig for target environment
   logger.debug('Get kubeconfig')
-  let kubeconfigPayload
+  let kubeconfigPayload: string
   const kubeconfig = new KubeConfig()
   try {
-    kubeconfigPayload = await targetEnv.getKubeConfig()
+    kubeconfigPayload = await targetEnv.getKubeConfigWithEmbeddedCredentials()
     kubeconfig.loadFromString(kubeconfigPayload)
   } catch (error) {
-    console.error(`Failed to fetch kubeconfig for environment: ${error}`)
+    const errMessage = error instanceof Error ? error.message : String(error)
+    console.error(`Failed to fetch kubeconfig for environment: ${errMessage}`)
     exit(1)
   }
 
@@ -350,7 +470,7 @@ export async function debugGameServer (targetEnv: TargetEnvironment, targetPodNa
       }
       targetPodName = metadata.name
     } else {
-      const podNames = gameServerPods.map(pod => pod.metadata?.name).join(', ')
+      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)
     }
@@ -373,10 +493,10 @@ export async function debugGameServer (targetEnv: TargetEnvironment, targetPodNa
       '-it',
       '--profile=general',
       '--image=metaplay/diagnostics:latest',
-      '--target=shard-server'
+      '--target=shard-server',
     ]
     console.log(`Execute: kubectl ${args.join(' ')}`)
-    const execResult = await executeCommand('kubectl', args, true)
+    const execResult = await executeCommand('kubectl', args, { inheritStdio: true })
 
     // Remove temporary kubeconfig
     logger.debug('Delete temporary kubeconfig')
@@ -388,7 +508,10 @@ export async function debugGameServer (targetEnv: TargetEnvironment, targetPodNa
       exit(execResult.exitCode)
     }
   } catch (err) {
-    console.error(`Failed to execute 'kubectl': ${err}. You need to have kubectl installed to debug a game server with metaplay-auth.`)
+    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')

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)

package/src/stackapi.ts

@@ -1,13 +1,9 @@
-import { logger } from './logging.js'
-import { type EnvironmentDetails } from './targetenvironment.js'
-
-export const defaultStackApiBaseUrl = 'https://infra.p1.metaplay.io/stackapi'
-
+// \note Unused right now but will likely need this back later
 export class StackAPI {
   private readonly accessToken: string
   private readonly stackApiBaseUrl: string
 
-  constructor (accessToken: string, stackApiBaseUrl: string | undefined) {
+  constructor(accessToken: string, stackApiBaseUrl: string | undefined) {
     if (accessToken == null) {
       throw new Error('accessToken must be provided')
     }
@@ -20,31 +16,4 @@ export class StackAPI {
       this.stackApiBaseUrl = 'https://infra.p1.metaplay.io/stackapi'
     }
   }
-
-  async resolveManagedEnvironmentFQDN (organization: string, project: string, environment: string): Promise<string> {
-    const url = `${this.stackApiBaseUrl}/v1/servers/${organization}/${project}/${environment}`
-    logger.debug(`Getting environment information from ${url}...`)
-    const response = await fetch(url, {
-      method: 'GET',
-      headers: {
-        Authorization: `Bearer ${this.accessToken}`,
-        'Content-Type': 'application/json'
-      }
-    })
-
-    // Throw on server errors (eg, forbidden)
-    if (!response.ok) {
-      const errorData = await response.json()
-      throw new Error(`Failed to fetch environment details with error ${response.status}: ${JSON.stringify(errorData)}`)
-    }
-
-    // Sanity check that response is of the right structure
-    const envDetails = await response.json() as EnvironmentDetails
-    logger.debug(`Received environment details: ${JSON.stringify(envDetails)}`)
-    if (!envDetails.deployment) {
-      throw new Error(`Received invalid environment details -- missing .deployment: ${JSON.stringify(envDetails)}`)
-    }
-
-    return envDetails.deployment.server_hostname
-  }
 }