d3ro-voice/apps/desktop/src/main/services/CloudSyncService.ts
Yun Chan 9cf3fd7317 fix(cloud-sync): drop the previous account's cached tier when signing in as someone else
Switching accounts without a sign-out skipped resetToFree, and if the
subscription lookup then failed the new account kept the old one's Pro badge
and ad decision, persisted across restarts.
2026-10-21 11:26:12 +09:00

1319 lines
52 KiB
TypeScript

// src/main/services/CloudSyncService.ts
// Phase V2-4: Supabase 동기화 — OAuth 로그인, 세션 영속화, 기기 간 양방향 동기화
// Local-first: 데스크톱은 SQLite에서 바로 동작하고, Supabase(모바일·웹의 정본)와 양방향으로 맞춘다.
// 실제 동기화는 services/sync/SyncEngine 이 한다 — 이 서비스는 인증·수명주기·트리거를 맡는다.
import { EventEmitter } from 'events'
import fs from 'fs'
import path from 'path'
import { app, safeStorage } from 'electron'
import {
createClient,
type SupabaseClient,
type Session,
type User,
type RealtimeChannel
} from '@supabase/supabase-js'
import { getLogger } from './LoggerService'
import { configGet, configSet, onConfigChanged } from './ConfigService'
import { SUPABASE_URL, SUPABASE_ANON_KEY } from '@d3ro/core/supabase-config'
import {
openForUser,
openLocal,
closeCurrent,
getCurrentUserId,
importLocalModeData,
LOCAL_USER_ID,
} from '../db'
import { D3ROError, ErrorCode } from '@d3ro/core/errors'
import type { LicenseTier } from '@d3ro/core/types'
import { SyncEngine, type SyncStatus } from './sync/SyncEngine'
import { SyncAbortedError } from './sync/sync-adapters'
import { SyncScheduler } from './sync/sync-scheduler'
import {
EncryptedFileTokenStore,
bindAuthEvents,
type SessionTokenStore,
type StoredSessionRecord,
} from './sync/session-token-store'
import { classifySessionRestoreFailure, sessionRestoreRetryDelayMs } from './sync/session-restore-policy'
import { openExternalSafe } from '../windows/web-contents-hardening'
import { SupabaseSyncRemote } from './sync/supabase-sync-remote'
import { enqueueChange, getSyncState, setSyncState } from './sync/sync-outbox'
import { checkInDesktopDevice, currentDeviceInfo, unregisterDesktopDevice } from './sync/device-registration'
import { realtimeTables, type SyncEntity, type SyncRunResult } from './sync/sync-types'
import { nodeRealtimeTransport } from './sync/realtime-transport'
import { SETTINGS_ROW_ID, SYNCED_CONFIG_KEYS, isApplyingRemoteSettings } from './sync/settings-sync'
import { AUDIO_BUCKET, listLocalAudioOwners } from './sync/audio-sync'
const logger = getLogger('CloudSyncService')
/** 로컬 변경을 모아서 보내는 지연 */
const FLUSH_DEBOUNCE_MS = 1_500
/** Realtime 이벤트가 몰릴 때 한 번만 가져오는 지연 */
const PULL_DEBOUNCE_MS = 1_500
/** 기기 생존 신호 + Realtime 누락 대비 전체 동기화 주기 */
const HEARTBEAT_MS = 5 * 60_000
/** sync_state 에 저장하는 이 사용자 DB의 등록 기기 id */
const DEVICE_STATE_KEY = 'device:id'
/** 로그아웃·계정 전환 때 진행 중인 동기화가 멈추기를 기다리는 최대 시간 */
const ENGINE_STOP_TIMEOUT_MS = 5_000
/** 로그인 버튼을 누른 뒤 deep link 콜백을 받아들이는 시간 — 요청하지 않은 콜백(login CSRF)을 거른다 */
const SIGN_IN_WINDOW_MS = 10 * 60_000
/** refresh token 파일 이름(userData 아래) */
const TOKEN_FILE = 'cloud-sync.token'
// ============================================================
// 타입
// ============================================================
interface SyncProgress {
current: number
total: number
table: string
}
interface SyncResult {
pushed: number
errors: string[]
}
interface CloudSyncState {
authenticated: boolean
userEmail: string | null
lastSyncAt: number | null
syncing: boolean
/** 아직 서버에 올라가지 않은 로컬 변경 수 */
pendingChanges: number
/** 서버가 거부해 자동 재시도를 멈춘 변경 수 (수동 업로드로 재시도) */
failedChanges: number
}
interface CloudSyncEvents {
'auth-changed': (payload: { user: User | null }) => void
'sync-progress': (payload: SyncProgress) => void
'sync-complete': (payload: SyncResult) => void
'sync-error': (payload: { error: string }) => void
/** 다른 기기의 변경이 로컬에 반영됨 — 화면 새로고침 신호 */
'data-changed': (payload: { entities: SyncEntity[] }) => void
}
// ============================================================
// CloudSyncService
// ============================================================
class CloudSyncService extends EventEmitter {
private _client: SupabaseClient | null = null
private _session: Session | null = null
private _lastSyncAt: number | null = null
private _syncing = false
/** Realtime 재구독 지수 백오프 상태 (U1) */
private _realtimeRetryCount = 0
private _realtimeRetryTimer: NodeJS.Timeout | null = null
private _initialized = false
private _realtimeChannel: RealtimeChannel | null = null
/** 진행 중인 startRealtime — 동시 호출을 하나로 합친다 */
private _realtimeStarting: Promise<void> | null = null
private _engine: SyncEngine | null = null
/** 로그인 시작(startSignIn) 후 콜백을 받아들이는 기한. null이면 진행 중인 로그인이 없다 */
private _pendingSignInUntil: number | null = null
private _tokenStore: SessionTokenStore | null = null
private _unbindAuthEvents: (() => void) | null = null
/**
* 로그인된 계정이지만 세션을 아직 복원하지 못한 상태(오프라인으로 시작 등)의 계정 id.
* 이 동안 기록은 그 계정 DB 에 쓰이고 outbox 에 쌓였다가, 복원되면 올라간다. 세션이 있으면 null.
*/
private _offlineUserId: string | null = null
private _restoreRetryTimer: NodeJS.Timeout | null = null
private _restoreAttempt = 0
/** _onSignOut 진행 중 — 자기 signOut() 이 일으킨 SIGNED_OUT 을 다시 처리하지 않게 */
private _signingOut = false
private readonly _scheduler = new SyncScheduler({
flushDelayMs: FLUSH_DEBOUNCE_MS,
pullDelayMs: PULL_DEBOUNCE_MS,
heartbeatMs: HEARTBEAT_MS,
run: (kind) => void this._runEngine(kind).catch(() => undefined),
onHeartbeat: () => this._onHeartbeat(),
})
/**
* 초기화 — Supabase 클라이언트 생성, 저장된 세션 복원.
* Supabase URL/KEY가 설정되지 않았으면 disabled 상태로 남는다.
*/
async init(): Promise<void> {
if (this._initialized) return
this._initialized = true
this._client = this._createClient()
this._lastSyncAt = (configGet('cloudSyncLastAt') as number | undefined) ?? null
this._bindClientAuthEvents(this._client)
// 언어·테마·자동 다듬기·활성 명령이 바뀌면 모바일 user_settings 로 올린다(원격 반영 중엔 제외).
onConfigChanged((event) => {
if (isApplyingRemoteSettings()) return
if ((SYNCED_CONFIG_KEYS as readonly string[]).includes(event.key)) {
this.pushOne('user_settings', SETTINGS_ROW_ID)
}
// 녹음 동기화를 켜면 그동안 올리지 않은 녹음을 올린다.
if (event.key === 'cloudSyncAudio' && event.value === true && this._engine) {
try {
for (const id of listLocalAudioOwners('history')) this.pushOne('history_audio', id)
for (const id of listLocalAudioOwners('meeting')) this.pushOne('meeting_audio', id)
} catch (err) {
logger.warn(`Audio re-queue failed: ${err instanceof Error ? err.message : String(err)}`)
}
}
})
// 저장된 refresh token 복원
const stored = this._loadStoredSession()
if (stored) {
await this._restoreSession(stored)
} else {
// 저장된 토큰 없음 → 미인증 상태를 렌더러에 명시 전달
this.emit('auth-changed', { user: null })
}
logger.info('CloudSyncService initialized')
}
private _createClient(): SupabaseClient {
return createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
auth: {
persistSession: false, // 직접 관리
autoRefreshToken: true,
detectSessionInUrl: false
},
// Electron 33 메인 프로세스(Node 20)에는 전역 WebSocket이 없다. 주입하지 않으면 Realtime이
// 연결조차 못 하고 TIMED_OUT/CLOSED만 반복한다(2026-09-16 설치본 로그) — 다른 기기의 변경이
// 실시간으로 오지 않던 원인.
realtime: { transport: nodeRealtimeTransport }
})
}
/**
* supabase-js는 메인 프로세스에서 refresh token을 주기적으로 회전시킨다. 회전된 토큰과 access token을
* 매번 저장·갱신해야 재시작 복원과 Realtime 재구독이 이미 쓰인/만료된 토큰을 쓰지 않는다.
*/
private _bindClientAuthEvents(client: SupabaseClient): void {
this._unbindAuthEvents?.()
this._unbindAuthEvents = bindAuthEvents<Session>(
(callback) => client.auth.onAuthStateChange((event, session) => callback(event, session)).data.subscription,
this._tokens(),
() => this._session?.user.id ?? null,
(session) => {
this._session = session
},
() => this._onRemoteSignedOut()
)
}
/**
* 이 기기의 Supabase 세션을 서버 결과와 무관하게 버린다.
* auth-js signOut 은 오프라인·5xx 면 { error } 를 돌려주고 _removeSession 을 건너뛰어, 클라이언트가
* 옛 계정 세션을 계속 들고 자동 갱신한다(Cloud STT·realtime-token 이 로그아웃 뒤에도 그 계정으로 돌던 원인).
* 공개 API 로는 메모리 세션만 지울 수 없으므로, 실패하면 자동 갱신을 멈추고 클라이언트를 새로 만든다.
*/
private async _revokeLocalSession(): Promise<void> {
const client = this._client
if (!client) return
let failure: string | null = null
try {
const { error } = await client.auth.signOut({ scope: 'local' })
if (error) failure = error.message
} catch (err) {
failure = err instanceof Error ? err.message : String(err)
}
if (failure === null) return
logger.warn(`signOut did not clear the client session (${failure}) — discarding the auth client`)
await client.auth.stopAutoRefresh().catch(() => undefined)
if (this._client !== client) return
const fresh = this._createClient()
this._client = fresh
this._bindClientAuthEvents(fresh)
}
/**
* 저장된 계정 id (없거나 구버전 토큰 파일이면 null). bootstrap 이 세션 복원을 기다리지 않고
* 그 계정 DB 를 먼저 열어, 복원 중·오프라인 동안의 기록이 익명 DB 로 새지 않게 한다.
*/
peekStoredAccountUserId(): string | null {
try {
return this._loadStoredSession()?.userId ?? null
} catch {
return null
}
}
// ── 세션 복원 (시작 시 + 오프라인 재시도) ─────────────────
private async _restoreSession(stored: StoredSessionRecord): Promise<void> {
const client = this._client
if (!client) return
try {
const { data, error } = await client.auth.refreshSession({ refresh_token: stored.refreshToken })
if (this._session) return // 기다리는 동안 사용자가 새로 로그인했다
if (error) {
this._handleRestoreFailure(error, error.message, stored)
return
}
if (!data.session) {
this._handleRestoreFailure(null, 'refreshSession returned no session', stored)
return
}
this._saveRefreshToken(data.session.refresh_token, data.session.user.id)
logger.info(`Restored session for user: ${data.session.user.email ?? data.session.user.id}`)
// 단일 진입점으로 수렴 — DB open + auth-changed emit + Realtime 시작
await this._onAuthenticated(data.session, { reason: 'restore' })
} catch (err) {
if (this._session) return
this._handleRestoreFailure(err, err instanceof Error ? err.message : String(err), stored)
}
}
/**
* 복원 실패 처리. 서버가 토큰을 확실히 거부했을 때만 토큰을 지우고 로그아웃한다.
* 네트워크·서버 일시 오류면 토큰을 보관하고, 저장된 계정 DB 에서 오프라인으로 계속 동작하며
* 백오프로 다시 시도한다(예전엔 어떤 오류든 토큰을 지워, 오프라인 시작만으로 로그아웃되고
* 그 뒤 기록이 익명 DB 에 갇혔다).
*/
private _handleRestoreFailure(error: unknown, message: string, stored: StoredSessionRecord): void {
if (classifySessionRestoreFailure(error) === 'invalid') {
// U3: 재인증 필요를 사용자에게 알린다(조용히 토큰만 지우면 "왜 로그아웃됐지?" 상태로 방치된다).
logger.error(`세션 복원 실패 — 재로그인 필요: ${message} (토큰 만료 또는 서버 세션 무효화)`)
this._cancelRestoreRetry()
this._offlineUserId = null
this._clearStoredRefreshToken()
this._revertToLocalDatabase('restore-invalid')
this.emit('sync-error', { error: `Sign-in session expired. Please sign in again. (${message})` })
this.emit('auth-changed', { user: null })
return
}
logger.warn(`세션 복원 보류(일시 오류) — 토큰 보관, 나중에 다시 시도: ${message}`)
const firstFailure = this._restoreAttempt === 0 && this._offlineUserId === null
if (stored.userId) this._enterOfflineAccount(stored.userId)
this._scheduleRestoreRetry()
if (firstFailure) {
this.emit('sync-error', {
error: `Could not reach the sync server. You are still signed in; sync resumes automatically when the connection is back. (${message})`,
})
this.emit('auth-changed', { user: null })
}
}
/** 세션 없이 저장된 계정 DB 로 동작한다(쓰기는 outbox 에 쌓인다). */
private _enterOfflineAccount(userId: string): void {
if (getCurrentUserId() !== userId) {
try {
openForUser(userId)
} catch (err) {
logger.warn(`Offline account DB open failed (staying in current DB): ${err instanceof Error ? err.message : String(err)}`)
return
}
}
this._offlineUserId = userId
}
private _scheduleRestoreRetry(): void {
if (this._restoreRetryTimer) return
const delay = sessionRestoreRetryDelayMs(this._restoreAttempt)
this._restoreAttempt++
logger.info(`Session restore retry #${this._restoreAttempt} in ${delay}ms`)
this._restoreRetryTimer = setTimeout(() => {
this._restoreRetryTimer = null
if (this._session) return
const stored = this._loadStoredSession()
if (!stored) return
void this._restoreSession(stored)
}, delay)
this._restoreRetryTimer.unref?.()
}
private _cancelRestoreRetry(): void {
if (this._restoreRetryTimer) {
clearTimeout(this._restoreRetryTimer)
this._restoreRetryTimer = null
}
this._restoreAttempt = 0
}
/** 로그인되지 않은 상태로 돌아갈 때 익명 로컬 DB 로 되돌린다(이미 로컬이면 그대로). */
private _revertToLocalDatabase(reason: string): void {
if (getCurrentUserId() === LOCAL_USER_ID) return
try {
const { dbPath } = openLocal()
logger.info(`[${reason}] Reverted to local DB: ${dbPath}`)
} catch (err) {
logger.error(`[${reason}] Local DB reopen failed: ${err instanceof Error ? err.message : String(err)}`)
}
}
/**
* auth 클라이언트가 세션을 버렸다(SIGNED_OUT) — 다른 기기의 전역 로그아웃, 토큰 폐기 등.
* 예전엔 무시해 엔진·Realtime 이 익명 키로 계속 돌며 푸시가 RLS 에 막히고, 5분 뒤 heartbeat 가
* "다른 기기에서 연결 해제됨"이라는 틀린 사유로 로그아웃시켰다.
*/
private _onRemoteSignedOut(): void {
if (this._signingOut || !this._session) return
logger.warn('Auth session ended outside this app (SIGNED_OUT) — signing out locally')
void this._onSignOut({ unregister: false })
.then(() => {
this.emit('sync-error', {
error: 'Your sign-in session has ended (signed out elsewhere or expired). Sign in again to keep syncing.',
})
})
.catch((err) => {
logger.warn(`Remote sign-out cleanup failed: ${err instanceof Error ? err.message : String(err)}`)
})
}
// ── 인증 lifecycle 단일 진입점 ─────────────────────────
/**
* 세션이 인증된 직후 호출되는 단일 진입점.
* - 사용자별 DB 오픈
* - auth-changed emit (renderer 게이트 해제)
* - Realtime 구독 시작
* init()의 세션 복원과 handleAuthCallback()의 신규 로그인 모두 여기로 수렴한다.
*/
private async _onAuthenticated(
session: Session,
opts: { reason: 'restore' | 'signin' }
): Promise<void> {
const userId = session.user.id
// 로그인(또는 복원) 성공 — 오프라인 재시도는 더 필요 없다.
this._cancelRestoreRetry()
// 0) 이전 계정의 동기화를 먼저 멈춘다 — 새 DB가 열린 뒤 이전 엔진이 그 DB에 쓰지 않게.
const previous = this._engine
this._engine = null
if (previous) {
previous.dispose()
await previous.whenIdle(ENGINE_STOP_TIMEOUT_MS)
}
// 다른 계정 DB 로 바뀌기 전에 진행 중인 받아쓰기·회의를 지금 DB 에 끝낸다. 그대로 두면 정지 시점의
// 저장·업로드가 새 계정 DB·저장소로 들어갔다(오프라인 복원 대기 중 다른 계정으로 로그인한 경우).
const openUserId = getCurrentUserId()
if (openUserId !== null && openUserId !== userId) {
await this._stopActiveCapture(`auth:${opts.reason}`)
}
this._session = session
this._offlineUserId = null
// 1) 사용자별 DB 열기 (Phase 1 — 사용자별 SQLite 격리)
// 이 시점부터 이 계정 DB 의 쓰기는 엔진이 만들어지기 전에도 outbox 에 기록된다(_recordChange).
try {
const { created, dbPath } = openForUser(userId)
logger.info(
`[auth:${opts.reason}] DB opened for ${userId}: ${dbPath} (created=${created})`
)
} catch (err) {
const message = err instanceof Error ? err.message : String(err)
logger.error(`[auth:${opts.reason}] DB open failed for ${userId}: ${message}`)
// DB를 열지 못하면 로그인 상태를 유지해서는 안 된다 — 즉시 signOut.
// openForUser 는 실패해도 이전 DB 를 닫지 않는다. 그것이 다른 계정의 DB 면 로컬로 되돌린다.
this._session = null
this._clearStoredRefreshToken()
this._revertToLocalDatabase(`auth:${opts.reason}`)
this.emit('sync-error', { error: `Database open failed: ${message}` })
this.emit('auth-changed', { user: null })
return
}
// 2) Supabase `subscriptions` 테이블에서 현재 티어 가져와 LicenseService에 동기화
// (빅뱅 Phase 4 — 티어 enforcement)
// 다른 계정으로 바로 바뀌는 경우엔 이전 계정의 캐시 티어를 먼저 버린다 — 조회가 실패하면
// 이전 계정의 Pro 배지·광고 판정이 새 계정에 남고, 저장값이라 재시작 후에도 이어졌다.
const switchedAccount = openUserId !== null && openUserId !== userId
try {
const { getLicenseService } = await import('./LicenseService')
if (switchedAccount) getLicenseService().resetToFree()
const tier = await this._fetchSubscriptionTier(userId)
getLicenseService().syncFromCloud(tier)
} catch (err) {
logger.warn(
`[auth:${opts.reason}] Subscription tier sync failed (falling back to free): ${
err instanceof Error ? err.message : String(err)
}`
)
}
// 3) 로그인 전 익명 로컬 모드에서 쌓인 기록을 이 계정 DB로 가져온다(최초 1회).
// 가져온 행은 아래 최초 대조가 서버로 올려 모바일에서도 보인다.
try {
importLocalModeData()
} catch (err) {
logger.warn(
`[auth:${opts.reason}] Local-mode import failed: ${err instanceof Error ? err.message : String(err)}`
)
}
// 4) 동기화 엔진 — 사용자 DB가 열린 뒤, 이 사용자 전용으로 만든다(엔진은 이 DB에 묶인다).
// 이전 엔진은 0)에서 이미 해제했다.
if (this._client) {
const engine = new SyncEngine({ remote: new SupabaseSyncRemote(this._client), userId })
engine.on('progress', (payload) => this.emit('sync-progress', payload))
this._engine = engine
}
// 5) renderer 게이트 해제 — DB가 열리고 티어가 반영된 뒤에 emit
this.emit('auth-changed', { user: session.user })
// 6) Realtime 구독 자동 시작
void this.startRealtime().catch((err) => {
logger.warn(
`Realtime 자동 시작 실패: ${err instanceof Error ? err.message : String(err)}`
)
})
// 7) 이 데스크톱을 계정의 기기 목록에 등록(모바일 "연결된 기기"), 주기 점검 시작
void this._checkInDevice(opts.reason)
this._startHeartbeat()
// 8) 최초 동기화: 대조(1회) → 로컬 변경 push → 원격 변경·삭제 pull.
// fire-and-forget — UI는 이미 해제됨. 실패해도 outbox에 남아 다음 트리거에 재시도된다.
void this._runEngine('full')
.then((result) => {
logger.info(
`[auth:${opts.reason}] Initial sync done: pushed=${result.pushed} pulled=${result.pulled} deleted=${result.deleted} errors=${result.errors.length}`
)
})
.catch((err) => {
logger.warn(
`[auth:${opts.reason}] Initial sync failed: ${err instanceof Error ? err.message : String(err)}`
)
})
}
/**
* 빅뱅 Phase 4: Supabase `subscriptions` 테이블에서 사용자의 현재 티어를 조회.
* - row 없음 → 'free' (auth trigger가 가입 시 자동 생성하므로 거의 발생 안 함)
* - tier 값 비정상 → 'free'
* - 네트워크 실패 → throw (caller가 warn + 현재 티어 유지)
*/
private async _fetchSubscriptionTier(userId: string): Promise<LicenseTier> {
if (!this._client) {
throw new D3ROError(ErrorCode.LLMServerUnreachable, 'Supabase client not initialized')
}
const { data, error } = await this._client
.from('subscriptions')
.select('tier, status')
.eq('user_id', userId)
.eq('status', 'active')
.maybeSingle()
if (error) {
throw new Error(error.message)
}
if (!data) return 'free'
const tier = data.tier as LicenseTier
if (tier === 'pro' || tier === 'pro_plus' || tier === 'team' || tier === 'enterprise' || tier === 'free') {
return tier
}
return 'free'
}
/**
* signOut 전 in-flight 세션/녹음을 안전하게 중단시키는 단일 진입점.
* VoiceMode/MeetingMode/Caption 진행 중이면 먼저 멈추고, 그 다음 Realtime stop,
* 그 다음 auth-changed(null) emit, 마지막으로 DB close.
*/
private async _onSignOut(options: { unregister: boolean } = { unregister: true }): Promise<void> {
if (this._signingOut) return
this._signingOut = true
try {
await this._runSignOut(options)
} finally {
this._signingOut = false
}
}
/** 진행 중인 받아쓰기·회의 녹음·자막을 지금 열린 DB 에 끝낸다(DB 를 닫거나 바꾸기 전). */
private async _stopActiveCapture(tag: string): Promise<void> {
try {
const { getVoiceModeService } = await import('./VoiceModeService')
const voiceMode = getVoiceModeService()
if (voiceMode.isActive) {
voiceMode.cancelSession()
logger.info(`[${tag}] VoiceMode active session cancelled`)
}
} catch (err) {
logger.warn(
`[${tag}] VoiceMode cancel failed: ${err instanceof Error ? err.message : String(err)}`
)
}
try {
const { getMeetingModeService } = await import('./MeetingModeService')
const meetingMode = getMeetingModeService()
if (meetingMode.isMeetingModeActive()) {
await meetingMode.stopRecording()
logger.info(`[${tag}] MeetingMode recording stopped`)
}
} catch (err) {
logger.warn(
`[${tag}] MeetingMode stop failed: ${err instanceof Error ? err.message : String(err)}`
)
}
try {
const { getCaptionService } = await import('./CaptionService')
const captionService = getCaptionService()
await captionService.stop()
} catch (err) {
logger.warn(
`[${tag}] Caption stop failed: ${err instanceof Error ? err.message : String(err)}`
)
}
}
private async _runSignOut(options: { unregister: boolean }): Promise<void> {
// 오프라인 복원 대기도 끝낸다 — 로그아웃한 계정의 토큰으로 다시 복원하지 않게.
this._cancelRestoreRetry()
this._offlineUserId = null
// 1) 활성 녹음/세션 강제 종료 (DB close 전에 flush 기회 제공)
await this._stopActiveCapture('signOut')
// 2) Realtime 구독·주기 작업 종료, 엔진 해제
await this.stopRealtime()
this._stopHeartbeat()
const engine = this._engine
engine?.dispose()
this._engine = null
// 3) 사용자가 직접 로그아웃하면 기기 목록에서도 빠진다(원격 해제로 로그아웃될 때는 이미 해제됨).
if (options.unregister && this._client && this._session) {
await unregisterDesktopDevice(this._client).catch(() => undefined)
}
// 4) Supabase 세션 무효화 — 이 기기의 세션만(scope:'local').
// 기본값 'global' 은 계정의 모든 refresh token 을 폐기해 휴대폰·다른 PC 까지 로그아웃시켰다.
// 서버가 실패를 돌려줘도 클라이언트의 세션은 반드시 버린다(_revokeLocalSession).
if (this._client && this._session) {
await this._revokeLocalSession()
}
// 4) in-memory 상태 + 저장된 토큰 clear
this._session = null
this._clearStoredRefreshToken()
// 5) LicenseService 티어를 free로 리셋 (빅뱅 Phase 4 — 익명 로컬 모드)
// pro/pro_plus 캐시가 남아있으면 premium feature gate가 이상하게 동작
try {
const { getLicenseService } = await import('./LicenseService')
getLicenseService().resetToFree()
} catch (err) {
logger.warn(
`[signOut] License reset failed: ${err instanceof Error ? err.message : String(err)}`
)
}
// 6) 사용자 DB 닫고 로컬 모드 DB로 복귀
// — 로그아웃 후에도 앱은 익명 로컬 모드로 계속 동작 (entry point 철학)
// 진행 중이던 pull이 끝나기를(최대 ENGINE_STOP_TIMEOUT_MS) 기다린다. 해제된 엔진은 다음 await에서 멈추고,
// 시간이 넘어도 사용자 DB 검사가 로컬 모드 DB에 쓰는 것을 막는다.
if (engine && !(await engine.whenIdle(ENGINE_STOP_TIMEOUT_MS))) {
logger.warn('[signOut] Sync engine did not stop in time — continuing (writes are blocked by user DB guard)')
}
closeCurrent()
try {
const { dbPath } = openLocal()
logger.info(`[signOut] Reverted to local DB: ${dbPath}`)
} catch (err) {
logger.error(
`[signOut] Local DB reopen failed: ${err instanceof Error ? err.message : String(err)}`
)
}
// 7) renderer에 auth-changed(null) emit — Settings는 다시 로그인 화면으로,
// 메인 UI는 로컬 모드로 계속 동작
this.emit('auth-changed', { user: null })
logger.info('Signed out — continuing in local mode')
}
// ── 상태 조회 ──────────────────────────────────────────
isEnabled(): boolean {
return this._client !== null
}
isAuthenticated(): boolean {
return this._session !== null
}
getUser(): User | null {
return this._session?.user ?? null
}
/**
* Phase 3.2: Premium LLM proxy 호출 시 Supabase Edge Function Authorization
* 헤더에 사용할 JWT access token 반환. null이면 비로그인 상태.
*
* 중요: 캐시된 _session이 아닌 Supabase 클라이언트에서 최신 세션을 직접 가져옴.
* _session은 로그인 시점에만 설정되지만, Supabase 클라이언트 내부에서 자동
* refresh된 토큰은 _session에 반영되지 않아 stale JWT가 될 수 있음.
*/
async getAccessToken(): Promise<string | null> {
return this._currentAccessToken()
}
/**
* 자격 증명의 단일 관문 — 이 서비스가 로그아웃 상태(_session=null)면 클라이언트에 무엇이 남아 있든 null.
* 기다리는 동안 계정이 바뀌거나 로그아웃되면 그 토큰도 버린다.
*/
private async _currentAccessToken(): Promise<string | null> {
const client = this._client
const session = this._session
if (!client || !session) return null
const { data } = await client.auth.getSession()
if (this._client !== client || this._session?.user.id !== session.user.id) return null
const current = data.session
if (!current || current.user?.id !== session.user.id) return null
return current.access_token ?? null
}
/**
* Phase 3.2: Edge Function 호출을 위한 Supabase 프로젝트 URL.
* 없으면 SaaS 미설정 상태.
*/
getSupabaseUrl(): string | null {
const url = configGet('supabaseUrl') as string | undefined
return url ?? null
}
/**
* Phase 3.2: Edge Function 호출 시 apikey 헤더에 필요한 anon key.
*/
getAnonKey(): string | null {
const key = configGet('supabaseAnonKey') as string | undefined
return key ?? null
}
/**
* Phase 3.2: Supabase Edge Function 호출 — 클라이언트가 auth 헤더를 올바르게 처리.
* raw fetch 대신 이걸 사용해야 gateway 레벨 401 방지.
*/
async invokeFunction(
name: string,
body: Record<string, unknown> | FormData,
options?: { signal?: AbortSignal; timeoutMs?: number }
): Promise<{ data: unknown; error: { message: string } | null }> {
if (!this._client) {
return { data: null, error: { message: 'Supabase client not initialized' } }
}
// 최신 세션 확보 (auto-refresh 보장) — 로그아웃 상태면 클라이언트에 남은 세션을 쓰지 않는다
const token = await this._currentAccessToken()
if (!token || !this._client) {
return { data: null, error: { message: 'No active session — 로그인 필요' } }
}
const { data, error } = await this._client.functions.invoke(name, {
body,
headers: { Authorization: `Bearer ${token}` },
signal: options?.signal,
timeout: options?.timeoutMs
})
if (error) {
let detail = error.message ?? String(error)
try {
if ('context' in error && error.context instanceof Response) {
const respBody = await (error.context as Response).json()
detail = JSON.stringify(respBody)
}
} catch {
// body 파싱 실패 시 기본 메시지 사용
}
return { data: null, error: { message: detail } }
}
return { data, error: null }
}
/**
* Edge Function 스트리밍 호출 — SSE 응답의 ReadableStream 반환.
* Supabase JS의 functions.invoke()는 JSON 자동 파싱하므로 SSE에 부적합.
* raw fetch + auth 토큰으로 직접 호출.
*/
async invokeFunctionStream(
name: string,
body: Record<string, unknown>,
signal?: AbortSignal,
): Promise<{ stream: ReadableStream<Uint8Array> | null; error: { message: string } | null }> {
if (!this._client) {
return { stream: null, error: { message: 'Supabase client not initialized' } }
}
const token = await this._currentAccessToken()
if (!token) {
return { stream: null, error: { message: 'No active session — 로그인 필요' } }
}
const url = configGet('supabaseUrl') as string | undefined
const anonKey = configGet('supabaseAnonKey') as string | undefined
if (!url || !anonKey) {
return { stream: null, error: { message: 'Supabase URL/key not configured' } }
}
try {
const response = await fetch(`${url}/functions/v1/${name}`, {
method: 'POST',
headers: {
Authorization: `Bearer ${token}`,
apikey: anonKey,
'Content-Type': 'application/json',
},
body: JSON.stringify(body),
signal,
})
if (!response.ok) {
const text = await response.text()
return { stream: null, error: { message: `${response.status}: ${text}` } }
}
if (!response.body) {
return { stream: null, error: { message: 'No response body' } }
}
return { stream: response.body, error: null }
} catch (err) {
if ((err as Error).name === 'AbortError') {
return { stream: null, error: { message: 'Request aborted' } }
}
return { stream: null, error: { message: err instanceof Error ? err.message : String(err) } }
}
}
/** 세션은 없지만 저장된 계정으로 오프라인 동작 중인지 (복원 재시도 대기) */
isOfflineAccount(): boolean {
return this._session === null && this._offlineUserId !== null
}
getState(): CloudSyncState {
const status = this.getSyncStatus()
return {
authenticated: this.isAuthenticated(),
userEmail: this._session?.user?.email ?? null,
lastSyncAt: this._lastSyncAt,
syncing: this._syncing,
pendingChanges: status?.pending ?? 0,
failedChanges: status?.parked ?? 0,
}
}
getLastSyncAt(): Date | null {
return this._lastSyncAt ? new Date(this._lastSyncAt) : null
}
// ── Realtime 구독 ──────────────────────────────────────
/**
* 원격 변경사항을 실시간으로 구독한다.
* 동기화 대상 테이블·삭제 기록(sync_tombstones)에 변경이 오면 debounce 후 pull,
* devices 변경이 오면 이 기기의 연결 해제 여부를 확인한다.
* 중복 호출 방지를 위해 기존 채널이 있으면 먼저 해제.
*/
startRealtime(): Promise<void> {
// heartbeat·재시도 타이머·인증 처리가 동시에 부를 수 있다. 겹치면 realtime-js 가 같은 topic 의
// 기존 채널 객체를 돌려줘 postgres_changes 바인딩이 호출마다 중복으로 쌓였다 — 한 번에 하나만 돈다.
if (!this._realtimeStarting) {
this._realtimeStarting = this._startRealtime().finally(() => {
this._realtimeStarting = null
})
}
return this._realtimeStarting
}
private async _startRealtime(): Promise<void> {
if (!this._client || !this._session) {
logger.warn('Realtime 시작 불가 — 로그인 필요')
return
}
if (this._realtimeChannel) {
const previous = this._realtimeChannel
this._realtimeChannel = null
// unsubscribe 만 하면 클라이언트 레지스트리에 채널이 남아 같은 topic 으로 재사용된다
await this._client.removeChannel(previous)
}
const userId = this._session.user.id
// postgres_changes 채널이 RLS를 통과하도록 access token을 realtime에 넣는다(TIMED_OUT 버그 픽스).
// 로그인 시점의 토큰은 1시간 뒤 만료되므로, 클라이언트의 현재 세션(필요하면 갱신)에서 꺼낸다 —
// 만료된 토큰으로 재구독하면 CHANNEL_ERROR만 반복한다.
try {
const { data } = await this._client.auth.getSession()
if (!this._session || !this._client) return
await this._client.realtime.setAuth(data.session?.access_token ?? this._session.access_token)
} catch (err) {
logger.warn(
`Realtime setAuth 실패 (계속 진행): ${err instanceof Error ? err.message : String(err)}`
)
}
if (!this._session || !this._client) return
let channel = this._client.channel(`cloud-sync:${userId}`)
for (const table of realtimeTables()) {
channel = channel.on(
'postgres_changes',
{ event: '*', schema: 'public', table, filter: `user_id=eq.${userId}` },
() => this._schedulePull()
)
}
// 이 계정의 기기 목록이 바뀌면(다른 기기에서 연결 해제 포함) 등록 상태를 다시 확인한다.
channel = channel.on(
'postgres_changes',
{ event: '*', schema: 'public', table: 'devices', filter: `user_id=eq.${userId}` },
() => void this._checkInDevice('heartbeat')
)
const subscribed = channel.subscribe((status) => {
// 교체된 이전 채널의 CLOSED 는 무시한다 — 재구독을 다시 예약해 채널이 겹치게 된다
if (this._realtimeChannel !== subscribed) return
logger.info(`Realtime 채널 상태: ${status}`)
// U1: TIMED_OUT / CHANNEL_ERROR / CLOSED 시 지수 백오프 자동 재구독.
// Supabase realtime은 네트워크 jitter로 간헐적 TIMED_OUT이 발생할 수 있고,
// 이때 기본 fallback(Phase 3.3 auto push)은 동작하지만 다른 기기 변경은 놓친다.
// 1s → 3s → 10s 3회 시도 후 포기. 성공(SUBSCRIBED) 시 카운터 리셋.
if (status === 'SUBSCRIBED') {
this._realtimeRetryCount = 0
if (this._realtimeRetryTimer) {
clearTimeout(this._realtimeRetryTimer)
this._realtimeRetryTimer = null
}
return
}
if (status === 'TIMED_OUT' || status === 'CHANNEL_ERROR' || status === 'CLOSED') {
this._scheduleRealtimeRetry()
}
})
this._realtimeChannel = subscribed
}
/**
* Realtime 재구독 지수 백오프 스케줄러 (U1).
* - 1차: 1s, 2차: 3s, 3차: 10s
* - 3회 초과 시 포기 (Auto push fallback만으로 동작)
* - 이미 스케줄돼 있으면 no-op (중복 방지)
*/
private _scheduleRealtimeRetry(): void {
if (this._realtimeRetryTimer) return
if (!this._client || !this._session) return
const MAX_RETRIES = 3
const DELAYS_MS = [1000, 3000, 10000]
if (this._realtimeRetryCount >= MAX_RETRIES) {
logger.warn(
`Realtime 재구독 ${MAX_RETRIES}회 실패 — Auto push fallback으로만 동작. 수동 재시도: cloudSync.startRealtime()`
)
return
}
const delay = DELAYS_MS[this._realtimeRetryCount]
this._realtimeRetryCount++
const attempt = this._realtimeRetryCount
logger.info(`Realtime 재구독 예약 (${attempt}/${MAX_RETRIES}): ${delay}ms 후`)
this._realtimeRetryTimer = setTimeout(() => {
this._realtimeRetryTimer = null
if (!this._session) return
void this.startRealtime().catch((err) => {
logger.warn(
`Realtime 재구독 실패 (${attempt}/${MAX_RETRIES}): ${err instanceof Error ? err.message : String(err)}`
)
})
}, delay)
}
async stopRealtime(): Promise<void> {
if (this._realtimeRetryTimer) {
clearTimeout(this._realtimeRetryTimer)
this._realtimeRetryTimer = null
}
this._realtimeRetryCount = 0
if (this._realtimeChannel) {
const channel = this._realtimeChannel
this._realtimeChannel = null
if (this._client) await this._client.removeChannel(channel)
else await channel.unsubscribe()
logger.info('Realtime 채널 종료')
}
}
// ── OAuth 로그인 ───────────────────────────────────────
/**
* OAuth 로그인 시작 — Supabase가 발급한 URL을 외부 브라우저로 열기.
* 사용자가 동의 후 d3ro-voice://auth-callback?code=...로 deep link 호출됨.
*/
async startSignIn(provider: 'google' | 'github'): Promise<void> {
if (!this._client) {
throw new D3ROError(ErrorCode.LLMServerUnreachable, 'Cloud Sync가 설정되지 않았습니다')
}
const redirectTo = 'd3ro-voice://auth-callback'
const { data, error } = await this._client.auth.signInWithOAuth({
provider,
options: {
redirectTo,
skipBrowserRedirect: true
}
})
if (error || !data.url) {
throw new D3ROError(
ErrorCode.LLMProcessingFailed,
`OAuth 시작 실패: ${error?.message ?? 'unknown'}`
)
}
// 이 앱이 요청한 로그인만 받아들인다: 콜백은 이 시각 이후 한 번만 유효하다.
this._pendingSignInUntil = Date.now() + SIGN_IN_WINDOW_MS
logger.info(`Opening OAuth URL in external browser: ${provider}`)
if (!(await openExternalSafe(data.url))) {
this._pendingSignInUntil = null
throw new D3ROError(ErrorCode.LLMProcessingFailed, 'OAuth URL is not an https URL')
}
}
/**
* deep link 로그인 콜백을 받아들일지. 사용자가 방금 로그인을 시작했고(startSignIn) 이미 로그인된 상태가
* 아닐 때만 한 번 허용한다 — 아무 웹페이지나 d3ro-voice://auth-callback#access_token=... 으로 앱을
* 공격자 계정에 로그인시켜 로컬 기록을 그 계정으로 올리게 하는 것(login CSRF)을 막는다.
*/
private _consumePendingSignIn(): void {
const until = this._pendingSignInUntil
this._pendingSignInUntil = null
if (until === null || Date.now() > until) {
throw new D3ROError(ErrorCode.LLMProcessingFailed, 'Ignored sign-in callback: no sign-in was started from this app')
}
if (this._session) {
throw new D3ROError(ErrorCode.LLMProcessingFailed, 'Ignored sign-in callback: already signed in — sign out first')
}
}
/**
* Deep link 콜백 처리 — PKCE flow code를 session으로 교환.
* 성공 시 _onAuthenticated(단일 진입점)로 수렴.
*/
async handleAuthCallback(code: string): Promise<void> {
if (!this._client) {
throw new D3ROError(ErrorCode.LLMServerUnreachable, 'Cloud Sync가 설정되지 않았습니다')
}
this._consumePendingSignIn()
const { data, error } = await this._client.auth.exchangeCodeForSession(code)
if (error || !data.session) {
throw new D3ROError(
ErrorCode.LLMProcessingFailed,
`세션 교환 실패: ${error?.message ?? 'unknown'}`
)
}
this._saveRefreshToken(data.session.refresh_token, data.session.user.id)
logger.info(`Signed in: ${data.session.user.email ?? data.session.user.id}`)
await this._onAuthenticated(data.session, { reason: 'signin' })
}
/**
* Deep link 콜백 처리 — Implicit flow로 받은 access/refresh token을
* client.auth.setSession()에 주입하여 세션 복원.
*
* supabase-js가 `persistSession: false`로 떠 있을 때 PKCE code_verifier 저장이
* 없어서 PKCE가 제대로 동작하지 않는다. Supabase가 implicit flow로 떨어져
* fragment(#access_token=...&refresh_token=...)에 토큰을 담아 보내는데, 이때
* 이 메서드를 사용한다.
*/
async handleAuthTokens(params: {
accessToken: string
refreshToken: string
}): Promise<void> {
if (!this._client) {
throw new D3ROError(ErrorCode.LLMServerUnreachable, 'Cloud Sync가 설정되지 않았습니다')
}
this._consumePendingSignIn()
const { data, error } = await this._client.auth.setSession({
access_token: params.accessToken,
refresh_token: params.refreshToken,
})
if (error || !data.session) {
throw new D3ROError(
ErrorCode.LLMProcessingFailed,
`세션 설정 실패: ${error?.message ?? 'unknown'}`
)
}
this._saveRefreshToken(data.session.refresh_token, data.session.user.id)
logger.info(`Signed in (implicit): ${data.session.user.email ?? data.session.user.id}`)
await this._onAuthenticated(data.session, { reason: 'signin' })
}
/**
* 로그아웃 — 단일 진입점 _onSignOut에서 세션/DB/녹음 모두 안전하게 정리.
*/
async signOut(): Promise<void> {
await this._onSignOut()
}
// ── 동기화 ─────────────────────────────────────────────
/**
* 로컬 변경 기록(outbox) + 짧은 지연 뒤 push.
* 로그인 상태가 아니면(익명 로컬 모드) 기록하지 않는다 — 로그인 시 최초 대조가 올린다.
*/
pushOne(entity: SyncEntity, id: string): void {
this._recordChange(entity, id, 'upsert')
}
/** 로컬 삭제를 다른 기기로 전파한다. */
pushDelete(entity: SyncEntity, id: string): void {
this._recordChange(entity, id, 'delete')
}
/**
* 변경을 이 계정 DB 의 outbox 에 기록한다. 엔진이 아직 없어도(로그인 직후 티어 조회 중,
* 오프라인 복원 대기 중) 기록한다 — 예전엔 버려져 최초 대조가 끝난 계정에서는 영영 올라가지 않았다.
* 엔진이 있을 때만 곧바로 flush 를 예약한다(없으면 엔진 생성 후 최초 동기화가 올린다).
*/
private _recordChange(entity: SyncEntity, id: string, op: 'upsert' | 'delete'): void {
const accountUserId = this._session?.user.id ?? this._offlineUserId
if (!accountUserId || getCurrentUserId() !== accountUserId) return
try {
enqueueChange(entity, id, op)
} catch (err) {
// 로컬 write는 절대 막지 않는다 — 다음 최초 대조가 없는 행을 다시 찾는다.
logger.warn(`Sync enqueue ${entity}/${id} failed: ${err instanceof Error ? err.message : String(err)}`)
return
}
if (this._engine && this._session) this._scheduleFlush()
}
private _scheduleFlush(): void {
this._scheduler.scheduleFlush()
}
private _schedulePull(): void {
this._scheduler.schedulePull()
}
/** 수동 "업로드": 보관된 실패 항목도 다시 시도한다. */
async pushAll(): Promise<SyncResult> {
const result = await this._runEngine('flush', { releaseParked: true })
return { pushed: result.pushed, errors: result.errors }
}
/** 수동 "다운로드". */
async pullAll(): Promise<SyncResult> {
const result = await this._runEngine('pull')
return { pushed: result.pulled + result.deleted, errors: result.errors }
}
private async _runEngine(
kind: 'full' | 'flush' | 'pull',
options: { releaseParked?: boolean } = {}
): Promise<SyncRunResult> {
const engine = this._engine
if (!engine || !this._session) {
throw new D3ROError(ErrorCode.LLMServerUnreachable, '로그인이 필요합니다')
}
this._syncing = true
try {
const result =
kind === 'full'
? await engine.runFullSync()
: kind === 'flush'
? await engine.flush(options)
: await engine.pull()
if (engine !== this._engine) return result
if (kind !== 'flush') {
this._lastSyncAt = Date.now()
configSet('cloudSyncLastAt', this._lastSyncAt)
}
if (result.changed.length > 0) this.emit('data-changed', { entities: result.changed })
this.emit('sync-complete', { pushed: result.pushed + result.pulled + result.deleted, errors: result.errors })
if (result.errors.length > 0) {
logger.warn(`Sync ${kind} finished with ${result.errors.length} error(s): ${result.errors.slice(0, 3).join(' | ')}`)
}
return result
} catch (err) {
const message = err instanceof Error ? err.message : String(err)
if (err instanceof SyncAbortedError || engine !== this._engine) {
// 로그아웃·계정 전환으로 멈춘 동기화 — 사용자에게 알릴 오류가 아니다.
logger.info(`Sync ${kind} stopped: ${message}`)
throw err
}
logger.error(`Sync ${kind} failed: ${message}`)
this.emit('sync-error', { error: message })
throw err
} finally {
this._syncing = false
}
}
// ── 기기 등록 ──────────────────────────────────────────
private async _checkInDevice(reason: 'signin' | 'restore' | 'heartbeat'): Promise<void> {
const client = this._client
const session = this._session
if (!client || !session) return
let known: string | null = null
try {
known = getSyncState(DEVICE_STATE_KEY)
} catch {
known = null
}
try {
const check = await checkInDesktopDevice(
client,
session.user.id,
reason,
currentDeviceInfo(app.getVersion()),
reason === 'signin' ? null : known
)
if (check.status === 'active') {
setSyncState(DEVICE_STATE_KEY, check.deviceId)
} else if (check.status === 'revoked' && this._session === session) {
logger.warn('This desktop was disconnected from another device — signing out')
await this._onSignOut({ unregister: false })
this.emit('sync-error', {
error: 'This computer was disconnected from your account on another device. Sign in again to keep syncing.',
})
}
} catch (err) {
logger.warn(`Device check-in (${reason}) failed: ${err instanceof Error ? err.message : String(err)}`)
}
}
private _startHeartbeat(): void {
this._scheduler.startHeartbeat()
}
private _onHeartbeat(): void {
if (!this._session) return
void this._checkInDevice('heartbeat')
// 재구독을 포기한 채널(3회 실패)을 되살린다 — 네트워크가 돌아온 뒤에도 실시간이 끊겨 있지 않게.
if (this._realtimeChannel?.state !== 'joined') {
this._realtimeRetryCount = 0
void this.startRealtime().catch(() => undefined)
}
// Realtime 이벤트를 놓쳤을 때의 안전망
void this._runEngine('full').catch(() => undefined)
}
private _stopHeartbeat(): void {
this._scheduler.stop()
}
/**
* 다른 기기(모바일·웹)에서 녹음한 기록의 재생 URL(5분 서명). 로컬 파일이 없을 때만 쓴다.
* 로그인 전이거나 서버에 녹음이 없으면 null.
*/
async createHistoryAudioUrl(historyId: string): Promise<string | null> {
const client = this._client
const session = this._session
if (!client || !session) return null
const { data, error } = await client
.from('audio_files')
.select('storage_key,upload_status')
.eq('user_id', session.user.id)
.eq('history_id', historyId)
.eq('upload_status', 'uploaded')
.order('created_at', { ascending: false })
.limit(1)
.maybeSingle()
if (error || !data || typeof data.storage_key !== 'string') return null
if (!data.storage_key.startsWith(`${session.user.id}/`)) return null
const signed = await client.storage.from(AUDIO_BUCKET).createSignedUrl(data.storage_key, 300)
return signed.error ? null : signed.data.signedUrl
}
getSyncStatus(): SyncStatus | null {
if (!this._engine) return null
try {
return this._engine.getStatus()
} catch {
return null
}
}
// ── 토큰 영속화 (electron safeStorage) — SessionTokenStore 에 위임 ─────
private _tokens(): SessionTokenStore {
if (!this._tokenStore) {
this._tokenStore = new EncryptedFileTokenStore(
path.join(app.getPath('userData'), TOKEN_FILE),
safeStorage,
{
existsSync: (p) => fs.existsSync(p),
readFileSync: (p) => fs.readFileSync(p),
writeFileSync: (p, data) => fs.writeFileSync(p, data),
unlinkSync: (p) => fs.unlinkSync(p),
},
logger
)
}
return this._tokenStore
}
private _saveRefreshToken(token: string, userId: string): void {
this._tokens().save(token, userId)
}
private _loadStoredSession(): StoredSessionRecord | null {
return this._tokens().loadRecord()
}
private _clearStoredRefreshToken(): void {
this._tokens().clear()
}
/** 테스트 전용: 타이머·auth 구독을 해제한다. */
disposeForTests(): void {
this._scheduler.stop()
this._cancelRestoreRetry()
this._unbindAuthEvents?.()
this._unbindAuthEvents = null
void this._client?.auth.stopAutoRefresh().catch(() => undefined)
this.removeAllListeners()
}
// ── EventEmitter 타입 오버라이드 ───────────────────────
override on<K extends keyof CloudSyncEvents>(event: K, listener: CloudSyncEvents[K]): this {
return super.on(event, listener)
}
override emit<K extends keyof CloudSyncEvents>(
event: K,
...args: Parameters<CloudSyncEvents[K]>
): boolean {
return super.emit(event, ...args)
}
}
// ── 싱글톤 ─────────────────────────────────────────────
let instance: CloudSyncService | null = null
export function resetCloudSyncServiceForTests(): void {
if (instance) instance.disposeForTests()
instance = null
}
export function getCloudSyncService(): CloudSyncService {
if (!instance) {
instance = new CloudSyncService()
}
return instance
}