602 lines
22 KiB
TypeScript
602 lines
22 KiB
TypeScript
// src/main/services/UpdateService.ts
|
|
// electron-updater 기반 자동 업데이트. 싱글톤 + EventEmitter.
|
|
//
|
|
// feed: Forgejo Generic Registry `d3ro-voice/latest` (canonical)
|
|
// 정책: release/update-policy.json (채널, 최소 지원 버전, 강제 업데이트, full/delta)
|
|
// 기능:
|
|
// 1. 채널(latest/beta/alpha) 선택 및 prerelease 게이팅
|
|
// 2. 사용자 인가 기반 다운로드 (autoDownload=false), 강제 업데이트 예외
|
|
// 3. 이번 버전 건너뛰기 (Skip This Version) — 비강제일 때만
|
|
// 4. major/버전갭 시 차분(.blockmap) 대신 전체 설치자
|
|
// 5. staged rollout + 원격 킬 스위치
|
|
// 6. 프로세스 락 충돌 방지 및 안전한 재시작 (quitAndInstall)
|
|
//
|
|
// 구조: 게이팅 순서는 update-policy.ts 의 순수 함수(evaluateUpdateOffer / shouldPromptForUpdate)가
|
|
// 정하고, 이 서비스는 포트(UpdaterPort / PolicySource / UpdatePrompter)를 통해 I/O 만 한다.
|
|
// 기본 어댑터는 electron-updater · fetch · electron dialog 이며, 테스트는 가짜 포트를 주입한다.
|
|
|
|
import { EventEmitter } from 'events'
|
|
import { randomUUID } from 'node:crypto'
|
|
import { app, dialog } from 'electron'
|
|
import { getLogger } from './LoggerService'
|
|
import { configGet, configGetAll, configSet } from './ConfigService'
|
|
import { getMainWindow } from '../windows/WindowManager'
|
|
import {
|
|
UPDATE_FEED_URL,
|
|
UPDATE_POLICY_URL,
|
|
isUpdateChannel,
|
|
type UpdateChannel,
|
|
} from '../update-feed'
|
|
import {
|
|
DEFAULT_UPDATE_POLICY,
|
|
evaluateUpdateOffer,
|
|
parseUpdatePolicy,
|
|
shouldPromptForUpdate,
|
|
type UpdateDecision,
|
|
type UpdatePolicy,
|
|
type UpdatePromptRecord,
|
|
} from '../update-policy'
|
|
|
|
const logger = getLogger('UpdateService')
|
|
|
|
/** 앱 시작 후 첫 체크까지 지연 — 초기화 경합(모델 로딩 등) 회피 */
|
|
const INITIAL_CHECK_DELAY_MS = 15_000
|
|
/** 주기 체크 간격 (4시간) */
|
|
const CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000
|
|
/** 원격 정책 fetch 타임아웃 */
|
|
const POLICY_FETCH_TIMEOUT_MS = 8_000
|
|
/** legacy 설치본이 저장한 skip 키 (AppConfig에 없는 과거 문자열 키) */
|
|
const LEGACY_SKIPPED_VERSION_KEY = 'skipped_update_version'
|
|
|
|
export interface UpdateProgressPayload {
|
|
percent: number
|
|
bytesPerSecond: number
|
|
transferred: number
|
|
total: number
|
|
}
|
|
|
|
export interface UpdateAvailablePayload {
|
|
version: string
|
|
currentVersion: string
|
|
channel: UpdateChannel
|
|
releaseNotes?: string
|
|
/** 연기·건너뛰기 불가 */
|
|
isMandatory: boolean
|
|
/** major 승격 여부 */
|
|
isMajorUpgrade: boolean
|
|
/** 차분 대신 전체 설치자로 받는지 */
|
|
isFullDownload: boolean
|
|
/** 강제 사유 (진단/로그) */
|
|
reason: UpdateDecision['reason']
|
|
}
|
|
|
|
export interface UpdateServiceEvents {
|
|
'checking-for-update': void
|
|
'update-available': UpdateAvailablePayload
|
|
'update-not-available': { version: string }
|
|
'download-progress': UpdateProgressPayload
|
|
'update-downloaded': { version: string }
|
|
'update-error': { message: string }
|
|
}
|
|
|
|
// ── 포트 ─────────────────────────────────────────────────────
|
|
|
|
export type ReleaseNotes = string | ReadonlyArray<{ version: string; note: string | null }> | null | undefined
|
|
|
|
export interface UpdateInfoLike {
|
|
version: string
|
|
releaseNotes?: ReleaseNotes
|
|
}
|
|
|
|
/** 업데이터(electron-updater) 이벤트를 서비스로 넘기는 콜백 */
|
|
export interface UpdaterEventHandlers {
|
|
onChecking(): void
|
|
onAvailable(info: UpdateInfoLike): void
|
|
onNotAvailable(version: string): void
|
|
onProgress(progress: UpdateProgressPayload): void
|
|
onDownloaded(version: string): void
|
|
onError(message: string): void
|
|
}
|
|
|
|
export interface UpdaterPort {
|
|
checkForUpdates(): Promise<unknown>
|
|
downloadUpdate(): Promise<unknown>
|
|
quitAndInstall(isSilent: boolean, isForceRunAfter: boolean): void
|
|
setChannel(channel: UpdateChannel, allowPrerelease: boolean): void
|
|
setDifferentialDisabled(disabled: boolean): void
|
|
}
|
|
|
|
/** 원격 정책 공급원. 실패하면 마지막으로 성공한 정책(없으면 기본값)을 돌려준다(fail-open). */
|
|
export interface PolicySource {
|
|
load(): Promise<UpdatePolicy>
|
|
}
|
|
|
|
export type ConsentAnswer = 'download' | 'later' | 'skip'
|
|
export type RestartAnswer = 'restart' | 'later'
|
|
|
|
export interface UpdatePrompter {
|
|
askConsent(input: { version: string; releaseNotes: ReleaseNotes; mandatory: boolean }): Promise<ConsentAnswer>
|
|
askRestart(version: string): Promise<RestartAnswer>
|
|
}
|
|
|
|
export interface UpdateServiceDeps {
|
|
/** 지원 환경(패키지 빌드·플랫폼·feed)일 때 업데이터를 만든다. 아니면 null(자동 업데이트 비활성). */
|
|
createUpdater(handlers: UpdaterEventHandlers): UpdaterPort | null
|
|
policySource: PolicySource
|
|
prompter: UpdatePrompter
|
|
currentVersion(): string
|
|
now(): number
|
|
}
|
|
|
|
// ── 서비스 ───────────────────────────────────────────────────
|
|
|
|
class UpdateService extends EventEmitter {
|
|
private _initialized = false
|
|
private _initialTimer: NodeJS.Timeout | null = null
|
|
private _intervalTimer: NodeJS.Timeout | null = null
|
|
/** 마지막으로 사용자에게 물어본 제안 — 새 버전/필수 격상/간격 경과 시 다시 묻는다 */
|
|
private _lastPrompt: UpdatePromptRecord | null = null
|
|
private _prompting = false
|
|
private _updater: UpdaterPort | null = null
|
|
private _downloading = false
|
|
private _policy: UpdatePolicy = DEFAULT_UPDATE_POLICY
|
|
private _channel: UpdateChannel = 'latest'
|
|
private _forceFullDownload = false
|
|
private readonly _deps: UpdateServiceDeps
|
|
|
|
constructor(deps: Partial<UpdateServiceDeps> = {}) {
|
|
super()
|
|
this._deps = {
|
|
createUpdater: deps.createUpdater ?? createElectronUpdater,
|
|
policySource: deps.policySource ?? createRemotePolicySource(),
|
|
prompter: deps.prompter ?? createDialogPrompter(),
|
|
currentVersion: deps.currentVersion ?? (() => app.getVersion()),
|
|
now: deps.now ?? (() => Date.now()),
|
|
}
|
|
}
|
|
|
|
/** 자동 업데이트 시작. 비활성 조건이면 로그만 남기고 no-op. */
|
|
initialize(): void {
|
|
if (this._initialized) return
|
|
this._initialized = true
|
|
|
|
this._updater = this._deps.createUpdater({
|
|
onChecking: () => {
|
|
logger.info('업데이트 확인 중...')
|
|
this.emit('checking-for-update', undefined as unknown as void)
|
|
},
|
|
onAvailable: (info) => {
|
|
logger.info(`업데이트 발견: v${info.version} (채널 ${this._channel})`)
|
|
void this.handleUpdateAvailable(info)
|
|
},
|
|
onNotAvailable: (version) => {
|
|
logger.info(`최신 버전 사용 중: v${version}`)
|
|
this.emit('update-not-available', { version })
|
|
},
|
|
onProgress: (progress) => this.emit('download-progress', progress),
|
|
onDownloaded: (version) => {
|
|
this._downloading = false
|
|
logger.info(`업데이트 다운로드 완료: v${version}`)
|
|
this.emit('update-downloaded', { version })
|
|
void this._promptRestart(version)
|
|
},
|
|
onError: (message) => {
|
|
// 수락한 다운로드가 실패했으면 다음 체크에서 다시 물을 수 있게 기록을 지운다
|
|
if (this._downloading) this._lastPrompt = null
|
|
this._downloading = false
|
|
logger.warn(`업데이트 체크 또는 다운로드 실패: ${message}`)
|
|
this.emit('update-error', { message })
|
|
},
|
|
})
|
|
if (!this._updater) return
|
|
|
|
this._applyChannel(this._resolveChannel(DEFAULT_UPDATE_POLICY))
|
|
this._initialTimer = setTimeout(() => void this.checkForUpdates(), INITIAL_CHECK_DELAY_MS)
|
|
this._intervalTimer = setInterval(() => void this.checkForUpdates(), CHECK_INTERVAL_MS)
|
|
logger.info(`자동 업데이트 활성 — feed: ${UPDATE_FEED_URL}`)
|
|
}
|
|
|
|
/**
|
|
* 수동 또는 주기적 업데이트 확인.
|
|
* 체크할 때마다 원격 정책을 다시 받는다 — 예전엔 시작 시 한 번만 받아, 오래 켜 둔 클라이언트는
|
|
* 킬 스위치·rollout·최소 지원 버전 변경을 재시작 전까지 전혀 반영하지 못했다.
|
|
*/
|
|
async checkForUpdates(): Promise<void> {
|
|
if (!this._updater || this._downloading) return
|
|
await this._refreshPolicy()
|
|
if (this._policy.killSwitch) {
|
|
logger.info('원격 킬 스위치 활성 — 업데이트 확인 중단')
|
|
return
|
|
}
|
|
try {
|
|
await this._updater.checkForUpdates()
|
|
} catch (err) {
|
|
logger.warn(`checkForUpdates 실패: ${err instanceof Error ? err.message : String(err)}`)
|
|
}
|
|
}
|
|
|
|
/** 사용자 수락 시 업데이트 다운로드 시작 */
|
|
async startDownload(): Promise<void> {
|
|
if (!this._updater || this._downloading) return
|
|
if (this._policy.killSwitch) {
|
|
logger.info('원격 킬 스위치 활성 — 다운로드 중단')
|
|
return
|
|
}
|
|
this._downloading = true
|
|
logger.info(
|
|
this._forceFullDownload
|
|
? '전체 설치자 다운로드 시작 (major/버전갭)'
|
|
: '차분 업데이트 다운로드 시작 (.blockmap)',
|
|
)
|
|
try {
|
|
await this._updater.downloadUpdate()
|
|
} catch (err) {
|
|
if (this._downloading) this._lastPrompt = null
|
|
this._downloading = false
|
|
logger.warn(`업데이트 다운로드 실패: ${err instanceof Error ? err.message : String(err)}`)
|
|
}
|
|
}
|
|
|
|
/** 이번 버전 건너뛰기 설정 */
|
|
skipVersion(version: string): void {
|
|
configSet('skippedUpdateVersion', version)
|
|
logger.info(`버전 v${version} 건너뛰기 등록 완료`)
|
|
}
|
|
|
|
/** 업데이트 채널을 전환한다. (설정 UI용) */
|
|
setChannel(channel: UpdateChannel): void {
|
|
configSet('updateChannel', channel)
|
|
this._applyChannel(channel)
|
|
logger.info(`업데이트 채널 전환: ${channel}`)
|
|
}
|
|
|
|
getChannel(): UpdateChannel {
|
|
return this._channel
|
|
}
|
|
|
|
getPolicy(): UpdatePolicy {
|
|
return this._policy
|
|
}
|
|
|
|
dispose(): void {
|
|
if (this._initialTimer) clearTimeout(this._initialTimer)
|
|
if (this._intervalTimer) clearInterval(this._intervalTimer)
|
|
this._initialTimer = null
|
|
this._intervalTimer = null
|
|
}
|
|
|
|
/** 업데이터가 새 버전을 알렸을 때 — 게이팅은 evaluateUpdateOffer 가 정한다. */
|
|
async handleUpdateAvailable(info: UpdateInfoLike): Promise<void> {
|
|
const currentVersion = this._deps.currentVersion()
|
|
const offer = evaluateUpdateOffer({
|
|
policy: this._policy,
|
|
channel: this._channel,
|
|
currentVersion,
|
|
targetVersion: info.version,
|
|
skippedVersion: this._skippedVersion(),
|
|
deviceId: this._deviceId(),
|
|
})
|
|
|
|
if (offer.action === 'ignore') {
|
|
switch (offer.reason) {
|
|
case 'kill-switch':
|
|
logger.info(`원격 킬 스위치 활성 — v${info.version} 무시`)
|
|
break
|
|
case 'channel':
|
|
logger.info(`채널 ${this._channel} 정책상 v${info.version} 무시`)
|
|
break
|
|
case 'skipped':
|
|
logger.info(`사용자가 건너뛴 버전 v${info.version} — 프롬프트 생략`)
|
|
break
|
|
case 'rollout':
|
|
logger.info(
|
|
`staged rollout(${this._policy.stagingPercentage}%) 밖 — v${info.version} 이번엔 노출하지 않음`,
|
|
)
|
|
break
|
|
}
|
|
return
|
|
}
|
|
|
|
const { decision } = offer
|
|
// major 승격 또는 버전 갭이면 차분 패치를 시도하지 않는다.
|
|
this._forceFullDownload = decision.forceFull
|
|
this._updater?.setDifferentialDisabled(decision.forceFull)
|
|
|
|
this.emit('update-available', {
|
|
version: info.version,
|
|
currentVersion,
|
|
channel: this._channel,
|
|
releaseNotes: typeof info.releaseNotes === 'string' ? info.releaseNotes : undefined,
|
|
isMandatory: decision.mandatory,
|
|
isMajorUpgrade: offer.isMajorUpgrade,
|
|
isFullDownload: decision.forceFull,
|
|
reason: decision.reason,
|
|
})
|
|
|
|
if (this._downloading) return
|
|
|
|
// forceInstallBelow는 다이얼로그 없이 즉시 설치 (보안 하한선).
|
|
if (offer.action === 'force-download') {
|
|
logger.info(`v${info.version} 강제 설치 (${decision.reason})`)
|
|
void this.startDownload()
|
|
return
|
|
}
|
|
|
|
await this._promptUserConsent(info.version, info.releaseNotes, decision)
|
|
}
|
|
|
|
// ── 내부 ──
|
|
|
|
private async _refreshPolicy(): Promise<void> {
|
|
this._policy = await this._deps.policySource.load()
|
|
this._applyChannel(this._resolveChannel(this._policy))
|
|
}
|
|
|
|
private _resolveChannel(policy: UpdatePolicy): UpdateChannel {
|
|
const configured = configGet('updateChannel')
|
|
return isUpdateChannel(configured) ? configured : policy.defaultChannel
|
|
}
|
|
|
|
private _applyChannel(channel: UpdateChannel): void {
|
|
this._channel = channel
|
|
if (!this._updater) return
|
|
const channelPolicy = this._policy.channels[channel] ?? { allowPrerelease: false }
|
|
this._updater.setChannel(channel, channelPolicy.allowPrerelease)
|
|
}
|
|
|
|
private _deviceId(): string {
|
|
const existing = configGet('updateDeviceId')
|
|
if (typeof existing === 'string' && existing.length > 0) return existing
|
|
const generated = randomUUID()
|
|
configSet('updateDeviceId', generated)
|
|
return generated
|
|
}
|
|
|
|
private _skippedVersion(): string | null {
|
|
const current = configGet('skippedUpdateVersion')
|
|
if (typeof current === 'string' && current) return current
|
|
const legacy = (configGetAll() as unknown as Record<string, unknown>)[LEGACY_SKIPPED_VERSION_KEY]
|
|
return typeof legacy === 'string' && legacy ? legacy : null
|
|
}
|
|
|
|
/** 1단계: 신규 업데이트 발견 시 다운로드 인가 요청 다이얼로그 */
|
|
private async _promptUserConsent(
|
|
version: string,
|
|
releaseNotes: ReleaseNotes,
|
|
decision: UpdateDecision,
|
|
): Promise<void> {
|
|
if (this._prompting) return
|
|
const now = this._deps.now()
|
|
if (!shouldPromptForUpdate(this._lastPrompt, { version, mandatory: decision.mandatory }, now)) {
|
|
logger.info(`v${version} 은 최근에 물어봤음 — 다음 간격까지 다시 묻지 않음`)
|
|
return
|
|
}
|
|
this._lastPrompt = { version, mandatory: decision.mandatory, at: now }
|
|
this._prompting = true
|
|
try {
|
|
const answer = await this._deps.prompter.askConsent({
|
|
version,
|
|
releaseNotes,
|
|
mandatory: decision.mandatory,
|
|
})
|
|
if (answer === 'download') {
|
|
void this.startDownload()
|
|
} else if (!decision.mandatory && answer === 'skip') {
|
|
this.skipVersion(version)
|
|
}
|
|
} finally {
|
|
this._prompting = false
|
|
}
|
|
}
|
|
|
|
/** 2단계: 다운로드 완료 시 안전한 재시작 및 설치 다이얼로그 */
|
|
private async _promptRestart(version: string): Promise<void> {
|
|
const answer = await this._deps.prompter.askRestart(version)
|
|
if (answer === 'restart' && this._updater) {
|
|
logger.info('사용자 재시작 수락 — 프로세스 리소스 해제 후 quitAndInstall 실행')
|
|
// 프로세스 락(EBUSY) 방지를 위해 isSilent=false, isForceRunAfter=true로 실행.
|
|
// quitAndInstall 은 app.quit() 경로를 타므로 종료 등록부(ShutdownRegistry)가 자원을 정리한다.
|
|
this._updater.quitAndInstall(false, true)
|
|
}
|
|
}
|
|
|
|
// ── 타입 안전한 이벤트 메서드 오버라이드 ──
|
|
|
|
override emit<K extends keyof UpdateServiceEvents>(
|
|
event: K,
|
|
payload: UpdateServiceEvents[K],
|
|
): boolean {
|
|
return super.emit(event, payload)
|
|
}
|
|
|
|
override on<K extends keyof UpdateServiceEvents>(
|
|
event: K,
|
|
listener: (payload: UpdateServiceEvents[K]) => void,
|
|
): this {
|
|
return super.on(event, listener)
|
|
}
|
|
}
|
|
|
|
// ── 기본 어댑터 (electron-updater / fetch / electron dialog) ─────
|
|
|
|
function createElectronUpdater(handlers: UpdaterEventHandlers): UpdaterPort | null {
|
|
if (!app.isPackaged) {
|
|
logger.info('dev 실행 — 자동 업데이트 비활성')
|
|
return null
|
|
}
|
|
if (process.platform !== 'win32' && process.platform !== 'darwin') {
|
|
logger.info(`플랫폼 ${process.platform} — 자동 업데이트 미지원`)
|
|
return null
|
|
}
|
|
if (!UPDATE_FEED_URL) {
|
|
logger.info('UPDATE_FEED_URL 미설정 — 자동 업데이트 비활성')
|
|
return null
|
|
}
|
|
|
|
let updater: import('electron-updater').AppUpdater
|
|
try {
|
|
// eslint-disable-next-line @typescript-eslint/no-require-imports
|
|
updater = (require('electron-updater') as typeof import('electron-updater')).autoUpdater
|
|
} catch (err) {
|
|
logger.warn(
|
|
`electron-updater 로드 실패 — 자동 업데이트 비활성: ${err instanceof Error ? err.message : String(err)}`,
|
|
)
|
|
return null
|
|
}
|
|
|
|
updater.setFeedURL({ provider: 'generic', url: UPDATE_FEED_URL })
|
|
// 사용자 인가를 위해 자동 다운로드는 비활성화 (동의 시 downloadUpdate 호출)
|
|
updater.autoDownload = false
|
|
updater.autoInstallOnAppQuit = true
|
|
updater.logger = {
|
|
info: (msg: unknown) => logger.info(String(msg)),
|
|
warn: (msg: unknown) => logger.warn(String(msg)),
|
|
error: (msg: unknown) => logger.error(String(msg)),
|
|
debug: (msg: unknown) => logger.debug(String(msg)),
|
|
}
|
|
|
|
updater.on('checking-for-update', () => handlers.onChecking())
|
|
updater.on('update-available', (info) => handlers.onAvailable(info))
|
|
updater.on('update-not-available', (info) => handlers.onNotAvailable(info.version))
|
|
updater.on('download-progress', (progress) =>
|
|
handlers.onProgress({
|
|
percent: progress.percent,
|
|
bytesPerSecond: progress.bytesPerSecond,
|
|
transferred: progress.transferred,
|
|
total: progress.total,
|
|
}),
|
|
)
|
|
updater.on('update-downloaded', (info) => handlers.onDownloaded(info.version))
|
|
updater.on('error', (err) => handlers.onError(err.message))
|
|
|
|
return {
|
|
checkForUpdates: () => updater.checkForUpdates(),
|
|
downloadUpdate: () => updater.downloadUpdate(),
|
|
quitAndInstall: (isSilent, isForceRunAfter) => updater.quitAndInstall(isSilent, isForceRunAfter),
|
|
setChannel: (channel, allowPrerelease) => {
|
|
updater.channel = channel
|
|
updater.allowPrerelease = allowPrerelease
|
|
},
|
|
setDifferentialDisabled: (disabled) => {
|
|
// NSIS 이외 업데이터는 이 속성을 무시한다
|
|
;(updater as unknown as { disableDifferentialDownload?: boolean }).disableDifferentialDownload = disabled
|
|
},
|
|
}
|
|
}
|
|
|
|
/** 원격 정책 공급원 — 실패하면 마지막으로 성공한 정책, 그것도 없으면 내장 기본값 */
|
|
export function createRemotePolicySource(
|
|
url: string | null | undefined = UPDATE_POLICY_URL,
|
|
fetchImpl: typeof fetch = (input, init) => fetch(input, init),
|
|
): PolicySource {
|
|
let lastGood: UpdatePolicy | null = null
|
|
return {
|
|
async load(): Promise<UpdatePolicy> {
|
|
if (!url) return lastGood ?? DEFAULT_UPDATE_POLICY
|
|
try {
|
|
const response = await fetchImpl(url, {
|
|
cache: 'no-store',
|
|
signal: AbortSignal.timeout(POLICY_FETCH_TIMEOUT_MS),
|
|
})
|
|
if (!response.ok) throw new Error(`HTTP ${response.status}`)
|
|
lastGood = parseUpdatePolicy(await response.json())
|
|
logger.info(
|
|
`원격 업데이트 정책 적용 — min=${lastGood.minimumSupportedVersion}, killSwitch=${lastGood.killSwitch}, staging=${lastGood.stagingPercentage}%`,
|
|
)
|
|
return lastGood
|
|
} catch (err) {
|
|
// 네트워크 실패 시 마지막 정책(없으면 내장 기본값)으로 fail-open (업데이트 자체는 계속).
|
|
logger.debug(
|
|
`원격 업데이트 정책 로드 실패 — ${lastGood ? '마지막 정책 유지' : '내장 기본값 사용'}: ${err instanceof Error ? err.message : String(err)}`,
|
|
)
|
|
return lastGood ?? DEFAULT_UPDATE_POLICY
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
/**
|
|
* electron dialog 기반 프롬프터.
|
|
* TODO(i18n): 문구가 아직 ko/en 인라인이다 — update.* 키를 locale 파일에 추가한 뒤 t() 로 옮긴다.
|
|
*/
|
|
function createDialogPrompter(): UpdatePrompter {
|
|
const isKorean = (): boolean => (configGet('language') as string | undefined)?.startsWith('ko') ?? true
|
|
const show = async (options: Electron.MessageBoxOptions): Promise<number> => {
|
|
const win = getMainWindow()
|
|
const { response } =
|
|
win && !win.isDestroyed()
|
|
? await dialog.showMessageBox(win, options)
|
|
: await dialog.showMessageBox(options)
|
|
return response
|
|
}
|
|
|
|
return {
|
|
async askConsent({ version, releaseNotes, mandatory }): Promise<ConsentAnswer> {
|
|
const isKo = isKorean()
|
|
const notesText = typeof releaseNotes === 'string' ? `\n\n[주요 변경사항]\n${releaseNotes}` : ''
|
|
const mandatoryNote = mandatory
|
|
? isKo
|
|
? '\n\n이 업데이트는 필수입니다 (지원 종료 버전).'
|
|
: '\n\nThis update is required (end of support).'
|
|
: ''
|
|
|
|
if (mandatory) {
|
|
const response = await show({
|
|
type: 'info',
|
|
title: isKo ? '필수 업데이트' : 'Required Update',
|
|
message: isKo
|
|
? `D3RO Voice v${version} 업데이트가 필요합니다.${mandatoryNote}${notesText}`
|
|
: `D3RO Voice v${version} is required.${mandatoryNote}${notesText}`,
|
|
buttons: isKo ? ['지금 업데이트'] : ['Update Now'],
|
|
defaultId: 0,
|
|
cancelId: -1,
|
|
})
|
|
return response === 0 ? 'download' : 'later'
|
|
}
|
|
|
|
const response = await show({
|
|
type: 'info',
|
|
title: isKo ? '새 버전 업데이트' : 'Software Update',
|
|
message: isKo
|
|
? `D3RO Voice v${version} 새 버전이 출시되었습니다. 지금 다운로드할까요?${notesText}`
|
|
: `A new version of D3RO Voice (v${version}) is available. Would you like to download it now?${notesText}`,
|
|
buttons: isKo
|
|
? ['지금 다운로드', '나중에', '이 버전 건너뛰기']
|
|
: ['Download Now', 'Later', 'Skip This Version'],
|
|
defaultId: 0,
|
|
cancelId: 1,
|
|
})
|
|
if (response === 0) return 'download'
|
|
if (response === 2) return 'skip'
|
|
return 'later'
|
|
},
|
|
|
|
async askRestart(version): Promise<RestartAnswer> {
|
|
const isKo = isKorean()
|
|
const response = await show({
|
|
type: 'info',
|
|
title: isKo ? '업데이트 준비 완료' : 'Update Ready',
|
|
message: isKo
|
|
? `D3RO Voice v${version} 다운로드가 완료되었습니다. 지금 앱을 재시작하여 설치를 완료할까요?`
|
|
: `D3RO Voice v${version} has been downloaded. Restart now to complete installation?`,
|
|
buttons: isKo ? ['지금 재시작 및 설치', '종료 시 자동 설치'] : ['Restart & Install Now', 'Install on Exit'],
|
|
defaultId: 0,
|
|
cancelId: 1,
|
|
})
|
|
return response === 0 ? 'restart' : 'later'
|
|
},
|
|
}
|
|
}
|
|
|
|
// ── 싱글톤 ──
|
|
|
|
let instance: UpdateService | null = null
|
|
|
|
export function getUpdateService(): UpdateService {
|
|
if (!instance) {
|
|
instance = new UpdateService()
|
|
}
|
|
return instance
|
|
}
|
|
|
|
export { UpdateService }
|