feat: [wip] self updates

Author: jakeaturner

admin/app/controllers/settings_controller.ts

@@ -43,6 +43,17 @@ export default class SettingsController {
         });
     }
 
+    async update({ inertia }: HttpContext) {
+        const updateInfo = await this.systemService.checkLatestVersion();
+        return inertia.render('settings/update', {
+            system: {
+                updateAvailable: updateInfo.updateAvailable,
+                latestVersion: updateInfo.latestVersion,
+                currentVersion: updateInfo.currentVersion
+            }
+        });
+    }
+
     async zim({ inertia }: HttpContext) {
         return inertia.render('settings/zim/index')
     }

admin/app/controllers/system_controller.ts

@@ -1,5 +1,6 @@
 import { DockerService } from '#services/docker_service';
 import { SystemService } from '#services/system_service'
+import { SystemUpdateService } from '#services/system_update_service'
 import { affectServiceValidator, installServiceValidator } from '#validators/system';
 import { inject } from '@adonisjs/core'
 import type { HttpContext } from '@adonisjs/core/http'
@@ -8,7 +9,8 @@ import type { HttpContext } from '@adonisjs/core/http'
 export default class SystemController {
     constructor(
         private systemService: SystemService,
-        private dockerService: DockerService
+        private dockerService: DockerService,
+        private systemUpdateService: SystemUpdateService
     ) { }
 
     async getInternetStatus({ }: HttpContext) {
@@ -43,4 +45,51 @@ export default class SystemController {
         }
         response.send({ success: result.success, message: result.message });
     }
+
+    async checkLatestVersion({ }: HttpContext) {
+        return await this.systemService.checkLatestVersion();
+    }
+
+    async requestSystemUpdate({ response }: HttpContext) {
+        if (!this.systemUpdateService.isSidecarAvailable()) {
+            response.status(503).send({
+                success: false,
+                error: 'Update sidecar is not available. Ensure the updater container is running.',
+            });
+            return;
+        }
+
+        const result = await this.systemUpdateService.requestUpdate();
+
+        if (result.success) {
+            response.send({
+                success: true,
+                message: result.message,
+                note: 'Monitor update progress via GET /api/system/update/status. The connection may drop during container restart.',
+            });
+        } else {
+            response.status(409).send({
+                success: false,
+                error: result.message,
+            });
+        }
+    }
+
+    async getSystemUpdateStatus({ response }: HttpContext) {
+        const status = this.systemUpdateService.getUpdateStatus();
+
+        if (!status) {
+            response.status(500).send({
+                error: 'Failed to retrieve update status',
+            });
+            return;
+        }
+
+        response.send(status);
+    }
+
+    async getSystemUpdateLogs({ response }: HttpContext) {
+        const logs = this.systemUpdateService.getUpdateLogs();
+        response.send({ logs });
+    }
 }

admin/app/services/system_service.ts

