feat(desktop): add app and local daemon update controls in Settings

2026-02-22 10:40:12 +07:00
parent d7e2ab4437
commit 231b83dbc2
9 changed files with 1196 additions and 8 deletions
@@ -0,0 +1,110 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import type { HostProfile } from '@/contexts/daemon-registry-context'
+
+async function loadModuleForPlatform(platform: 'web' | 'ios' | 'android') {
+  vi.resetModules()
+  vi.doMock('react-native', () => ({ Platform: { OS: platform } }))
+  return import('./desktop-updates')
+}
+
+function createHost(input: {
+  serverId: string
+  endpoint: string
+  type?: 'direct' | 'relay'
+}): HostProfile {
+  const now = new Date(0).toISOString()
+
+  if (input.type === 'relay') {
+    return {
+      serverId: input.serverId,
+      label: input.serverId,
+      connections: [
+        {
+          id: `${input.serverId}-relay`,
+          type: 'relay',
+          relayEndpoint: input.endpoint,
+          daemonPublicKeyB64: 'test-key',
+        },
+      ],
+      preferredConnectionId: `${input.serverId}-relay`,
+      createdAt: now,
+      updatedAt: now,
+    }
+  }
+
+  return {
+    serverId: input.serverId,
+    label: input.serverId,
+    connections: [
+      {
+        id: `${input.serverId}-direct`,
+        type: 'direct',
+        endpoint: input.endpoint,
+      },
+    ],
+    preferredConnectionId: `${input.serverId}-direct`,
+    createdAt: now,
+    updatedAt: now,
+  }
+}
+
+describe('desktop-updates helpers', () => {
+  afterEach(() => {
+    vi.doUnmock('react-native')
+    vi.restoreAllMocks()
+    vi.resetModules()
+  })
+
+  it('normalizes versions for app-daemon comparisons', async () => {
+    const { normalizeVersionForComparison } = await loadModuleForPlatform('web')
+
+    expect(normalizeVersionForComparison(' v0.1.15 ')).toBe('0.1.15')
+    expect(normalizeVersionForComparison('0.1.15')).toBe('0.1.15')
+    expect(normalizeVersionForComparison(null)).toBeNull()
+  })
+
+  it('detects version mismatch after normalization', async () => {
+    const { isVersionMismatch } = await loadModuleForPlatform('web')
+
+    expect(isVersionMismatch('v0.1.15', '0.1.15')).toBe(false)
+    expect(isVersionMismatch('0.1.15', '0.1.16')).toBe(true)
+    expect(isVersionMismatch('0.1.15', null)).toBe(false)
+  })
+
+  it('formats display versions with v prefix and unavailable fallback', async () => {
+    const { formatVersionWithPrefix } = await loadModuleForPlatform('web')
+
+    expect(formatVersionWithPrefix('0.2.0')).toBe('v0.2.0')
+    expect(formatVersionWithPrefix('v0.2.0')).toBe('v0.2.0')
+    expect(formatVersionWithPrefix(null)).toBe('Unavailable')
+  })
+
+  it('prefers localhost direct host when selecting local daemon', async () => {
+    const { findLikelyLocalDaemonHost } = await loadModuleForPlatform('web')
+    const remote = createHost({ serverId: 'remote', endpoint: '10.0.0.2:6767' })
+    const local = createHost({ serverId: 'local', endpoint: 'localhost:6767' })
+
+    expect(findLikelyLocalDaemonHost([remote, local])?.serverId).toBe('local')
+  })
+
+  it('falls back to first host when no localhost endpoint exists', async () => {
+    const { findLikelyLocalDaemonHost } = await loadModuleForPlatform('web')
+    const relay = createHost({ serverId: 'relay', endpoint: 'relay.paseo.sh:443', type: 'relay' })
+    const remote = createHost({ serverId: 'remote', endpoint: '10.0.0.2:6767' })
+
+    expect(findLikelyLocalDaemonHost([relay, remote])?.serverId).toBe('relay')
+  })
+
+  it('builds copyable daemon update diagnostics', async () => {
+    const { buildDaemonUpdateDiagnostics } = await loadModuleForPlatform('web')
+    const diagnostics = buildDaemonUpdateDiagnostics({
+      exitCode: 1,
+      stdout: 'stdout text',
+      stderr: 'stderr text',
+    })
+
+    expect(diagnostics).toContain('Exit code: 1')
+    expect(diagnostics).toContain('STDOUT:\nstdout text')
+    expect(diagnostics).toContain('STDERR:\nstderr text')
+  })
+})
@@ -0,0 +1,174 @@
+import { Platform } from 'react-native'
+import type { HostProfile } from '@/contexts/daemon-registry-context'
+import { getTauri } from '@/utils/tauri'
+
+export interface DesktopAppUpdateCheckResult {
+  hasUpdate: boolean
+  currentVersion: string | null
+  latestVersion: string | null
+  body: string | null
+  date: string | null
+}
+
+export interface DesktopAppUpdateInstallResult {
+  installed: boolean
+  version: string | null
+  message: string
+}
+
+export interface LocalDaemonUpdateResult {
+  exitCode: number
+  stdout: string
+  stderr: string
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
+function toStringOrNull(value: unknown): string | null {
+  if (typeof value !== 'string') {
+    return null
+  }
+
+  const trimmed = value.trim()
+  return trimmed.length > 0 ? trimmed : null
+}
+
+function toStringOrEmpty(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function toNumberOr(defaultValue: number, value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : defaultValue
+}
+
+async function invokeDesktopCommand<T>(command: string): Promise<T> {
+  const invoke = getTauri()?.core?.invoke
+  if (typeof invoke !== 'function') {
+    throw new Error('Tauri invoke() is unavailable in this environment.')
+  }
+
+  return (await invoke(command)) as T
+}
+
+function isLikelyLocalDirectEndpoint(endpoint: string): boolean {
+  const normalized = endpoint.trim().toLowerCase()
+  return (
+    normalized === 'localhost' ||
+    normalized.startsWith('localhost:') ||
+    normalized === '127.0.0.1' ||
+    normalized.startsWith('127.0.0.1:') ||
+    normalized === '::1' ||
+    normalized.startsWith('::1:') ||
+    normalized === '[::1]' ||
+    normalized.startsWith('[::1]:')
+  )
+}
+
+export function shouldShowDesktopUpdateSection(): boolean {
+  return Platform.OS === 'web' && getTauri() !== null
+}
+
+export async function checkDesktopAppUpdate(): Promise<DesktopAppUpdateCheckResult> {
+  const result = await invokeDesktopCommand<unknown>('check_app_update')
+  if (!isRecord(result)) {
+    throw new Error('Unexpected response while checking desktop updates.')
+  }
+
+  return {
+    hasUpdate: result.hasUpdate === true,
+    currentVersion: toStringOrNull(result.currentVersion),
+    latestVersion: toStringOrNull(result.latestVersion),
+    body: toStringOrNull(result.body),
+    date: toStringOrNull(result.date),
+  }
+}
+
+export async function installDesktopAppUpdate(): Promise<DesktopAppUpdateInstallResult> {
+  const result = await invokeDesktopCommand<unknown>('install_app_update')
+  if (!isRecord(result)) {
+    throw new Error('Unexpected response while installing desktop update.')
+  }
+
+  return {
+    installed: result.installed === true,
+    version: toStringOrNull(result.version),
+    message: toStringOrNull(result.message) ?? 'Update completed.',
+  }
+}
+
+export async function runLocalDaemonUpdate(): Promise<LocalDaemonUpdateResult> {
+  const result = await invokeDesktopCommand<unknown>('run_local_daemon_update')
+  if (!isRecord(result)) {
+    throw new Error('Unexpected response while updating local daemon.')
+  }
+
+  return {
+    exitCode: toNumberOr(1, result.exitCode),
+    stdout: toStringOrEmpty(result.stdout),
+    stderr: toStringOrEmpty(result.stderr),
+  }
+}
+
+export function normalizeVersionForComparison(version: string | null | undefined): string | null {
+  const value = version?.trim()
+  if (!value) {
+    return null
+  }
+
+  return value.replace(/^v/i, '')
+}
+
+export function isVersionMismatch(
+  appVersion: string | null | undefined,
+  daemonVersion: string | null | undefined
+): boolean {
+  const app = normalizeVersionForComparison(appVersion)
+  const daemon = normalizeVersionForComparison(daemonVersion)
+
+  if (!app || !daemon) {
+    return false
+  }
+
+  return app !== daemon
+}
+
+export function formatVersionWithPrefix(version: string | null | undefined): string {
+  const value = version?.trim()
+  if (!value) {
+    return 'Unavailable'
+  }
+
+  return value.startsWith('v') ? value : `v${value}`
+}
+
+export function findLikelyLocalDaemonHost(daemons: HostProfile[]): HostProfile | null {
+  if (daemons.length === 0) {
+    return null
+  }
+
+  const localhostDaemon = daemons.find((daemon) =>
+    daemon.connections.some(
+      (connection) =>
+        connection.type === 'direct' && isLikelyLocalDirectEndpoint(connection.endpoint)
+    )
+  )
+
+  return localhostDaemon ?? daemons[0] ?? null
+}
+
+export function buildDaemonUpdateDiagnostics(result: LocalDaemonUpdateResult): string {
+  const stdout = result.stdout.length > 0 ? result.stdout : '(empty)'
+  const stderr = result.stderr.length > 0 ? result.stderr : '(empty)'
+
+  return [
+    `Exit code: ${result.exitCode}`,
+    '',
+    'STDOUT:',
+    stdout,
+    '',
+    'STDERR:',
+    stderr,
+  ].join('\n')
+}