fix(desktop): harden session, meeting, caption and LLM lifecycles; route LLM calls through the gateway

This commit is contained in:
Yun Chan 2026-09-28 02:16:15 +09:00
parent 3a46437f28
commit ddc78546f0
62 changed files with 4786 additions and 648 deletions

View file

@ -17,13 +17,26 @@ import {
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 } from '../db'
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 } from './sync/session-token-store'
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'
@ -105,6 +118,15 @@ class CloudSyncService extends EventEmitter {
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,
@ -144,7 +166,8 @@ class CloudSyncService extends EventEmitter {
() => this._session?.user.id ?? null,
(session) => {
this._session = session
}
},
() => this._onRemoteSignedOut()
)
// 언어·테마·자동 다듬기·활성 명령이 바뀌면 모바일 user_settings 로 올린다(원격 반영 중엔 제외).
@ -165,39 +188,9 @@ class CloudSyncService extends EventEmitter {
})
// 저장된 refresh token 복원
const stored = this._loadStoredRefreshToken()
const stored = this._loadStoredSession()
if (stored) {
try {
const { data, error } = await this._client.auth.refreshSession({ refresh_token: stored })
if (error) {
// U3: 장시간 idle 후 refresh token 소진 시 사용자에게 재인증 필요를
// 알리기 위해 error 로깅 승격 + sync-error + auth-changed(user:null) emit.
// 기존에는 조용히 토큰만 삭제해서 사용자가 "왜 로그아웃됐지?" 상태로 방치됐음.
logger.error(
`세션 복원 실패 — 재로그인 필요: ${error.message} (토큰 만료 또는 서버 세션 무효화)`
)
this._clearStoredRefreshToken()
this.emit('sync-error', {
error: `Sign-in session expired. Please sign in again. (${error.message})`,
})
this.emit('auth-changed', { user: null })
} else if (data.session) {
this._saveRefreshToken(data.session.refresh_token)
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) {
const message = err instanceof Error ? err.message : String(err)
logger.error(`세션 복원 예외 — 재로그인 필요: ${message}`)
this._clearStoredRefreshToken()
this.emit('sync-error', {
error: `Sign-in session restore failed. Please sign in again. (${message})`,
})
this.emit('auth-changed', { user: null })
}
await this._restoreSession(stored)
} else {
// 저장된 토큰 없음 → 미인증 상태를 렌더러에 명시 전달
this.emit('auth-changed', { user: null })
@ -206,6 +199,141 @@ class CloudSyncService extends EventEmitter {
logger.info('CloudSyncService initialized')
}
/**
* 저장된 계정 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 단일 진입점 ─────────────────────────
/**
@ -220,6 +348,8 @@ class CloudSyncService extends EventEmitter {
opts: { reason: 'restore' | 'signin' }
): Promise<void> {
const userId = session.user.id
// 로그인(또는 복원) 성공 — 오프라인 재시도는 더 필요 없다.
this._cancelRestoreRetry()
// 0) 이전 계정의 동기화를 먼저 멈춘다 — 새 DB가 열린 뒤 이전 엔진이 그 DB에 쓰지 않게.
const previous = this._engine
@ -229,8 +359,10 @@ class CloudSyncService extends EventEmitter {
await previous.whenIdle(ENGINE_STOP_TIMEOUT_MS)
}
this._session = session
this._offlineUserId = null
// 1) 사용자별 DB 열기 (Phase 1 — 사용자별 SQLite 격리)
// 이 시점부터 이 계정 DB 의 쓰기는 엔진이 만들어지기 전에도 outbox 에 기록된다(_recordChange).
try {
const { created, dbPath } = openForUser(userId)
logger.info(
@ -239,9 +371,11 @@ class CloudSyncService extends EventEmitter {
} catch (err) {
const message = err instanceof Error ? err.message : String(err)
logger.error(`[auth:${opts.reason}] DB open failed for ${userId}: ${message}`)
// DB를 열지 못하면 로그인 상태를 유지해서는 안 된다 — 즉시 signOut
// 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
@ -343,6 +477,20 @@ class CloudSyncService extends EventEmitter {
* 그 다음 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
}
}
private async _runSignOut(options: { unregister: boolean }): Promise<void> {
// 오프라인 복원 대기도 끝낸다 — 로그아웃한 계정의 토큰으로 다시 복원하지 않게.
this._cancelRestoreRetry()
this._offlineUserId = null
// 1) 활성 녹음/세션 강제 종료 (DB close 전에 flush 기회 제공)
try {
const { getVoiceModeService } = await import('./VoiceModeService')
@ -392,10 +540,11 @@ class CloudSyncService extends EventEmitter {
await unregisterDesktopDevice(this._client).catch(() => undefined)
}
// 4) Supabase 세션 무효화
// 4) Supabase 세션 무효화 — 이 기기의 세션만(scope:'local').
// 기본값 'global' 은 계정의 모든 refresh token 을 폐기해 휴대폰·다른 PC 까지 로그아웃시켰다.
if (this._client && this._session) {
try {
await this._client.auth.signOut()
await this._client.auth.signOut({ scope: 'local' })
} catch (err) {
logger.warn(`signOut warning: ${err instanceof Error ? err.message : String(err)}`)
}
@ -582,6 +731,11 @@ class CloudSyncService extends EventEmitter {
}
}
/** 세션은 없지만 저장된 계정으로 오프라인 동작 중인지 (복원 재시도 대기) */
isOfflineAccount(): boolean {
return this._session === null && this._offlineUserId !== null
}
getState(): CloudSyncState {
const status = this.getSyncStatus()
return {
@ -787,7 +941,7 @@ class CloudSyncService extends EventEmitter {
)
}
this._saveRefreshToken(data.session.refresh_token)
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' })
@ -822,7 +976,7 @@ class CloudSyncService extends EventEmitter {
)
}
this._saveRefreshToken(data.session.refresh_token)
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' })
@ -850,8 +1004,14 @@ class CloudSyncService extends EventEmitter {
this._recordChange(entity, id, 'delete')
}
/**
* 변경을 이 계정 DB 의 outbox 에 기록한다. 엔진이 아직 없어도(로그인 직후 티어 조회 중,
* 오프라인 복원 대기 중) 기록한다 — 예전엔 버려져 최초 대조가 끝난 계정에서는 영영 올라가지 않았다.
* 엔진이 있을 때만 곧바로 flush 를 예약한다(없으면 엔진 생성 후 최초 동기화가 올린다).
*/
private _recordChange(entity: SyncEntity, id: string, op: 'upsert' | 'delete'): void {
if (!this._session || !this._engine || getCurrentUserId() !== this._session.user.id) return
const accountUserId = this._session?.user.id ?? this._offlineUserId
if (!accountUserId || getCurrentUserId() !== accountUserId) return
try {
enqueueChange(entity, id, op)
} catch (err) {
@ -859,7 +1019,7 @@ class CloudSyncService extends EventEmitter {
logger.warn(`Sync enqueue ${entity}/${id} failed: ${err instanceof Error ? err.message : String(err)}`)
return
}
this._scheduleFlush()
if (this._engine && this._session) this._scheduleFlush()
}
private _scheduleFlush(): void {
@ -1029,12 +1189,12 @@ class CloudSyncService extends EventEmitter {
return this._tokenStore
}
private _saveRefreshToken(token: string): void {
this._tokens().save(token)
private _saveRefreshToken(token: string, userId: string): void {
this._tokens().save(token, userId)
}
private _loadStoredRefreshToken(): string | null {
return this._tokens().load()
private _loadStoredSession(): StoredSessionRecord | null {
return this._tokens().loadRecord()
}
private _clearStoredRefreshToken(): void {
@ -1044,6 +1204,7 @@ class CloudSyncService extends EventEmitter {
/** 테스트 전용: 타이머·auth 구독을 해제한다. */
disposeForTests(): void {
this._scheduler.stop()
this._cancelRestoreRetry()
this._unbindAuthEvents?.()
this._unbindAuthEvents = null
void this._client?.auth.stopAutoRefresh().catch(() => undefined)