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

@ -3,15 +3,22 @@
// 싱글톤 + EventEmitter 패턴. CaptionService 연동.
import { EventEmitter } from 'events'
import { BrowserWindow, Notification, dialog } from 'electron'
import { BrowserWindow, Notification, app, dialog } from 'electron'
import fs from 'fs'
import { dirname as pathDirname } from 'path'
import { eq, desc, sql } from 'drizzle-orm'
import { dirname as pathDirname, join as pathJoin } from 'path'
import { eq, desc, sql, inArray } from 'drizzle-orm'
import { getLogger } from './LoggerService'
import { configGet } from './ConfigService'
import { getCloudSyncService } from './CloudSyncService'
import { getMainWindow } from '../windows/WindowManager'
import { getDatabase } from '../db'
import { onAccountScopeChanged } from './account-scope'
import { getLlmGateway } from './llm/LlmGateway'
import { MeetingRecordingSession, type RecordingSnapshot } from './meeting/MeetingRecordingSession'
import { condenseTranscriptToBudget } from './meeting/transcript-condenser'
import { selectTranscriptExcerpts } from '@d3ro/core/meeting-llm-input'
import { LLM_PROXY_CHAT_LIMITS } from '@d3ro/core/llm-chat'
import type { MeetingChatHistoryTurn, MeetingLiveSession } from '@d3ro/core/meeting-live'
import { meetingSessions, meetingMemos, meetingDocuments } from '../db/schema'
import { IPC_CHANNELS } from '@d3ro/core/ipc-channels'
import { D3ROError, ErrorCode } from '@d3ro/core/errors'
@ -46,7 +53,6 @@ import type {
MeetingGenerateDocParams,
MeetingExportFormat,
MeetingDocGeneratingProgress,
CaptionSegment,
} from '@d3ro/core/types'
const logger = getLogger('MeetingModeService')
@ -57,46 +63,82 @@ const REWRITE_CHUNK_CHARS = 1500
const REWRITE_CHUNK_MAX_TOKENS = 2048
/** 회의 채팅 히스토리를 세션마다 이 개수(메시지)까지만 유지한다 */
const MAX_CHAT_HISTORY_MESSAGES = 20
/** 녹음 중 전사를 DB 에 남기는 주기 — 비정상 종료 시 잃는 양의 상한 */
const TRANSCRIPT_CHECKPOINT_MS = 15_000
/** 중단된 녹음(전사 없음)의 오류 메시지 — 저장용(UI 는 status 로 표시) */
const INTERRUPTED_MESSAGE = 'Recording was interrupted before it was saved'
/**
* 회의 기능이 쓰는 LLM 포트 — 백엔드 선택(local/online, 폴백)은 LlmGateway 한 곳이 정한다.
* 문서 생성·요약 입력은 이 한도(프록시 메시지 한도) 안으로 맞춘다.
*/
type MeetingLlm = {
generate: (
text: string,
options?: { systemPrompt?: string; temperature?: number; maxTokens?: number },
) => Promise<{ text: string; model?: string }>
chatStream: (
messages: Array<{ role: string; content: string }>,
options?: { temperature?: number },
) => AsyncGenerator<string, string>
}
/** 문서 생성 사용자 메시지의 머리말(LLM 지시문) */
const DOCUMENT_REQUEST_PREFIX = '다음 회의 전사록과 참석자 메모를 분석하여 문서를 작성해주세요:\n\n## 전사록\n'
const CONDENSED_NOTE = '(회의가 길어 구간별로 정리한 내용입니다)\n'
/** 채팅 system 프롬프트 머리말 여유 — 지시문·발췌 안내가 들어갈 자리 */
const CHAT_SYSTEM_OVERHEAD_CHARS = 600
/** 회의 녹음 WAV 경로 (화자 구분·동기화·삭제가 같은 규칙을 쓴다) */
function meetingAudioFilePathSync(sessionId: string): string {
return pathJoin(app.getPath('userData'), 'meeting-audio', `${sessionId}.wav`)
}
async function meetingAudioFilePath(sessionId: string): Promise<string> {
const { app } = await import('electron')
const path = await import('path')
return path.join(app.getPath('userData'), 'meeting-audio', `${sessionId}.wav`)
return meetingAudioFilePathSync(sessionId)
}
let isShowingMeetingSaveDialog = false
class MeetingModeService extends EventEmitter {
private _state: MeetingModeState = 'idle'
private _sessionId: string | null = null
private _sessionStartedAt: number | null = null
private _segments: CaptionSegment[] = []
private _memos: MeetingMemo[] = []
private _segmentHandler: ((segment: CaptionSegment) => void) | null = null
private _audioDataHandler: ((payload: { buffer: Buffer; timestamp: number }) => void) | null = null
/**
* 진행 중인 녹음. 녹음 한 건의 세그먼트·메모·오디오·구독은 이 객체가 단독으로 소유한다.
* 후처리가 끝날 때까지 남아 있어 getStateInfo 가 세션 id 를 계속 보고한다(실시간 편집 반영용).
*/
private _current: MeetingRecordingSession | null = null
/** 진행 중인 정지 — 동시에 온 정지 요청(두 번 클릭, 로그아웃)은 이 promise 를 함께 기다린다 */
private _stopInFlight: Promise<void> | null = null
private _audioLevelTimer: ReturnType<typeof setInterval> | null = null
private _lastRms = 0
private _checkpointTimer: ReturnType<typeof setInterval> | null = null
private _checkpointedSegments = 0
/** CaptionService session-saved 방지 플래그 */
private _meetingModeActive = false
/** Phase 15.5-2: 녹음 중 오디오 WAV 파일 보존 */
private _audioBuffersForFile: Buffer[] = []
// Phase 15: Meeting AI Chat — 세션마다 따로 보관한다(회의 A 의 질의응답이 B 로 새지 않게)
private _chatHistories = new Map<string, Array<{ role: 'user' | 'assistant'; content: string }>>()
private _chatAbortController: AbortController | null = null
/** 회의마다 진행 중인 채팅 — 한 회의의 취소가 다른 회의 채팅을 끊지 않게 */
private _chatAbortControllers = new Map<string, AbortController>()
private readonly _unsubscribeScope: () => void
constructor() {
super()
// 이 서비스가 내는 'error' 는 알림용이다 — 듣는 쪽이 없어도 throw 되지 않게 기본 수신자를 둔다
// (EventEmitter 는 리스너 없는 'error' 를 던져 후처리 catch 를 깨뜨렸다).
this.on('error', () => { /* default sink */ })
// 계정 DB 가 바뀔 때마다(로그인·로그아웃) 그 DB 에 남은 중단된 녹음을 정리한다.
this._unsubscribeScope = onAccountScopeChanged(() => {
try {
this.recoverInterruptedSessions()
} catch (err) {
logger.warn(`중단된 회의 정리 실패: ${err instanceof Error ? err.message : String(err)}`)
}
})
}
/** 테스트 전용: 타이머·구독을 푼다 */
disposeForTests(): void {
this._stopTimers()
this._unsubscribeScope()
this.cancelMeetingChat()
this.removeAllListeners()
}
// ── 공개 접근자 ──
@ -105,12 +147,30 @@ class MeetingModeService extends EventEmitter {
}
getStateInfo(): MeetingModeStateInfo {
const session = this._current
return {
state: this._state,
sessionId: this._sessionId,
elapsedMs: this._sessionStartedAt ? Date.now() - this._sessionStartedAt : 0,
memoCount: this._memos.length,
segmentCount: this._segments.length,
sessionId: session?.id ?? null,
elapsedMs: session ? session.elapsedMs() : 0,
memoCount: session?.memos.length ?? 0,
segmentCount: session?.segments.length ?? 0,
}
}
/**
* 진행 중인 녹음의 세그먼트·메모 사본. 녹음 화면을 다시 열었을 때(페이지 이동 후 복귀) 그동안의
* 실시간 전사와 메모를 복원한다. 녹음 중이 아니면 null.
*/
getLiveSession(): MeetingLiveSession | null {
const session = this._current
if (!session) return null
return {
sessionId: session.id,
state: this._state,
startedAt: session.startedAt,
elapsedMs: session.elapsedMs(),
segments: session.segments.map((segment) => ({ ...segment })),
memos: session.memos.map((memo) => ({ ...memo })),
}
}
@ -121,26 +181,23 @@ class MeetingModeService extends EventEmitter {
/** 활성 세션, 자막, 오디오 캡처 상태를 강제로 완전 초기화 */
async forceReset(): Promise<void> {
logger.warn('MeetingModeService: forceReset 실행')
if (this._audioLevelTimer) {
clearInterval(this._audioLevelTimer)
this._audioLevelTimer = null
}
if (this._audioDataHandler) {
try {
const { getAudioCaptureService } = await import('./AudioCaptureService')
getAudioCaptureService().off('audio-data', this._audioDataHandler)
} catch { /* noop */ }
this._audioDataHandler = null
this._stopTimers()
const session = this._current
if (session) {
session.detach()
// 아직 녹음 중이던 세션은 지금까지의 전사를 남기고 닫는다(행이 'recording' 으로 굳지 않게).
if (!session.isStopping) {
try {
this._persistSnapshot(session.checkpoint({ includeAudio: true }), { interrupted: true })
} catch (err) {
logger.warn(`forceReset 전사 저장 실패: ${err instanceof Error ? err.message : String(err)}`)
}
}
}
try {
const { getCaptionService } = await import('./CaptionService')
const captionService = getCaptionService()
// 강제 정지(소유자 무시) 후 구독을 푼다
await captionService.stop().catch(() => null)
if (this._segmentHandler) {
captionService.off('segment', this._segmentHandler)
this._segmentHandler = null
}
// 강제 정지(소유자 무시)
await getCaptionService().stop().catch(() => null)
} catch { /* noop */ }
try {
@ -148,11 +205,8 @@ class MeetingModeService extends EventEmitter {
await getAudioCaptureService().stop().catch(() => {})
} catch { /* noop */ }
this._meetingModeActive = false
this._sessionId = null
this._sessionStartedAt = null
this._segments = []
this._memos = []
this._stopInFlight = null
this._resetSession()
this._setState('idle')
this._sendStateToRenderer()
}
@ -192,11 +246,6 @@ class MeetingModeService extends EventEmitter {
const sessionId = crypto.randomUUID()
const now = Date.now()
this._sessionId = sessionId
this._sessionStartedAt = now
this._segments = []
this._memos = []
// DB에 세션 생성
const db = getDatabase()
db.insert(meetingSessions).values({
@ -207,13 +256,41 @@ class MeetingModeService extends EventEmitter {
updatedAt: now,
}).run()
// CaptionService 시작 (오버레이 숨김 상태로 — 회의 모드 UI에서 자체 표시)
this._segmentHandler = (segment: CaptionSegment) => {
this._segments.push(segment)
this.emit('segment', segment)
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.SEGMENT, segment)
}
captionService.on('segment', this._segmentHandler)
const { getAudioCaptureService, calculateRMS } = await import('./AudioCaptureService')
const audioCaptureService = getAudioCaptureService()
const session = new MeetingRecordingSession(
sessionId,
now,
{
caption: {
onSegment: (listener) => {
captionService.on('segment', listener)
return () => { captionService.off('segment', listener) }
},
// 회의가 소유한 세션만 멈춘다. 다른 소유자면 false(요약 없음).
stop: () => captionService.stop('meeting'),
},
audio: {
onChunk: (listener) => {
const handler = (payload: { buffer: Buffer; timestamp: number }): void => listener(payload.buffer)
audioCaptureService.on('audio-data', handler)
return () => { audioCaptureService.off('audio-data', handler) }
},
},
onSegment: (segment) => {
this.emit('segment', segment)
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.SEGMENT, segment)
},
onStopError: (err) => {
logger.error(`자막 정지 실패 — 지금까지의 전사로 저장한다: ${err instanceof Error ? err.message : String(err)}`)
},
},
calculateRMS,
)
this._current = session
this._checkpointedSegments = 0
// 세그먼트 구독은 자막 시작 전에 건다 — 첫 문장을 놓치지 않게.
session.attachCaption()
try {
// 회의 모드가 소유한 자막 세션: 마이크 고정(전역 설정은 건드리지 않음), 오버레이 없음
@ -226,11 +303,9 @@ class MeetingModeService extends EventEmitter {
})
} catch (err) {
// 시작 실패 시 복원
captionService.off('segment', this._segmentHandler)
this._segmentHandler = null
session.detach()
if (this._current === session) this._current = null
this._meetingModeActive = false
this._sessionId = null
this._sessionStartedAt = null
db.update(meetingSessions).set({
status: 'error',
@ -243,20 +318,13 @@ class MeetingModeService extends EventEmitter {
throw err
}
// 오디오 레벨 모니터링 시작
const { getAudioCaptureService, calculateRMS } = await import('./AudioCaptureService')
const audioCaptureService = getAudioCaptureService()
this._audioBuffersForFile = []
this._audioDataHandler = (payload: { buffer: Buffer; timestamp: number }) => {
this._lastRms = calculateRMS(payload.buffer)
// Phase 15.5-2: 오디오 버퍼 축적 (WAV 저장용)
this._audioBuffersForFile.push(Buffer.from(payload.buffer))
}
audioCaptureService.on('audio-data', this._audioDataHandler)
// 오디오 레벨 모니터링 + WAV 저장용 버퍼 (Phase 15.5-2)
session.attachAudio()
this._audioLevelTimer = setInterval(() => {
this._sendToRenderer('meetingMode:audioLevel', { level: this._lastRms })
this._sendToRenderer('meetingMode:audioLevel', { level: session.lastRms })
}, 100)
// 전사를 주기적으로 DB 에 남긴다 — 앱이 비정상 종료돼도 회의 전체가 사라지지 않게.
this._checkpointTimer = setInterval(() => this._checkpointTranscript(), TRANSCRIPT_CHECKPOINT_MS)
logger.info(`회의 녹음 시작: sessionId=${sessionId}`)
this._sendStateToRenderer()
@ -272,20 +340,15 @@ class MeetingModeService extends EventEmitter {
// ── 메모 추가 ──
async addMemo(content: string): Promise<MeetingMemo> {
if (this._state !== 'recording' || !this._sessionId || !this._sessionStartedAt) {
const session = this._current
if (this._state !== 'recording' || !session) {
throw new D3ROError(ErrorCode.MeetingNotRecording, '녹음 중이 아닙니다')
}
const memo: MeetingMemo = {
id: crypto.randomUUID(),
sessionId: this._sessionId,
content,
timestampMs: Date.now() - this._sessionStartedAt,
createdAt: Date.now(),
const memo = session.addMemo(crypto.randomUUID(), content)
if (!memo) {
throw new D3ROError(ErrorCode.MeetingNotRecording, '녹음 중이 아닙니다')
}
this._memos.push(memo)
// DB 저장
const db = getDatabase()
db.insert(meetingMemos).values({
@ -307,69 +370,113 @@ class MeetingModeService extends EventEmitter {
// ── 녹음 종료 ──
/**
* 녹음을 멈추고 전사를 저장한다. 정지가 진행 중이면 그 정지를 함께 기다린다 — 정지를 두 번 눌러도
* (또는 로그아웃이 동시에 멈춰도) 정지·저장·완료 알림은 한 번만 일어난다.
*/
async stopRecording(): Promise<void> {
if (this._state !== 'recording') {
if (this._stopInFlight) return this._stopInFlight
const session = this._current
if (this._state !== 'recording' || !session) {
throw new D3ROError(ErrorCode.MeetingNotRecording, '녹음 중이 아닙니다')
}
const sessionId = this._sessionId!
const now = Date.now()
// 오디오 레벨 모니터링 정리
if (this._audioLevelTimer) {
clearInterval(this._audioLevelTimer)
this._audioLevelTimer = null
}
if (this._audioDataHandler) {
const { getAudioCaptureService } = await import('./AudioCaptureService')
getAudioCaptureService().off('audio-data', this._audioDataHandler)
this._audioDataHandler = null
const run = this._stopSession(session)
this._stopInFlight = run
try {
await run
} finally {
if (this._stopInFlight === run) this._stopInFlight = null
}
}
// CaptionService 종료 — 먼저 멈추고(말하던 마지막 문장이 flush 되어 'segment' 로 온다)
// 그다음 구독을 푼다. 예전엔 구독을 먼저 풀어 정지 직전 문장이 회의 전사에서 빠졌다.
const { getCaptionService } = await import('./CaptionService')
const captionService = getCaptionService()
private async _stopSession(session: MeetingRecordingSession): Promise<void> {
this._stopTimers()
// 정지(마지막 문장 flush)가 끝날 때까지 '처리 중'으로 보인다 — 정지 버튼이 사라져 다시 누를 수 없다.
this._setState('processing')
this._sendStateToRenderer()
const captionSummary = await captionService.stop('meeting')
const snapshot = await session.stop()
if (this._segmentHandler) {
captionService.off('segment', this._segmentHandler)
this._segmentHandler = null
}
// 혹시 구독 밖에서 확정된 세그먼트가 있으면 요약에서 보충한다
if (captionSummary) {
const known = new Set(this._segments.map((seg) => seg.id))
for (const segment of captionSummary.segments) {
if (!known.has(segment.id)) this._segments.push(segment)
}
this._segments.sort((a, b) => a.timestamp - b.timestamp)
}
// 세션 종료 시간 기록
// 세션 종료 시간 기록 — 불변 스냅샷에서 읽는다(인스턴스 필드는 다른 호출이 바꿀 수 있다)
const db = getDatabase()
db.update(meetingSessions).set({
endedAt: now,
durationMs: this._sessionStartedAt ? now - this._sessionStartedAt : 0,
updatedAt: now,
}).where(eq(meetingSessions.id, sessionId)).run()
getCloudSyncService().pushOne('meetings', sessionId)
endedAt: snapshot.endedAt,
durationMs: snapshot.durationMs,
updatedAt: Date.now(),
}).where(eq(meetingSessions.id, snapshot.id)).run()
getCloudSyncService().pushOne('meetings', snapshot.id)
logger.info(`회의 녹음 종료: sessionId=${sessionId}, segments=${this._segments.length}`)
logger.info(`회의 녹음 종료: sessionId=${snapshot.id}, segments=${snapshot.segments.length}`)
// 후처리 시작 (비동기)
this._runPostProcessing().catch((err: unknown) => {
logger.error(`후처리 실패: ${err instanceof Error ? err.message : String(err)}`)
})
await this._runPostProcessing(snapshot)
}
/**
* 앱 종료(ShutdownRegistry)용. 녹음 중이면 지금까지의 전사·녹음을 곧바로 저장하고(자막 flush 를
* 기다리지 않는다 — 종료 예산 안에 끝나야 한다), 자막·마이크를 멈춘다. 알림·렌더러 전송은 하지 않는다.
*/
async shutdown(): Promise<void> {
this._stopTimers()
const session = this._current
if (!session) return
if (!session.isStopping) {
try {
this._persistSnapshot(session.checkpoint({ includeAudio: true }), { interrupted: false })
logger.info(`종료 중 회의 저장: sessionId=${session.id}`)
} catch (err) {
logger.error(`종료 중 회의 저장 실패: ${err instanceof Error ? err.message : String(err)}`)
}
}
session.detach()
try {
const { getCaptionService } = await import('./CaptionService')
await getCaptionService().stop().catch(() => null)
} catch { /* noop */ }
this._resetSession()
this._state = 'idle'
}
/**
* 이 DB 에 'recording'/'processing' 으로 남은 회의(앱 강제 종료·정전 등)를 닫는다.
* 저장된 전사가 있으면 'completed', 없으면 'error'. 진행 중인 녹음은 건드리지 않는다.
* @returns 정리한 회의 수
*/
recoverInterruptedSessions(): number {
let db: ReturnType<typeof getDatabase>
try {
db = getDatabase()
} catch {
return 0
}
const liveId = this._current?.id ?? null
const rows = db.select().from(meetingSessions).where(inArray(meetingSessions.status, ['recording', 'processing'])).all()
let recovered = 0
for (const row of rows) {
if (row.id === liveId) continue
const now = Date.now()
const endedAt = row.endedAt ?? row.updatedAt ?? now
const hasTranscript = !!row.rawTranscript && row.rawTranscript.trim().length > 0
db.update(meetingSessions).set({
status: hasTranscript ? 'completed' : 'error',
endedAt,
durationMs: row.durationMs ?? Math.max(0, endedAt - row.startedAt),
errorMessage: hasTranscript ? row.errorMessage : (row.errorMessage ?? INTERRUPTED_MESSAGE),
updatedAt: now,
}).where(eq(meetingSessions.id, row.id)).run()
getCloudSyncService().pushOne('meetings', row.id)
recovered++
}
if (recovered > 0) logger.warn(`중단된 회의 ${recovered}건을 정리했다`)
return recovered
}
// ── 후처리 파이프라인 ──
private async _runPostProcessing(): Promise<void> {
/** 불변 스냅샷만 읽는다 — 서비스 필드(다른 호출이 초기화할 수 있다)에 기대지 않는다. */
private async _runPostProcessing(snapshot: RecordingSnapshot): Promise<void> {
this._setState('processing')
this._sendStateToRenderer()
const sessionId = this._sessionId!
const sessionId = snapshot.id
const db = getDatabase()
try {
@ -381,41 +488,22 @@ class MeetingModeService extends EventEmitter {
// Step 1: 전사 텍스트 합산
this._sendProgress(sessionId, 'merging', 40)
// 세그먼트 시각은 epoch 이다 — 회의 시작 기준 상대 시각으로 바꿔 [MM:SS] 로 쓴다
const startedAt = this._sessionStartedAt ?? this._segments[0]?.timestamp ?? 0
const rawTranscript = buildTranscriptFromSegments(this._segments, startedAt)
// Step 2: DB 저장 (rawTranscript + completed)
// Step 2: DB 저장 (rawTranscript + completed) + Step 2.5: 오디오 WAV 파일 저장 (화자 구분용)
this._sendProgress(sessionId, 'saving', 80)
const now = Date.now()
db.update(meetingSessions).set({
status: 'completed',
rawTranscript,
sttModel: configGet('sttModelId') as string | undefined,
updatedAt: now,
}).where(eq(meetingSessions.id, sessionId)).run()
getCloudSyncService().pushOne('meetings', sessionId)
// Step 2.5: 오디오 WAV 파일 저장 (화자 구분용)
if (this._audioBuffersForFile.length > 0) {
try {
const wavPath = await meetingAudioFilePath(sessionId)
fs.mkdirSync(pathDirname(wavPath), { recursive: true })
this._saveWav(wavPath, Buffer.concat(this._audioBuffersForFile))
getCloudSyncService().pushOne('meeting_audio', sessionId)
logger.info(`회의 오디오 저장: ${wavPath}`)
} catch (err) {
logger.warn(`오디오 저장 실패: ${err instanceof Error ? err.message : String(err)}`)
}
}
this._audioBuffersForFile = []
this._persistSnapshot(snapshot, { interrupted: false })
// Step 3: 알림
this._sendProgress(sessionId, 'notifying', 95)
new Notification({
title: '녹음 완료',
body: '전사가 완료되었습니다. 문서 생성 탭에서 회의록을 만들어보세요.',
}).show()
// 알림 실패는 저장된 회의를 실패로 만들지 않는다
try {
new Notification({
title: '녹음 완료',
body: '전사가 완료되었습니다. 문서 생성 탭에서 회의록을 만들어보세요.',
}).show()
} catch (err) {
logger.warn(`완료 알림 실패: ${err instanceof Error ? err.message : String(err)}`)
}
// 완료 이벤트
this._sendProgress(sessionId, 'notifying', 100)
@ -425,21 +513,21 @@ class MeetingModeService extends EventEmitter {
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.SESSION_COMPLETED, detail)
}
this._resetSession()
this._setState('idle')
this._sendStateToRenderer()
this._finishSession(snapshot.id)
logger.info(`회의 전사 저장 완료: sessionId=${sessionId}`)
} catch (err) {
db.update(meetingSessions).set({
status: 'error',
errorMessage: err instanceof Error ? err.message : String(err),
updatedAt: Date.now(),
}).where(eq(meetingSessions.id, sessionId)).run()
getCloudSyncService().pushOne('meetings', sessionId)
try {
db.update(meetingSessions).set({
status: 'error',
errorMessage: err instanceof Error ? err.message : String(err),
updatedAt: Date.now(),
}).where(eq(meetingSessions.id, sessionId)).run()
getCloudSyncService().pushOne('meetings', sessionId)
} catch (dbErr) {
logger.error(`후처리 오류 기록 실패: ${dbErr instanceof Error ? dbErr.message : String(dbErr)}`)
}
this._resetSession()
this._setState('idle')
this._sendStateToRenderer()
this._finishSession(snapshot.id)
const d3roErr = new D3ROError(
ErrorCode.MeetingProcessingFailed,
@ -454,6 +542,76 @@ class MeetingModeService extends EventEmitter {
}
}
/**
* 스냅샷(전사·종료 시각·녹음)을 DB·파일에 쓴다. 동기 — 앱 종료 예산 안에서도 끝난다.
* interrupted 면 전사가 없을 때 'error' 로 닫는다.
*/
private _persistSnapshot(snapshot: RecordingSnapshot, options: { interrupted: boolean }): void {
const db = getDatabase()
const rawTranscript = buildTranscriptFromSegments([...snapshot.segments], snapshot.startedAt)
const hasTranscript = rawTranscript.trim().length > 0
const status = options.interrupted && !hasTranscript ? 'error' : 'completed'
db.update(meetingSessions).set({
status,
rawTranscript,
endedAt: snapshot.endedAt,
durationMs: snapshot.durationMs,
sttModel: configGet('sttModelId') as string | undefined,
...(status === 'error' ? { errorMessage: INTERRUPTED_MESSAGE } : {}),
updatedAt: Date.now(),
}).where(eq(meetingSessions.id, snapshot.id)).run()
getCloudSyncService().pushOne('meetings', snapshot.id)
if (snapshot.pcm.length > 0) {
try {
const wavPath = meetingAudioFilePathSync(snapshot.id)
fs.mkdirSync(pathDirname(wavPath), { recursive: true })
this._saveWav(wavPath, snapshot.pcm)
getCloudSyncService().pushOne('meeting_audio', snapshot.id)
logger.info(`회의 오디오 저장: ${wavPath}`)
} catch (err) {
logger.warn(`오디오 저장 실패: ${err instanceof Error ? err.message : String(err)}`)
}
}
}
/** 녹음 중 주기 저장 — 새 세그먼트가 있을 때만 rawTranscript 를 갱신한다(푸시는 정지 때). */
private _checkpointTranscript(): void {
const session = this._current
if (!session || session.isStopping || this._state !== 'recording') return
if (session.segments.length === this._checkpointedSegments) return
try {
const snapshot = session.checkpoint({ includeAudio: false })
const rawTranscript = buildTranscriptFromSegments([...snapshot.segments], snapshot.startedAt)
getDatabase().update(meetingSessions).set({
rawTranscript,
updatedAt: Date.now(),
}).where(eq(meetingSessions.id, snapshot.id)).run()
this._checkpointedSegments = snapshot.segments.length
} catch (err) {
logger.warn(`전사 중간 저장 실패: ${err instanceof Error ? err.message : String(err)}`)
}
}
private _stopTimers(): void {
if (this._audioLevelTimer) {
clearInterval(this._audioLevelTimer)
this._audioLevelTimer = null
}
if (this._checkpointTimer) {
clearInterval(this._checkpointTimer)
this._checkpointTimer = null
}
}
/** 이 세션의 후처리가 끝났다 — 그사이 새 녹음이 시작됐으면 그것은 건드리지 않는다. */
private _finishSession(sessionId: string): void {
if (this._current && this._current.id !== sessionId) return
this._resetSession()
this._setState('idle')
this._sendStateToRenderer()
}
// ── 세션 조회 ──
getSessions(page: number, pageSize: number): MeetingSessionPage {
@ -518,6 +676,7 @@ class MeetingModeService extends EventEmitter {
db.delete(meetingSessions).where(eq(meetingSessions.id, sessionId)).run()
// 서버는 회의 삭제가 메모·문서로 cascade 된다 — 회의 하나만 지우면 된다.
getCloudSyncService().pushDelete('meetings', sessionId)
this.cancelMeetingChat(sessionId)
this._chatHistories.delete(sessionId)
// 로컬 녹음(WAV)도 지운다 — 행이 사라지면 어떤 경로도 이 파일을 다시 찾지 않는다(best-effort)
void this._deleteMeetingAudio(sessionId)
@ -604,12 +763,11 @@ class MeetingModeService extends EventEmitter {
}
private _resetSession(): void {
this._sessionId = null
this._sessionStartedAt = null
this._segments = []
this._memos = []
this._stopTimers()
this._current?.detach()
this._current = null
this._checkpointedSegments = 0
this._meetingModeActive = false
this._audioBuffersForFile = []
}
/** PCM16 버퍼를 WAV 파일로 저장 (16kHz mono 16-bit) */
@ -657,27 +815,17 @@ class MeetingModeService extends EventEmitter {
}
/**
* 회의 문서/폴리시/채팅/화자추정 LLM.
* llmBackend==='local' 이면 LocalLLM(Ollama). online 이면 Premium, 불가 시 Local 폴백.
* 회의 문서/폴리시/화자추정 LLM — LlmGateway(백엔드 선택 정책의 정본)에 위임한다.
* llmBackend==='local' 이면 로컬, online 이면 Premium(불가·실패 시 로컬 폴백).
*/
private async _resolveMeetingLlm(): Promise<MeetingLlm> {
const backend = configGet('llmBackend')
if (backend === 'online') {
try {
const { getPremiumLLMService } = await import('./PremiumLLMService')
const premium = getPremiumLLMService()
if (premium.isAvailable()) {
return premium
}
logger.warn('Premium LLM unavailable for meeting — falling back to local')
} catch (err) {
logger.warn(
`Premium LLM init failed for meeting: ${err instanceof Error ? err.message : String(err)}`,
)
}
const gateway = getLlmGateway()
return {
generate: (text, options) =>
gateway.generate(text, options, {
onFallback: (reason) => logger.warn(`Meeting LLM fallback: ${reason}`),
}),
}
const { getLocalLLMService } = await import('./LocalLLMService')
return getLocalLLMService()
}
// ── Phase 14.5: 전사 수정 ──
@ -746,8 +894,17 @@ class MeetingModeService extends EventEmitter {
const memoSection = formattedMemos
? `\n\n## 참석자 메모 (📝 표시)\n${formattedMemos}`
: ''
// 긴 회의는 한 번에 보내면 프록시 한도(8,000자)를 넘어 거부된다 — 구간별로 줄인 뒤 보낸다.
const budget =
LLM_PROXY_CHAT_LIMITS.maxMessageChars - DOCUMENT_REQUEST_PREFIX.length - CONDENSED_NOTE.length - memoSection.length
const fitted = await condenseTranscriptToBudget(llmService, transcript, budget)
if (fitted.condensed) {
logger.info(`문서 생성: 전사를 ${fitted.rounds}회 구간 정리해 한도 안에 맞췄다 (sessionId=${params.sessionId})`)
}
sendProgress(60)
const transcriptSection = fitted.condensed ? `${CONDENSED_NOTE}${fitted.text}` : fitted.text
const result = await llmService.generate(
`다음 회의 전사록과 참석자 메모를 분석하여 문서를 작성해주세요:\n\n## 전사록\n${transcript}${memoSection}`,
`${DOCUMENT_REQUEST_PREFIX}${transcriptSection}${memoSection}`,
{
systemPrompt,
temperature: 0.3,
@ -1092,13 +1249,33 @@ class MeetingModeService extends EventEmitter {
if (!row) throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션 없음: ${sessionId}`)
const transcript = row.editedTranscript ?? row.rawTranscript ?? ''
const systemPrompt = `당신은 회의 내용을 분석하는 AI 어시스턴트입니다.
// system 은 한도(8,000자)에서 앞부분만 남기고 잘린다 — 예전엔 긴 회의의 뒷부분이 조용히 빠져
// 그 부분 질문에 "확인되지 않습니다"라고 답했다. 한도를 넘으면 질문과 관련된 구간을 골라 넣고,
// 일부만 봤다는 사실을 모델이 답에 밝히게 한다.
const excerpt = selectTranscriptExcerpts(
transcript,
userMessage,
LLM_PROXY_CHAT_LIMITS.maxSystemChars - CHAT_SYSTEM_OVERHEAD_CHARS,
)
const systemPrompt = excerpt.complete
? `당신은 회의 내용을 분석하는 AI 어시스턴트입니다.
아래 회의 전사 내용을 참고하여 사용자의 질문에 정확하게 답변하세요.
전사 내용에 없는 것은 "전사 내용에서 확인되지 않습니다"라고 답하세요.
## 회의 전사
${transcript}`
${excerpt.text}`
: `당신은 회의 내용을 분석하는 AI 어시스턴트입니다.
회의가 길어 전체 ${excerpt.totalChunks}개 구간 중 질문과 관련된 ${excerpt.includedChunks}개 구간의 발췌만 아래에 있습니다.
발췌를 참고하여 사용자의 질문에 정확하게 답변하세요.
발췌에 없는 것은 "제공된 전사 발췌에서는 확인되지 않습니다(회의가 길어 일부 구간만 참고했습니다)"라고 답하세요.
## 회의 전사 (발췌)
${excerpt.text}`
if (!excerpt.complete) {
logger.info(
`회의 채팅: 전사 ${excerpt.totalChunks}개 구간 중 ${excerpt.includedChunks}개만 발췌해 보냈다 (sessionId=${sessionId})`,
)
}
// 이 회의의 히스토리만 쓴다. 사용자 턴은 답변이 끝났을 때 함께 기록한다
// (실패·취소 시 짝 없는 사용자 턴이 남지 않게).
@ -1109,16 +1286,19 @@ ${transcript}`
{ role: 'user' as const, content: userMessage },
]
// 다른 채팅이 흐르고 있으면 끊는다 — 컨트롤러는 하나뿐이다
this._chatAbortController?.abort()
// 같은 회의에서 흐르던 채팅만 끊는다 — 다른 회의의 채팅은 건드리지 않는다
this._chatAbortControllers.get(sessionId)?.abort()
const controller = new AbortController()
this._chatAbortController = controller
this._chatAbortControllers.set(sessionId, controller)
const signal = controller.signal
let fullResponse = ''
try {
const llm = await this._resolveMeetingLlm()
const generator = llm.chatStream(messages, { temperature: 0.5 })
const { generator } = await getLlmGateway().openChatStream(
messages,
{ signal, local: { temperature: 0.5 } },
{ onFallback: (reason) => logger.warn(`Meeting chat fallback: ${reason}`) },
)
for await (const token of generator) {
if (signal.aborted) break
@ -1148,15 +1328,19 @@ ${transcript}`
})
}
} finally {
if (this._chatAbortController === controller) this._chatAbortController = null
if (this._chatAbortControllers.get(sessionId) === controller) this._chatAbortControllers.delete(sessionId)
}
}
cancelMeetingChat(): void {
if (this._chatAbortController) {
this._chatAbortController.abort()
this._chatAbortController = null
/** 회의 채팅을 멈춘다. sessionId 를 주면 그 회의만, 생략하면 전부. */
cancelMeetingChat(sessionId?: string): void {
if (sessionId) {
this._chatAbortControllers.get(sessionId)?.abort()
this._chatAbortControllers.delete(sessionId)
return
}
for (const controller of this._chatAbortControllers.values()) controller.abort()
this._chatAbortControllers.clear()
}
/** 회의 채팅 히스토리를 비운다. sessionId 를 주면 그 회의만, 생략하면 전부. */
@ -1168,8 +1352,8 @@ ${transcript}`
}
}
/** 테스트/진단용: 특정 회의의 채팅 히스토리 사본 */
getMeetingChatHistory(sessionId: string): Array<{ role: 'user' | 'assistant'; content: string }> {
/** 특정 회의의 채팅 히스토리 사본 — 채팅 패널을 다시 열 때 main 이 기억하는 대화를 보여 준다 */
getMeetingChatHistory(sessionId: string): MeetingChatHistoryTurn[] {
return [...(this._chatHistories.get(sessionId) ?? [])]
}
@ -1314,6 +1498,8 @@ export function getMeetingModeService(): MeetingModeService {
}
export function resetMeetingModeServiceForTests(): void {
if (instance) instance.removeAllListeners()
if (instance) instance.disposeForTests()
instance = null
}
export type { MeetingModeService }