@tothalex/nulljs 0.0.40

package/src/lib/update-server.ts

@@ -0,0 +1,180 @@
+import { existsSync, createWriteStream, chmodSync, unlinkSync, mkdirSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import https from 'node:https'
+import * as tar from 'tar'
+import chalk from 'chalk'
+
+interface PlatformInfo {
+  target: string
+  extension: string
+  binaryName: string
+}
+
+function getPlatformInfo(): PlatformInfo {
+  const platform = process.platform
+  const arch = process.arch
+
+  const platformMap: Record<string, Record<string, string>> = {
+    linux: {
+      x64: 'x86_64-unknown-linux-gnu',
+      arm64: 'aarch64-unknown-linux-gnu'
+    },
+    darwin: {
+      x64: 'x86_64-apple-darwin',
+      arm64: 'aarch64-apple-darwin'
+    }
+  }
+
+  const target = platformMap[platform]?.[arch]
+  if (!target) {
+    throw new Error(`Unsupported platform: ${platform}-${arch}`)
+  }
+
+  const extension = '.tar.gz'
+  const binaryName = 'server'
+
+  return { target, extension, binaryName }
+}
+
+async function downloadFile(url: string, destination: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const file = createWriteStream(destination)
+
+    https
+      .get(url, (response) => {
+        if (response.statusCode === 302 || response.statusCode === 301) {
+          // Handle redirect
+          return downloadFile(response.headers.location!, destination).then(resolve).catch(reject)
+        }
+
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to download: ${response.statusCode}`))
+          return
+        }
+
+        response.pipe(file)
+
+        file.on('finish', () => {
+          file.close()
+          resolve()
+        })
+
+        file.on('error', reject)
+      })
+      .on('error', reject)
+  })
+}
+
+async function extractArchive(
+  archivePath: string,
+  extractPath: string,
+  binaryName: string
+): Promise<void> {
+  // Extract tar.gz
+  await tar.x({
+    file: archivePath,
+    cwd: extractPath
+  })
+
+  // Make binary executable
+  const binaryPath = join(extractPath, binaryName)
+  chmodSync(binaryPath, '755')
+}
+
+async function getLatestReleaseUrl(target: string, extension: string): Promise<string> {
+  const baseUrl = 'https://nulljs.s3.eu-north-1.amazonaws.com/releases'
+  return `${baseUrl}/nulljs-server-${target}/nulljs-server-${target}${extension}`
+}
+
+function getServerBinPath(): string {
+  // Try to find the server binary relative to this module
+  // This works both in development and when installed globally
+  const currentFile = fileURLToPath(import.meta.url)
+  const moduleRoot = join(dirname(currentFile), '../..')
+  return join(moduleRoot, 'bin', 'server')
+}
+
+export async function updateServer(): Promise<void> {
+  try {
+    console.log(chalk.blue('🔄 Updating nulljs server binary...'))
+
+    const { target, extension, binaryName } = getPlatformInfo()
+
+    const serverBinPath = getServerBinPath()
+    const binDir = dirname(serverBinPath)
+    const archivePath = join(binDir, `server${extension}`)
+    const backupPath = join(binDir, 'server.backup')
+
+    // Create bin directory if it doesn't exist
+    if (!existsSync(binDir)) {
+      mkdirSync(binDir, { recursive: true })
+    }
+
+    // Backup existing binary if it exists
+    if (existsSync(serverBinPath)) {
+      console.log(chalk.blue('💾 Backing up existing binary...'))
+
+      // Remove old backup if it exists
+      if (existsSync(backupPath)) {
+        unlinkSync(backupPath)
+      }
+
+      // Create backup
+      const fs = await import('node:fs/promises')
+      await fs.copyFile(serverBinPath, backupPath)
+      console.log(chalk.green('✅ Backup created'))
+    }
+
+    console.log(chalk.blue(`🔍 Downloading latest server for ${target}...`))
+
+    // Get download URL from latest release
+    const downloadUrl = await getLatestReleaseUrl(target, extension)
+
+    try {
+      // Download the archive
+      await downloadFile(downloadUrl, archivePath)
+      console.log(chalk.green('✅ Download completed'))
+
+      // Remove existing binary before extracting new one
+      if (existsSync(serverBinPath)) {
+        unlinkSync(serverBinPath)
+      }
+
+      // Extract the binary
+      console.log(chalk.blue('📂 Extracting binary...'))
+      await extractArchive(archivePath, binDir, binaryName)
+
+      // Clean up archive
+      unlinkSync(archivePath)
+
+      // Remove backup since update was successful
+      if (existsSync(backupPath)) {
+        unlinkSync(backupPath)
+      }
+
+      console.log(chalk.green('✅ nulljs server updated successfully'))
+    } catch (error) {
+      // If update failed and we have a backup, restore it
+      if (existsSync(backupPath)) {
+        console.log(chalk.yellow('⚠️  Update failed, restoring backup...'))
+
+        if (existsSync(serverBinPath)) {
+          unlinkSync(serverBinPath)
+        }
+
+        const fs = await import('node:fs/promises')
+        await fs.copyFile(backupPath, serverBinPath)
+        unlinkSync(backupPath)
+
+        console.log(chalk.green('✅ Backup restored'))
+      }
+
+      throw error
+    }
+  } catch (error) {
+    console.error(chalk.red('❌ Failed to update server binary:'), error.message)
+    throw error
+  }
+}
+