@@ -62,7 +62,16 @@ export class SystemService {
 
     const query = Service.query()
       .orderBy('friendly_name', 'asc')
-      .select('id', 'service_name', 'installed', 'installation_status', 'ui_location', 'friendly_name', 'description', 'icon')
+      .select(
+        'id',
+        'service_name',
+        'installed',
+        'installation_status',
+        'ui_location',
+        'friendly_name',
+        'description',
+        'icon'
+      )
       .where('is_dependency_service', false)
     if (installedOnly) {
       query.where('installed', true)
@@ -166,6 +175,52 @@ export class SystemService {
     }
   }
 
+  async checkLatestVersion(): Promise<{
+    success: boolean
+    updateAvailable: boolean
+    currentVersion: string
+    latestVersion: string
+    message?: string
+  }> {
+    try {
+      const response = await axios.get(
+        'https://api.github.com/repos/Crosstalk-Solutions/project-nomad/releases/latest',
+        {
+          headers: { Accept: 'application/vnd.github+json' },
+          timeout: 5000,
+        }
+      )
+
+      if (!response || !response.data?.tag_name) {
+        throw new Error('Invalid response from GitHub API')
+      }
+
+      const latestVersion = response.data.tag_name.replace(/^v/, '') // Remove leading 'v' if present
+      const currentVersion = SystemService.getAppVersion()
+
+      logger.info(`Current version: ${currentVersion}, Latest version: ${latestVersion}`)
+
+      // NOTE: this will always return true in dev environment! See getAppVersion()
+      const updateAvailable = latestVersion !== currentVersion
+
+      return {
+        success: true,
+        updateAvailable,
+        currentVersion,
+        latestVersion,
+      }
+    } catch (error) {
+      logger.error('Error checking latest version:', error)
+      return {
+        success: false,
+        updateAvailable: false,
+        currentVersion: '',
+        latestVersion: '',
+        message: `Failed to check latest version: ${error instanceof Error ? error.message : error}`,
+      }
+    }
+  }
+
   /**
    * Checks the current state of Docker containers against the database records and updates the database accordingly.
    * It will mark services as not installed if their corresponding containers are not running, and can also handle cleanup of any orphaned records.

admin/app/services/system_update_service.ts

@@ -0,0 +1,95 @@
+import logger from '@adonisjs/core/services/logger'
+import { readFileSync, existsSync } from 'fs'
+import { writeFile } from 'fs/promises'
+import { join } from 'path'
+
+interface UpdateStatus {
+  stage: 'idle' | 'starting' | 'pulling' | 'pulled' | 'recreating' | 'complete' | 'error'
+  progress: number
+  message: string
+  timestamp: string
+}
+
+export class SystemUpdateService {
+  private static SHARED_DIR = '/app/update-shared'
+  private static REQUEST_FILE = join(SystemUpdateService.SHARED_DIR, 'update-request')
+  private static STATUS_FILE = join(SystemUpdateService.SHARED_DIR, 'update-status')
+  private static LOG_FILE = join(SystemUpdateService.SHARED_DIR, 'update-log')
+
+  /**
+   * Requests a system update by creating a request file that the sidecar will detect
+   */
+  async requestUpdate(): Promise<{ success: boolean; message: string }> {
+    try {
+      const currentStatus = this.getUpdateStatus()      
+      if (currentStatus && !['idle', 'complete', 'error'].includes(currentStatus.stage)) {
+        return {
+          success: false,
+          message: `Update already in progress (stage: ${currentStatus.stage})`,
+        }
+      }
+
+      const requestData = {
+        requested_at: new Date().toISOString(),
+        requester: 'admin-api',
+      }
+
+      await writeFile(SystemUpdateService.REQUEST_FILE, JSON.stringify(requestData, null, 2))
+      logger.info('[SystemUpdateService]: System update requested - sidecar will process shortly')
+
+      return {
+        success: true,
+        message: 'System update initiated. The admin container will restart during the process.',
+      }
+    } catch (error) {
+      logger.error('[SystemUpdateService]: Failed to request system update:', error)
+      return {
+        success: false,
+        message: `Failed to request update: ${error.message}`,
+      }
+    }
+  }
+
+  getUpdateStatus(): UpdateStatus | null {
+    try {
+      if (!existsSync(SystemUpdateService.STATUS_FILE)) {
+        return {
+          stage: 'idle',
+          progress: 0,
+          message: 'No update in progress',
+          timestamp: new Date().toISOString(),
+        }
+      }
+
+      const statusContent = readFileSync(SystemUpdateService.STATUS_FILE, 'utf-8')
+      return JSON.parse(statusContent) as UpdateStatus
+    } catch (error) {
+      logger.error('[SystemUpdateService]: Failed to read update status:', error)
+      return null
+    }
+  }
+
+  getUpdateLogs(): string {
+    try {
+      if (!existsSync(SystemUpdateService.LOG_FILE)) {
+        return 'No update logs available'
+      }
+
+      return readFileSync(SystemUpdateService.LOG_FILE, 'utf-8')
+    } catch (error) {
+      logger.error('[SystemUpdateService]: Failed to read update logs:', error)
+      return `Error reading logs: ${error.message}`
+    }
+  }
+
+  /**
+   * Check if the update sidecar is reachable (i.e. shared volume is mounted)
+   */
+  isSidecarAvailable(): boolean {
+    try {
+      return existsSync(SystemUpdateService.SHARED_DIR)
+    } catch (error) {
+      return false
+    }
+  }
+}

admin/inertia/layouts/SettingsLayout.tsx

@@ -4,7 +4,7 @@ import {
   FolderIcon,
   MagnifyingGlassIcon,
 } from '@heroicons/react/24/outline'
-import { IconDashboard, IconGavel, IconMapRoute } from '@tabler/icons-react'
+import { IconArrowBigUpLines, IconDashboard, IconGavel, IconMapRoute } from '@tabler/icons-react'
 import StyledSidebar from '~/components/StyledSidebar'
 import { getServiceLink } from '~/lib/navigation'
 
@@ -26,6 +26,12 @@ const navigation = [
     icon: MagnifyingGlassIcon,
     current: false,
   },
+  {
+    name: 'Check for Updates',
+    href: '/settings/update',
+    icon: IconArrowBigUpLines,
+    current: false,
+  },
   { name: 'System', href: '/settings/system', icon: Cog6ToothIcon, current: true },
 ]
 

admin/inertia/lib/api.ts

@@ -2,7 +2,7 @@ import axios, { AxiosInstance } from 'axios'
 import { ListRemoteZimFilesResponse, ListZimFilesResponse } from '../../types/zim'
 import { ServiceSlim } from '../../types/services'
 import { FileEntry } from '../../types/files'
-import { SystemInformationResponse } from '../../types/system'
+import { SystemInformationResponse, SystemUpdateStatus } from '../../types/system'
 import { CuratedCollectionWithStatus, DownloadJobWithProgress } from '../../types/downloads'
 import { catchInternal } from './util'
 
@@ -116,6 +116,29 @@ class API {
     })()
   }
 
+  async getSystemUpdateStatus() {
+    return catchInternal(async () => {
+      const response = await this.client.get<SystemUpdateStatus>('/system/update/status')
+      return response.data
+    })()
+  }
+
+  async getSystemUpdateLogs() {
+    return catchInternal(async () => {
+      const response = await this.client.get<{ logs: string }>('/system/update/logs')
+      return response.data
+    })()
+  }
+
+  async healthCheck() {
+    return catchInternal(async () => {
+      const response = await this.client.get<{ status: string }>('/health', {
+        timeout: 5000,
+      })
+      return response.data
+    })()
+  }
+
   async installService(service_name: string) {
     return catchInternal(async () => {
       const response = await this.client.post<{ success: boolean; message: string }>(
@@ -198,6 +221,15 @@ class API {
       return response.data
     })()
   }
+
+  async startSystemUpdate() {
+    return catchInternal(async () => {
+      const response = await this.client.post<{ success: boolean; message: string }>(
+        '/system/update'
+      )
+      return response.data
+    })()
+  }
 }
 
 export default new API()