// src/main/services/MeetingModeService.ts // Phase 14 / 14.5: Meeting Mode — 실시간 녹음 + 타임스탬프 메모 + 문서 생성/내보내기 // 싱글톤 + EventEmitter 패턴. CaptionService 연동. import { EventEmitter } from 'events' import { BrowserWindow, Notification, app, dialog } from 'electron' import fs from 'fs' 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 { isRecoverableMeeting, syncStateRecordingLedger, type LocalRecordingLedger, } from './meeting/local-recording-ledger' import { createTranscriptStore, transcriptBase, type MeetingTranscriptStore, type TranscriptRevision, } from './meeting/transcript-revision-store' import { buildDiarizationChunkInput, diarizationContinuityHint, extractSpeakerLabels, lastLines, stripEchoedContext, } from './meeting/diarization-context' 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' import { buildExportMarkdown, renderMeetingPdfHtml, formatTime, formatDateFile, formatDateRange, } from '@d3ro/core/utils/meeting-markdown' import { applySpeakerLabels, buildTranscriptFromSegments, chunkTranscriptByLines, formatTranscriptLines, looksTruncatedRewrite, parseTranscriptLines, } from '@d3ro/core/meeting-transcript' import { markdownToDocx } from '@d3ro/core/utils/markdown-to-docx' import type { MeetingModeState, MeetingMemo, MeetingSessionSummary, MeetingSessionDetail, MeetingMinutes, MeetingSessionPage, MeetingStartResult, MeetingModeStateInfo, MeetingProcessingStep, MeetingProcessingProgress, MeetingDocument, MeetingGenerateDocParams, MeetingExportFormat, MeetingDocGeneratingProgress, } from '@d3ro/core/types' const logger = getLogger('MeetingModeService') /** 회의 전사를 LLM 으로 다시 쓸 때 한 번에 보낼 최대 글자 수 (출력 토큰 한도 안에 들도록) */ const REWRITE_CHUNK_CHARS = 1500 /** 조각 하나의 출력 토큰 상한 — 로컬(Ollama)·Premium 모두 4096 이하만 허용한다 */ const REWRITE_CHUNK_MAX_TOKENS = 2048 /** 화자 추정에서 다음 조각에 넘기는 앞 조각의 라벨된 마지막 줄 수 */ const DIARIZATION_CONTEXT_LINES = 4 /** 회의 채팅 히스토리를 세션마다 이 개수(메시지)까지만 유지한다 */ 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' /** 녹음 동안 인식이 계속 실패해 전사가 하나도 없다 */ const TRANSCRIPTION_FAILED_MESSAGE = 'Transcription failed during recording' /** 자막 인식 실패를 렌더러에 다시 알리는 최소 간격 */ const CAPTION_FAILURE_NOTICE_INTERVAL_MS = 30_000 /** * 회의 기능이 쓰는 LLM 포트 — 백엔드 선택(local/online, 폴백)은 LlmGateway 한 곳이 정한다. * 문서 생성·요약 입력은 이 한도(프록시 메시지 한도) 안으로 맞춘다. */ type MeetingLlm = { generate: ( text: string, options?: { systemPrompt?: string; temperature?: number; maxTokens?: number }, ) => Promise<{ text: string; model?: 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 { return meetingAudioFilePathSync(sessionId) } let isShowingMeetingSaveDialog = false class MeetingModeService extends EventEmitter { private _state: MeetingModeState = 'idle' /** * 진행 중인 녹음. 녹음 한 건의 세그먼트·메모·오디오·구독은 이 객체가 단독으로 소유한다. * 후처리가 끝날 때까지 남아 있어 getStateInfo 가 세션 id 를 계속 보고한다(실시간 편집 반영용). */ private _current: MeetingRecordingSession | null = null /** 진행 중인 정지 — 동시에 온 정지 요청(두 번 클릭, 로그아웃)은 이 promise 를 함께 기다린다 */ private _stopInFlight: Promise | null = null private _audioLevelTimer: ReturnType | null = null private _checkpointTimer: ReturnType | null = null private _checkpointedSegments = 0 /** CaptionService session-saved 방지 플래그 */ private _meetingModeActive = false // Phase 15: Meeting AI Chat — 세션마다 따로 보관한다(회의 A 의 질의응답이 B 로 새지 않게) private _chatHistories = new Map>() /** 회의마다 진행 중인 채팅 — 한 회의의 취소가 다른 회의 채팅을 끊지 않게 */ private _chatAbortControllers = new Map() private readonly _unsubscribeScope: () => void /** 회의별 자막 인식 실패 수 — 전사가 비었을 때 'completed' 대신 'error' 로 닫는 근거 */ private readonly _captionFailures = new Map() /** 정지 후처리가 최종 저장을 마친 회의 — 종료(shutdown) 때 다시 쓰지 않는다. */ private _finalizedSessionId: string | null = null private _unsubscribeCaptionFailure: (() => void) | null = null private _lastCaptionFailureNoticeAt = 0 constructor( private readonly _recordingLedger: LocalRecordingLedger = syncStateRecordingLedger, /** 전사 수정본 쓰기의 단일 관문 — 기준본 확인(compare-and-set)과 동기화 예약을 맡는다 */ private readonly _transcripts: MeetingTranscriptStore = createSqliteMeetingTranscriptStore(), ) { 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() } // ── 공개 접근자 ── getState(): MeetingModeState { return this._state } getStateInfo(): MeetingModeStateInfo { const session = this._current return { state: this._state, 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 })), } } isMeetingModeActive(): boolean { return this._meetingModeActive } /** 활성 세션, 자막, 오디오 캡처 상태를 강제로 완전 초기화 */ async forceReset(): Promise { logger.warn('MeetingModeService: forceReset 실행') 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') // 강제 정지(소유자 무시) await getCaptionService().stop().catch(() => null) } catch { /* noop */ } try { const { getAudioCaptureService } = await import('./AudioCaptureService') await getAudioCaptureService().stop().catch(() => {}) } catch { /* noop */ } this._stopInFlight = null this._resetSession() this._setState('idle') this._sendStateToRenderer() } // ── 녹음 시작 ── async startRecording(options?: { force?: boolean }): Promise { if (options?.force) { await this.forceReset() } if (this._state !== 'idle') { throw new D3ROError( ErrorCode.MeetingAlreadyRecording, `회의 모드가 이미 실행 중입니다 (${this._state}). 이전 회의를 종료하거나 강제 초기화 후 다시 시도해주세요.`, ) } // CaptionService 상태 확인 const { getCaptionService } = await import('./CaptionService') const captionService = getCaptionService() const captionState = captionService.getState() if (captionState !== 'inactive') { if (options?.force) { await captionService.stop().catch(() => {}) } else { throw new D3ROError( ErrorCode.MeetingAlreadyRecording, '실시간 자막 모드가 아직 실행 중입니다. 자막을 먼저 종료하거나 강제 초기화 후 시작해주세요.', ) } } this._setState('recording') this._meetingModeActive = true const sessionId = crypto.randomUUID() const now = Date.now() // DB에 세션 생성 const db = getDatabase() db.insert(meetingSessions).values({ id: sessionId, status: 'recording', startedAt: now, createdAt: now, updatedAt: now, }).run() // 이 기기에서 시작한 녹음 — 앱이 끊기면 다음 시작 때 이것만 복구한다(다른 기기 회의는 건드리지 않음). this._markLocalRecording(sessionId) 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 { // 회의 모드가 소유한 자막 세션: 마이크 고정(전역 설정은 건드리지 않음), 오버레이 없음 // (회의 UI 가 자체 패널에 표시), 'caption' 히스토리 중복 저장 없음, 핫키로 끌 수 없음. await captionService.start({ owner: 'meeting', audioSource: 'mic', showOverlay: false, persistHistory: false, }) } catch (err) { // 시작 실패 시 복원 session.detach() if (this._current === session) this._current = null this._meetingModeActive = false this._clearLocalRecording(sessionId) 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) this._setState('idle') throw err } // 인식이 계속 실패하면(사이드카 다운·모델 로드 실패) 회의가 조용히 빈 전사로 끝나지 않게 알린다. this._watchCaptionFailures(captionService, sessionId) // 오디오 레벨 모니터링 + WAV 저장용 버퍼 (Phase 15.5-2) session.attachAudio() this._audioLevelTimer = setInterval(() => { this._sendToRenderer('meetingMode:audioLevel', { level: session.lastRms }) }, 100) // 전사를 주기적으로 DB 에 남긴다 — 앱이 비정상 종료돼도 회의 전체가 사라지지 않게. this._checkpointTimer = setInterval(() => this._checkpointTranscript(), TRANSCRIPT_CHECKPOINT_MS) logger.info(`회의 녹음 시작: sessionId=${sessionId}`) this._sendStateToRenderer() // Phase 3.3: 부모 meeting row를 즉시 push (빈 상태로). // 자식 meeting_memos/meeting_documents의 RLS/FK가 부모 존재를 요구하므로, // 녹음 중에 들어오는 addMemo/generateDocument 푸시가 통과하려면 필수. getCloudSyncService().pushOne('meetings', sessionId) return { sessionId } } // ── 메모 추가 ── async addMemo(content: string): Promise { const session = this._current if (this._state !== 'recording' || !session) { throw new D3ROError(ErrorCode.MeetingNotRecording, '녹음 중이 아닙니다') } const memo = session.addMemo(crypto.randomUUID(), content) if (!memo) { throw new D3ROError(ErrorCode.MeetingNotRecording, '녹음 중이 아닙니다') } // DB 저장 const db = getDatabase() db.insert(meetingMemos).values({ id: memo.id, sessionId: memo.sessionId, content: memo.content, timestampMs: memo.timestampMs, createdAt: memo.createdAt, }).run() this.emit('memo-added', memo) logger.debug(`메모 추가: [${formatTime(memo.timestampMs)}] ${content}`) // Phase 3.3: 자동 push (fire-and-forget) getCloudSyncService().pushOne('meeting_memos', memo.id) return memo } // ── 녹음 종료 ── /** * 녹음을 멈추고 전사를 저장한다. 정지가 진행 중이면 그 정지를 함께 기다린다 — 정지를 두 번 눌러도 * (또는 로그아웃이 동시에 멈춰도) 정지·저장·완료 알림은 한 번만 일어난다. */ async stopRecording(): Promise { if (this._stopInFlight) return this._stopInFlight const session = this._current if (this._state !== 'recording' || !session) { throw new D3ROError(ErrorCode.MeetingNotRecording, '녹음 중이 아닙니다') } const run = this._stopSession(session) this._stopInFlight = run try { await run } finally { if (this._stopInFlight === run) this._stopInFlight = null } } private async _stopSession(session: MeetingRecordingSession): Promise { this._stopTimers() // 정지(마지막 문장 flush)가 끝날 때까지 '처리 중'으로 보인다 — 정지 버튼이 사라져 다시 누를 수 없다. this._setState('processing') this._sendStateToRenderer() const snapshot = await session.stop() // 세션 종료 시간 기록 — 불변 스냅샷에서 읽는다(인스턴스 필드는 다른 호출이 바꿀 수 있다) const db = getDatabase() db.update(meetingSessions).set({ endedAt: snapshot.endedAt, durationMs: snapshot.durationMs, updatedAt: Date.now(), }).where(eq(meetingSessions.id, snapshot.id)).run() getCloudSyncService().pushOne('meetings', snapshot.id) logger.info(`회의 녹음 종료: sessionId=${snapshot.id}, segments=${snapshot.segments.length}`) await this._runPostProcessing(snapshot) } /** * 앱 종료(ShutdownRegistry)용. 녹음 중이면 지금까지의 전사·녹음을 곧바로 저장하고(자막 flush 를 * 기다리지 않는다 — 종료 예산 안에 끝나야 한다), 자막·마이크를 멈춘다. 알림·렌더러 전송은 하지 않는다. */ async shutdown(): Promise { this._stopTimers() const session = this._current if (!session) return // 정지 중(마지막 문장 flush 대기)이어도 아직 최종 저장 전이면 지금까지를 저장한다 — 건너뛰면 // 메모리에만 있던 녹음과 마지막 주기 저장 이후 전사가 사라졌다. if (this._finalizedSessionId !== session.id) { 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 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 if (!isRecoverableMeeting(row, this._recordingLedger)) 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) this._clearLocalRecording(row.id) recovered++ } if (recovered > 0) logger.warn(`중단된 회의 ${recovered}건을 정리했다`) return recovered } // ── 후처리 파이프라인 ── /** 불변 스냅샷만 읽는다 — 서비스 필드(다른 호출이 초기화할 수 있다)에 기대지 않는다. */ private async _runPostProcessing(snapshot: RecordingSnapshot): Promise { this._setState('processing') this._sendStateToRenderer() const sessionId = snapshot.id const db = getDatabase() try { db.update(meetingSessions).set({ status: 'processing', updatedAt: Date.now(), }).where(eq(meetingSessions.id, sessionId)).run() getCloudSyncService().pushOne('meetings', sessionId) // Step 1: 전사 텍스트 합산 this._sendProgress(sessionId, 'merging', 40) // Step 2: DB 저장 (rawTranscript + completed) + Step 2.5: 오디오 WAV 파일 저장 (화자 구분용) this._sendProgress(sessionId, 'saving', 80) this._persistSnapshot(snapshot, { interrupted: false }) this._finalizedSessionId = sessionId // Step 3: 알림 this._sendProgress(sessionId, 'notifying', 95) // 알림 실패는 저장된 회의를 실패로 만들지 않는다 try { new Notification({ title: '녹음 완료', body: '전사가 완료되었습니다. 문서 생성 탭에서 회의록을 만들어보세요.', }).show() } catch (err) { logger.warn(`완료 알림 실패: ${err instanceof Error ? err.message : String(err)}`) } // 완료 이벤트 this._sendProgress(sessionId, 'notifying', 100) const detail = this._loadSessionDetail(sessionId) if (detail) { this.emit('session-completed', detail) this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.SESSION_COMPLETED, detail) } this._finishSession(snapshot.id) logger.info(`회의 전사 저장 완료: sessionId=${sessionId}`) } catch (err) { 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._finishSession(snapshot.id) const d3roErr = new D3ROError( ErrorCode.MeetingProcessingFailed, `후처리 실패: ${err instanceof Error ? err.message : String(err)}`, ) this.emit('error', d3roErr) this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.ERROR, { code: d3roErr.code, message: d3roErr.message, }) logger.error(`후처리 실패: ${d3roErr.message}`) } } /** * 스냅샷(전사·종료 시각·녹음)을 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 transcriptionFailed = !hasTranscript && (this._captionFailures.get(snapshot.id) ?? 0) > 0 const status = !hasTranscript && (options.interrupted || transcriptionFailed) ? 'error' : 'completed' const errorMessage = options.interrupted ? INTERRUPTED_MESSAGE : TRANSCRIPTION_FAILED_MESSAGE db.update(meetingSessions).set({ status, rawTranscript, endedAt: snapshot.endedAt, durationMs: snapshot.durationMs, sttModel: configGet('sttModelId') as string | undefined, ...(status === 'error' ? { errorMessage } : {}), updatedAt: Date.now(), }).where(eq(meetingSessions.id, snapshot.id)).run() getCloudSyncService().pushOne('meetings', snapshot.id) this._captionFailures.delete(snapshot.id) this._clearLocalRecording(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 _watchCaptionFailures( captionService: { on(event: 'failure', listener: (error: D3ROError) => void): unknown; off(event: 'failure', listener: (error: D3ROError) => void): unknown }, sessionId: string, ): void { this._unsubscribeCaptionFailure?.() this._captionFailures.set(sessionId, 0) this._lastCaptionFailureNoticeAt = 0 const listener = (error: D3ROError): void => { if (this._current?.id !== sessionId) return this._captionFailures.set(sessionId, (this._captionFailures.get(sessionId) ?? 0) + 1) const now = Date.now() if (now - this._lastCaptionFailureNoticeAt < CAPTION_FAILURE_NOTICE_INTERVAL_MS) return this._lastCaptionFailureNoticeAt = now this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.ERROR, { code: error.code ?? ErrorCode.MeetingProcessingFailed, message: error.message, }) } captionService.on('failure', listener) this._unsubscribeCaptionFailure = () => { captionService.off('failure', listener) } } private _markLocalRecording(sessionId: string): void { try { this._recordingLedger.mark(sessionId) } catch (err) { logger.warn(`로컬 녹음 표식 기록 실패: ${err instanceof Error ? err.message : String(err)}`) } } private _clearLocalRecording(sessionId: string): void { try { this._recordingLedger.clear(sessionId) } catch (err) { logger.warn(`로컬 녹음 표식 정리 실패: ${err instanceof Error ? err.message : String(err)}`) } } private _stopTimers(): void { this._unsubscribeCaptionFailure?.() this._unsubscribeCaptionFailure = null 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 { const db = getDatabase() const offset = (page - 1) * pageSize const countResult = db.select({ count: sql`count(*)` }) .from(meetingSessions) .get() const total = countResult?.count ?? 0 const rows = db.select() .from(meetingSessions) .orderBy(desc(meetingSessions.createdAt)) .limit(pageSize) .offset(offset) .all() const sessions: MeetingSessionSummary[] = rows.map((row) => { const memoCount = db.select({ count: sql`count(*)` }) .from(meetingMemos) .where(eq(meetingMemos.sessionId, row.id)) .get()?.count ?? 0 return { id: row.id, title: row.title, status: row.status as MeetingSessionSummary['status'], startedAt: row.startedAt, endedAt: row.endedAt, durationMs: row.durationMs, memoCount, } }) return { sessions, total, page, pageSize, totalPages: Math.ceil(total / pageSize), } } getSession(sessionId: string): MeetingSessionDetail { const detail = this._loadSessionDetail(sessionId) if (!detail) { throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`) } return detail } deleteSession(sessionId: string): void { const db = getDatabase() const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, sessionId)).get() if (!row) { throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`) } db.delete(meetingMemos).where(eq(meetingMemos.sessionId, sessionId)).run() db.delete(meetingDocuments).where(eq(meetingDocuments.sessionId, sessionId)).run() 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) logger.info(`회의 세션 삭제: ${sessionId}`) } private async _deleteMeetingAudio(sessionId: string): Promise { try { const audioPath = await meetingAudioFilePath(sessionId) await fs.promises.rm(audioPath, { force: true }) } catch (err) { logger.warn(`회의 오디오 삭제 실패: ${err instanceof Error ? err.message : String(err)}`) } } updateTitle(sessionId: string, title: string): void { const db = getDatabase() const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, sessionId)).get() if (!row) { throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`) } db.update(meetingSessions).set({ title, updatedAt: Date.now() }) .where(eq(meetingSessions.id, sessionId)).run() getCloudSyncService().pushOne('meetings', sessionId) } // ── 내보내기 ── async exportPdf(sessionId: string): Promise { const session = this._loadSessionDetail(sessionId) if (!session) { throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`) } const html = this._buildPdfHtml(session) const { filePath } = await dialog.showSaveDialog({ title: 'PDF로 내보내기', defaultPath: `회의록_${formatDateFile(session.startedAt)}.pdf`, filters: [{ name: 'PDF', extensions: ['pdf'] }], }) if (!filePath) return '' const win = new BrowserWindow({ show: false, width: 800, height: 600 }) try { await win.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(html)}`) const pdfBuffer = await win.webContents.printToPDF({ printBackground: true, pageSize: 'A4', margins: { top: 20, bottom: 20, left: 20, right: 20 }, }) fs.writeFileSync(filePath, pdfBuffer) logger.info(`PDF 내보내기 완료: ${filePath}`) return filePath } finally { win.close() } } async exportMarkdown(sessionId: string): Promise { const session = this._loadSessionDetail(sessionId) if (!session) { throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`) } const { filePath } = await dialog.showSaveDialog({ title: '마크다운으로 내보내기', defaultPath: `회의록_${formatDateFile(session.startedAt)}.md`, filters: [{ name: 'Markdown', extensions: ['md'] }], }) if (!filePath) return '' const md = buildExportMarkdown(session) fs.writeFileSync(filePath, md, 'utf-8') logger.info(`마크다운 내보내기 완료: ${filePath}`) return filePath } // ── 내부 헬퍼 ── private _setState(state: MeetingModeState): void { this._state = state this.emit('state-changed', state) } private _resetSession(): void { this._stopTimers() this._current?.detach() this._current = null this._checkpointedSegments = 0 this._meetingModeActive = false } /** PCM16 버퍼를 WAV 파일로 저장 (16kHz mono 16-bit) */ private _saveWav(filePath: string, pcmBuffer: Buffer): void { const sampleRate = 16000 const numChannels = 1 const bitsPerSample = 16 const byteRate = sampleRate * numChannels * (bitsPerSample / 8) const blockAlign = numChannels * (bitsPerSample / 8) const dataSize = pcmBuffer.length const header = Buffer.alloc(44) header.write('RIFF', 0) header.writeUInt32LE(36 + dataSize, 4) header.write('WAVE', 8) header.write('fmt ', 12) header.writeUInt32LE(16, 16) // fmt chunk size header.writeUInt16LE(1, 20) // PCM header.writeUInt16LE(numChannels, 22) header.writeUInt32LE(sampleRate, 24) header.writeUInt32LE(byteRate, 28) header.writeUInt16LE(blockAlign, 32) header.writeUInt16LE(bitsPerSample, 34) header.write('data', 36) header.writeUInt32LE(dataSize, 40) // 헤더와 PCM 을 이어 붙이지 않고 따로 쓴다 — 3시간 회의면 concat 사본만 350MB 가 더 생긴다 const fd = fs.openSync(filePath, 'w') try { fs.writeSync(fd, header) fs.writeSync(fd, pcmBuffer) } finally { fs.closeSync(fd) } } private _sendToRenderer(channel: string, data: unknown): void { const win = getMainWindow() if (win && !win.isDestroyed()) { win.webContents.send(channel, data) } } private _sendStateToRenderer(): void { this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.STATE_CHANGED, this.getStateInfo()) } private _sendProgress(sessionId: string, step: MeetingProcessingStep, percent: number): void { const progress: MeetingProcessingProgress = { sessionId, step, percent } this.emit('processing-progress', progress) this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.PROCESSING_PROGRESS, progress) } /** * 회의 문서/폴리시/화자추정 LLM — LlmGateway(백엔드 선택 정책의 정본)에 위임한다. * llmBackend==='local' 이면 로컬, online 이면 Premium(불가·실패 시 로컬 폴백). */ private async _resolveMeetingLlm(): Promise { const gateway = getLlmGateway() return { generate: (text, options) => gateway.generate(text, options, { onFallback: (reason) => logger.warn(`Meeting LLM fallback: ${reason}`), }), } } // ── Phase 14.5: 전사 수정 ── updateTranscript(sessionId: string, editedTranscript: string): void { // 사용자의 수동 저장(실시간 세그먼트 반영 포함)은 기준본 확인 없이 쓴다 — 렌더러 계약은 그대로다. if (this._transcripts.writeEdited(sessionId, editedTranscript) === 'not-found') { throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`) } logger.info(`전사 수정 저장: sessionId=${sessionId}`) } /** * LLM 결과(다듬기·화자 구분)를 읽었던 기준본 위에서만 쓴다. 그 사이 사용자가 전사를 고쳤으면 * 덮어쓰지 않고 실패시킨다 — 예전엔 마지막 쓰기가 이겨 수동 편집이 조용히 사라졌다. */ private _writeRewrite(sessionId: string, text: string, base: TranscriptRevision, failureCode: ErrorCode): void { const result = this._transcripts.writeEdited(sessionId, text, base.revision) if (result === 'not-found') { throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션 없음: ${sessionId}`) } if (result === 'conflict') { throw new D3ROError(failureCode, '작업하는 동안 전사가 수정되어 결과를 저장하지 않았습니다. 다시 시도해 주세요.') } } // ── Phase 14.5: 문서 생성 ── async generateDocument(params: MeetingGenerateDocParams): Promise { const db = getDatabase() const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, params.sessionId)).get() if (!row) { throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${params.sessionId}`) } const { getMeetingDocTemplateService } = await import('./MeetingDocTemplateService') const templateService = getMeetingDocTemplateService() const template = templateService.getById(params.templateId) if (!template) { throw new D3ROError(ErrorCode.MeetingDocTemplateNotFound, `템플릿을 찾을 수 없습니다: ${params.templateId}`) } const transcript = row.editedTranscript ?? row.rawTranscript ?? '' // 메모도 함께 참조 const memoRows = db.select().from(meetingMemos) .where(eq(meetingMemos.sessionId, params.sessionId)) .orderBy(meetingMemos.timestampMs) .all() const formattedMemos = memoRows.length > 0 ? memoRows.map((m) => `[${formatTime(m.timestampMs)}] 📝 ${m.content}`).join('\n') : '' const systemPrompt = params.customPrompt ?? template.systemPrompt const docTitle = params.customTitle ?? `${template.name} — ${row.title ?? '무제 회의'}` // 진행률 전송 const sendProgress = (percent: number): void => { const progress: MeetingDocGeneratingProgress = { sessionId: params.sessionId, templateId: params.templateId, percent, } this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DOC_GENERATING_PROGRESS, progress) } sendProgress(10) const llmService = await this._resolveMeetingLlm() sendProgress(30) const llmStart = Date.now() 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( `${DOCUMENT_REQUEST_PREFIX}${transcriptSection}${memoSection}`, { systemPrompt, temperature: 0.3, maxTokens: 4096, }, ) const llmLatencyMs = Date.now() - llmStart sendProgress(85) const now = Date.now() const docId = crypto.randomUUID() db.insert(meetingDocuments).values({ id: docId, sessionId: params.sessionId, templateType: template.templateType, title: docTitle, content: result.text, promptUsed: systemPrompt, llmModel: result.model, llmLatencyMs, createdAt: now, updatedAt: now, }).run() sendProgress(100) logger.info(`문서 생성 완료: docId=${docId}, sessionId=${params.sessionId}`) // Phase 3.3: 자동 push (fire-and-forget) getCloudSyncService().pushOne('meeting_documents', docId) return { id: docId, sessionId: params.sessionId, templateType: template.templateType, title: docTitle, content: result.text, promptUsed: systemPrompt, llmModel: result.model ?? null, llmLatencyMs, createdAt: now, updatedAt: now, } } // ── Phase 14.5: 문서 조회/수정/삭제 ── getDocuments(sessionId: string): MeetingDocument[] { const db = getDatabase() const rows = db.select().from(meetingDocuments) .where(eq(meetingDocuments.sessionId, sessionId)) .all() return rows.map((r) => ({ id: r.id, sessionId: r.sessionId, templateType: r.templateType, title: r.title, content: r.content, promptUsed: r.promptUsed, llmModel: r.llmModel, llmLatencyMs: r.llmLatencyMs, createdAt: r.createdAt, updatedAt: r.updatedAt, })) } updateDocument(documentId: string, content: string): void { const db = getDatabase() const row = db.select().from(meetingDocuments).where(eq(meetingDocuments.id, documentId)).get() if (!row) { throw new D3ROError(ErrorCode.MeetingDocumentNotFound, `문서를 찾을 수 없습니다: ${documentId}`) } db.update(meetingDocuments).set({ content, updatedAt: Date.now() }) .where(eq(meetingDocuments.id, documentId)).run() getCloudSyncService().pushOne('meeting_documents', documentId) logger.info(`문서 수정: docId=${documentId}`) } deleteDocument(documentId: string): void { const db = getDatabase() const row = db.select().from(meetingDocuments).where(eq(meetingDocuments.id, documentId)).get() if (!row) { throw new D3ROError(ErrorCode.MeetingDocumentNotFound, `문서를 찾을 수 없습니다: ${documentId}`) } db.delete(meetingDocuments).where(eq(meetingDocuments.id, documentId)).run() getCloudSyncService().pushDelete('meeting_documents', documentId) logger.info(`문서 삭제: docId=${documentId}`) } // ── Phase 14.5: 문서 내보내기 ── async exportDocument(documentId: string, format: MeetingExportFormat, targetPath?: string): Promise { const db = getDatabase() const row = db.select().from(meetingDocuments).where(eq(meetingDocuments.id, documentId)).get() if (!row) { throw new D3ROError(ErrorCode.MeetingDocumentNotFound, `문서를 찾을 수 없습니다: ${documentId}`) } const safeTitle = row.title.replace(/[/\\?%*:|"<>]/g, '-').slice(0, 50) const dateStr = formatDateFile(row.createdAt) let filters: Electron.FileFilter[] let defaultName: string switch (format) { case 'md': filters = [{ name: 'Markdown', extensions: ['md'] }] defaultName = `${safeTitle}_${dateStr}.md` break case 'txt': filters = [{ name: 'Text', extensions: ['txt'] }] defaultName = `${safeTitle}_${dateStr}.txt` break case 'docx': filters = [{ name: 'Word Document', extensions: ['docx'] }] defaultName = `${safeTitle}_${dateStr}.docx` break case 'pdf': filters = [{ name: 'PDF', extensions: ['pdf'] }] defaultName = `${safeTitle}_${dateStr}.pdf` break } let filePath: string | undefined = targetPath if (!filePath) { if (isShowingMeetingSaveDialog) { return '' } isShowingMeetingSaveDialog = true try { const { getMainWindow } = await import('../windows/WindowManager') const mainWindow = getMainWindow() const dialogOptions = { title: '문서 내보내기', defaultPath: defaultName, filters, } const res = mainWindow ? await dialog.showSaveDialog(mainWindow, dialogOptions) : await dialog.showSaveDialog(dialogOptions) filePath = res.filePath } finally { isShowingMeetingSaveDialog = false } } if (!filePath) return '' switch (format) { case 'md': case 'txt': fs.writeFileSync(filePath, row.content, 'utf-8') break case 'docx': { const buf = await markdownToDocx(row.content, row.title) fs.writeFileSync(filePath, buf) break } case 'pdf': { const html = renderMeetingPdfHtml({ title: row.title, markdown: row.content }) const win = new BrowserWindow({ show: false, width: 800, height: 600 }) try { await win.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(html)}`) const pdfBuffer = await win.webContents.printToPDF({ printBackground: true, pageSize: 'A4', margins: { top: 20, bottom: 20, left: 20, right: 20 }, }) fs.writeFileSync(filePath, pdfBuffer) } finally { win.close() } break } } logger.info(`문서 내보내기 완료: format=${format}, path=${filePath}`) return filePath } async exportTranscript(sessionId: string, targetPath?: string): Promise { const db = getDatabase() const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, sessionId)).get() if (!row) { throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`) } const transcript = row.editedTranscript ?? row.rawTranscript ?? '' const dateStr = formatDateFile(row.startedAt) const safeTitle = (row.title ?? '무제_회의').replace(/[/\\?%*:|"<>]/g, '-').slice(0, 50) let filePath: string | undefined = targetPath if (!filePath) { const res = await dialog.showSaveDialog({ title: '전사 내보내기', defaultPath: `전사_${safeTitle}_${dateStr}.txt`, filters: [{ name: 'Text', extensions: ['txt'] }], }) filePath = res.filePath } if (!filePath) return '' fs.writeFileSync(filePath, transcript, 'utf-8') logger.info(`전사 내보내기 완료: path=${filePath}`) return filePath } // ── 내부 헬퍼 ── private _loadSessionDetail(sessionId: string): MeetingSessionDetail | null { const db = getDatabase() const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, sessionId)).get() if (!row) return null const memoRows = db.select().from(meetingMemos) .where(eq(meetingMemos.sessionId, sessionId)) .orderBy(meetingMemos.timestampMs) .all() const memos: MeetingMemo[] = memoRows.map((m) => ({ id: m.id, sessionId: m.sessionId, content: m.content, timestampMs: m.timestampMs, createdAt: m.createdAt, })) const docRows = db.select().from(meetingDocuments) .where(eq(meetingDocuments.sessionId, sessionId)) .all() const documents: MeetingDocument[] = docRows.map((d) => ({ id: d.id, sessionId: d.sessionId, templateType: d.templateType, title: d.title, content: d.content, promptUsed: d.promptUsed, llmModel: d.llmModel, llmLatencyMs: d.llmLatencyMs, createdAt: d.createdAt, updatedAt: d.updatedAt, })) let minutes: MeetingMinutes | null = null if (row.minutesJson) { try { minutes = JSON.parse(row.minutesJson) as MeetingMinutes } catch { logger.warn(`회의록 JSON 파싱 실패: sessionId=${sessionId}`) } } return { id: row.id, title: row.title, status: row.status as MeetingSessionDetail['status'], startedAt: row.startedAt, endedAt: row.endedAt, durationMs: row.durationMs, memoCount: memos.length, rawTranscript: row.rawTranscript, editedTranscript: row.editedTranscript, minutesMarkdown: row.minutesMarkdown, minutes, memos, documents, sttModel: row.sttModel, llmModel: row.llmModel, errorMessage: row.errorMessage, } } // ── Phase 15: Auto Polish ── async polishTranscript(sessionId: string): Promise { const base = this._transcripts.read(sessionId) if (!base) throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션 없음: ${sessionId}`) // 기준본은 수정본(사용자 편집·화자 라벨) 우선 — 원문으로 다듬으면 편집과 라벨이 통째로 사라졌다. const transcript = transcriptBase(base) if (!transcript) throw new D3ROError(ErrorCode.MeetingPolishFailed, '전사 텍스트가 없습니다') const llm = await this._resolveMeetingLlm() const polished = await this._rewriteTranscriptInChunks( llm, transcript, '다음 음성 전사 텍스트를 다듬어주세요. 필러 단어(음, 어, 그, 아 등)를 제거하고, 문장 구조를 자연스럽게 교정하되, 원래 의미와 내용은 절대 변경하지 마세요. 타임스탬프 형식 [MM:SS]과 화자 표기([화자 N] 등)는 그대로 유지하세요.', ErrorCode.MeetingPolishFailed, ) this._writeRewrite(sessionId, polished, base, ErrorCode.MeetingPolishFailed) logger.info(`Auto Polish 완료: sessionId=${sessionId}`) return polished } /** * 긴 전사를 줄 경계 조각으로 나눠 LLM 으로 다시 쓰고 이어 붙인다. * 한 번에 통째로 보내면 출력 토큰 한도(2048/4096)에서 잘린 결과가 editedTranscript 를 * 덮어써 회의 뒷부분이 문서·채팅·동기화에서 조용히 사라졌다. 조각 하나라도 잘린 것으로 * 보이면 저장하지 않고 실패시킨다. */ private async _rewriteTranscriptInChunks( llm: MeetingLlm, transcript: string, systemPrompt: string, failureCode: ErrorCode, options: { carrySpeakerContext?: boolean } = {}, ): Promise { const chunks = chunkTranscriptByLines(transcript, REWRITE_CHUNK_CHARS) if (chunks.length === 0) { throw new D3ROError(failureCode, '전사 텍스트가 없습니다') } const outputs: string[] = [] let previousTail: string[] = [] for (let i = 0; i < chunks.length; i++) { const chunk = chunks[i] // 화자 추정은 조각 사이에 화자 번호를 이어 준다 — 앞 조각의 라벨된 끝부분과 지금까지의 화자 목록. const carry = options.carrySpeakerContext === true const input = carry ? buildDiarizationChunkInput(chunk, previousTail) : chunk const prompt = carry ? systemPrompt + diarizationContinuityHint(extractSpeakerLabels(outputs.join('\n'))) : systemPrompt const result = await llm.generate(input, { systemPrompt: prompt, temperature: 0.3, maxTokens: REWRITE_CHUNK_MAX_TOKENS, }) const text = carry ? stripEchoedContext(result.text, previousTail) : result.text.trim() if (looksTruncatedRewrite(chunk, text)) { throw new D3ROError( failureCode, `LLM 결과가 잘린 것으로 보여 저장하지 않았습니다 (조각 ${i + 1}/${chunks.length})`, ) } outputs.push(text.trim()) if (carry) previousTail = lastLines(text, DIARIZATION_CONTEXT_LINES) } return outputs.join('\n') } // ── Phase 15: Meeting AI Chat ── async chatWithMeeting(sessionId: string, userMessage: string): Promise { const db = getDatabase() const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, sessionId)).get() if (!row) throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션 없음: ${sessionId}`) const transcript = row.editedTranscript ?? row.rawTranscript ?? '' // system 은 한도(8,000자)에서 앞부분만 남기고 잘린다 — 예전엔 긴 회의의 뒷부분이 조용히 빠져 // 그 부분 질문에 "확인되지 않습니다"라고 답했다. 한도를 넘으면 질문과 관련된 구간을 골라 넣고, // 일부만 봤다는 사실을 모델이 답에 밝히게 한다. const excerpt = selectTranscriptExcerpts( transcript, userMessage, LLM_PROXY_CHAT_LIMITS.maxSystemChars - CHAT_SYSTEM_OVERHEAD_CHARS, ) const systemPrompt = excerpt.complete ? `당신은 회의 내용을 분석하는 AI 어시스턴트입니다. 아래 회의 전사 내용을 참고하여 사용자의 질문에 정확하게 답변하세요. 전사 내용에 없는 것은 "전사 내용에서 확인되지 않습니다"라고 답하세요. ## 회의 전사 ${excerpt.text}` : `당신은 회의 내용을 분석하는 AI 어시스턴트입니다. 회의가 길어 전체 ${excerpt.totalChunks}개 구간 중 질문과 관련된 ${excerpt.includedChunks}개 구간의 발췌만 아래에 있습니다. 발췌를 참고하여 사용자의 질문에 정확하게 답변하세요. 발췌에 없는 것은 "제공된 전사 발췌에서는 확인되지 않습니다(회의가 길어 일부 구간만 참고했습니다)"라고 답하세요. ## 회의 전사 (발췌) ${excerpt.text}` if (!excerpt.complete) { logger.info( `회의 채팅: 전사 ${excerpt.totalChunks}개 구간 중 ${excerpt.includedChunks}개만 발췌해 보냈다 (sessionId=${sessionId})`, ) } // 이 회의의 히스토리만 쓴다. 사용자 턴은 답변이 끝났을 때 함께 기록한다 // (실패·취소 시 짝 없는 사용자 턴이 남지 않게). const history = this._chatHistories.get(sessionId) ?? [] const messages = [ { role: 'system' as const, content: systemPrompt }, ...history, { role: 'user' as const, content: userMessage }, ] // 같은 회의에서 흐르던 채팅만 끊는다 — 다른 회의의 채팅은 건드리지 않는다 this._chatAbortControllers.get(sessionId)?.abort() const controller = new AbortController() this._chatAbortControllers.set(sessionId, controller) const signal = controller.signal let fullResponse = '' try { 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 fullResponse += token this._sendToRenderer(IPC_CHANNELS.MEETING_CHAT.DELTA, { sessionId, token }) } // 취소(대화 지우기·패널 떠남·같은 회의의 새 질문)된 답변은 보내지 않는다 — 비운 대화에 잘린 답변이 // 다시 나타났고, 기록에 없는 턴이라 화면과 모델의 대화가 어긋났다. if (signal.aborted) return const updated = [ ...history, { role: 'user' as const, content: userMessage }, { role: 'assistant' as const, content: fullResponse }, ] this._chatHistories.set(sessionId, updated.slice(-MAX_CHAT_HISTORY_MESSAGES)) this._sendToRenderer(IPC_CHANNELS.MEETING_CHAT.MESSAGE, { sessionId, role: 'assistant', content: fullResponse, timestamp: Date.now(), }) } catch (err) { if (!signal.aborted && (err as Error).name !== 'AbortError') { this._sendToRenderer(IPC_CHANNELS.MEETING_CHAT.ERROR, { sessionId, message: err instanceof Error ? err.message : String(err), }) } } finally { if (this._chatAbortControllers.get(sessionId) === controller) this._chatAbortControllers.delete(sessionId) } } /** 회의 채팅을 멈춘다. 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 를 주면 그 회의만, 생략하면 전부. */ clearMeetingChatHistory(sessionId?: string): void { if (sessionId) { this._chatHistories.delete(sessionId) } else { this._chatHistories.clear() } } /** 특정 회의의 채팅 히스토리 사본 — 채팅 패널을 다시 열 때 main 이 기억하는 대화를 보여 준다 */ getMeetingChatHistory(sessionId: string): MeetingChatHistoryTurn[] { return [...(this._chatHistories.get(sessionId) ?? [])] } // ── Phase 15.5: 화자 구분 ── async diarizeSession(sessionId: string, numSpeakers?: number): Promise { const row = this._transcripts.read(sessionId) if (!row) throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션 없음: ${sessionId}`) if (!row.raw) throw new D3ROError(ErrorCode.DiarizationFailed, '전사 텍스트가 없습니다') this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 10 }) // 오디오 파일 존재 확인 const audioPath = await meetingAudioFilePath(sessionId) const hasAudioFile = fs.existsSync(audioPath) const hfToken = configGet('hfToken') as string if (hasAudioFile && hfToken) { // Phase 15.5-2: pyannote 실제 화자 구분 logger.info(`pyannote 화자 구분 시작: ${audioPath}`) this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 20 }) try { const audioBuffer = fs.readFileSync(audioPath) const serverUrl = `http://127.0.0.1:18765` const formData = new FormData() formData.append('audio', new Blob([audioBuffer]), 'audio.wav') formData.append('hf_token', hfToken) if (numSpeakers && numSpeakers > 0) { formData.append('num_speakers', String(numSpeakers)) } this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 40 }) const response = await fetch(`${serverUrl}/diarize`, { method: 'POST', body: formData, }) if (!response.ok) { const errData = await response.json() as { message?: string } throw new Error(errData.message ?? `Diarization failed: ${response.status}`) } const diarResult = await response.json() as { segments: Array<{ speaker: string; start: number; end: number }> num_speakers: number } this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 70 }) // 전사 줄과 화자 구간 매칭 — 줄 형식 규칙은 core meeting-transcript 한 곳에서만 해석한다. // 화자는 덧붙이지 않고 교체하므로 다시 돌려도 라벨이 쌓이지 않는다. const transcript = transcriptBase(row) ?? '' const labeledLines = applySpeakerLabels( parseTranscriptLines(transcript), diarResult.segments, (raw) => raw.replace('SPEAKER_', '화자 '), ) this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 85 }) this._writeRewrite(sessionId, formatTranscriptLines(labeledLines), row, ErrorCode.DiarizationFailed) logger.info(`pyannote 화자 구분 완료: ${diarResult.num_speakers}명, sessionId=${sessionId}`) } catch (err) { logger.warn(`pyannote 실패, LLM 폴백: ${err instanceof Error ? err.message : String(err)}`) // pyannote 실패 시 LLM 폴백 await this._diarizeLLMFallback(sessionId, row, numSpeakers) } } else { // LLM 기반 화자 추정 (오디오 없거나 HF 토큰 없음) await this._diarizeLLMFallback(sessionId, row, numSpeakers) } this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 100 }) logger.info(`화자 구분 완료: sessionId=${sessionId}`) } private async _diarizeLLMFallback( sessionId: string, row: TranscriptRevision, numSpeakers?: number, ): Promise { this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 30 }) const llm = await this._resolveMeetingLlm() const transcript = transcriptBase(row) ?? '' const speakerHint = numSpeakers && numSpeakers > 0 ? `회의에는 총 ${numSpeakers}명의 화자가 있습니다.` : '화자 수는 문맥에서 추정하세요.' const labeled = await this._rewriteTranscriptInChunks( llm, transcript, `다음 회의 전사록을 분석하여 각 발언의 화자를 추정해주세요. ${speakerHint} 각 줄을 [시간] [화자] 내용 형식으로 변환하세요. 화자는 "화자 1", "화자 2" 등으로 표시하세요. 발언 내용, 어조, 문맥을 기반으로 화자를 추정하세요. 원문의 타임스탬프와 내용은 변경하지 마세요.`, ErrorCode.DiarizationFailed, { carrySpeakerContext: true }, ) this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 80 }) this._writeRewrite(sessionId, labeled, row, ErrorCode.DiarizationFailed) } private _buildPdfHtml(session: MeetingSessionDetail): string { const durationMin = session.durationMs ? Math.round(session.durationMs / 60000) : 0 return renderMeetingPdfHtml({ title: session.title ?? '무제 회의', meta: `일시: ${formatDateRange(session.startedAt, session.endedAt)} | 소요: ${durationMin}분`, markdown: session.minutesMarkdown, emptyMessage: '회의록이 생성되지 않았습니다.', }) } } // ── 싱글톤 ── /** 기본 전사 저장소 — meeting_sessions 행을 읽고 쓰며, 쓴 뒤 동기화를 예약한다. */ function createSqliteMeetingTranscriptStore(): MeetingTranscriptStore { return createTranscriptStore({ readRow: (sessionId) => getDatabase() .select({ rawTranscript: meetingSessions.rawTranscript, editedTranscript: meetingSessions.editedTranscript }) .from(meetingSessions) .where(eq(meetingSessions.id, sessionId)) .get(), writeEdited: (sessionId, editedTranscript, now) => { getDatabase() .update(meetingSessions) .set({ editedTranscript, updatedAt: now }) .where(eq(meetingSessions.id, sessionId)) .run() }, onWritten: (sessionId) => getCloudSyncService().pushOne('meetings', sessionId), }) } let instance: MeetingModeService | null = null export function getMeetingModeService(): MeetingModeService { if (!instance) { instance = new MeetingModeService() } return instance } export function resetMeetingModeServiceForTests(): void { if (instance) instance.disposeForTests() instance = null } export type { MeetingModeService }