d3ro-voice/apps/desktop/src/main/services/MeetingModeService.ts
Yun Chan a14bb52b7f fix(meeting-chat): don't send a cancelled answer back to the panel
Clearing the chat mid-answer emptied the panel and then the truncated
answer reappeared, a turn the model's history never recorded.
2026-10-20 22:53:07 +09:00

1629 lines
63 KiB
TypeScript

// 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<string> {
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<void> | null = null
private _audioLevelTimer: ReturnType<typeof setInterval> | null = null
private _checkpointTimer: ReturnType<typeof setInterval> | null = null
private _checkpointedSegments = 0
/** CaptionService session-saved 방지 플래그 */
private _meetingModeActive = false
// Phase 15: Meeting AI Chat — 세션마다 따로 보관한다(회의 A 의 질의응답이 B 로 새지 않게)
private _chatHistories = new Map<string, Array<{ role: 'user' | 'assistant'; content: string }>>()
/** 회의마다 진행 중인 채팅 — 한 회의의 취소가 다른 회의 채팅을 끊지 않게 */
private _chatAbortControllers = new Map<string, AbortController>()
private readonly _unsubscribeScope: () => void
/** 회의별 자막 인식 실패 수 — 전사가 비었을 때 'completed' 대신 'error' 로 닫는 근거 */
private readonly _captionFailures = new Map<string, number>()
/** 정지 후처리가 최종 저장을 마친 회의 — 종료(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<void> {
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<MeetingStartResult> {
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<MeetingMemo> {
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<void> {
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<void> {
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<void> {
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<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
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<void> {
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<number>`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<number>`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<void> {
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<string> {
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<string> {
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<MeetingLlm> {
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<MeetingDocument> {
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<string> {
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<string> {
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<string> {
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<string> {
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<void> {
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<void> {
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<void> {
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 }