fix: red-team round 3 hardening across desktop, mobile, core and server

Batch of red-team r3 fixes that were in the working tree before the
2026-09-28 design overhaul, committed as one unit with their tests.

- desktop main: STT timeouts and sidecar, voice recording store, sync
  (credentials, audio, knowledge reindex, push gates), runtime
  provisioner, update policy, AltGr keybindings, voice-command policy,
  dictionary file codec/limits, meeting transcript condensing and a
  local recording ledger so interrupted-session recovery only closes
  meetings this device recorded (a phone's live meeting is left alone).
- mobile: login CSRF via implicit token callbacks rejected, account
  deletion/retention, durable queue retention, knowledge realtime
  without unfiltered DELETE, meeting re-record failure paths, cloud STT
  client, preferences store/resync.
- core: text chunking splits long unbroken transcripts to fit, template
  field policy, dictionary limits, meeting markdown inline handling.
- server: payple webhook policy and cancellation order scope, meeting
  document generation quota, team RPC null-role guard, unified LLM
  quota in-flight accounting, knowledge chunk vector index, meeting
  re-record failure paths (migrations 20260929*).
- ci: portable/runtime feed gates, update-policy schema, Forgejo file
  delete and alias planning.

Four older tests are updated to the new contracts rather than the old
behavior: token-pair auth callbacks are rejected, knowledge realtime no
longer subscribes to DELETE, long transcript lines are split, and
meeting recovery requires the local recording ledger for empty rows.
This commit is contained in:
Yun Chan 2026-09-28 20:45:52 +09:00
parent 2428ede03d
commit ba9ef9741e
161 changed files with 17056 additions and 2379 deletions

View file

@ -15,6 +15,24 @@ 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'
@ -61,12 +79,18 @@ const logger = getLogger('MeetingModeService')
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 한 곳이 정한다.
@ -116,8 +140,16 @@ class MeetingModeService extends EventEmitter {
/** 회의마다 진행 중인 채팅 — 한 회의의 취소가 다른 회의 채팅을 끊지 않게 */
private _chatAbortControllers = new Map<string, AbortController>()
private readonly _unsubscribeScope: () => void
/** 회의별 자막 인식 실패 수 — 전사가 비었을 때 'completed' 대신 'error' 로 닫는 근거 */
private readonly _captionFailures = new Map<string, number>()
private _unsubscribeCaptionFailure: (() => void) | null = null
private _lastCaptionFailureNoticeAt = 0
constructor() {
constructor(
private readonly _recordingLedger: LocalRecordingLedger = syncStateRecordingLedger,
/** 전사 수정본 쓰기의 단일 관문 — 기준본 확인(compare-and-set)과 동기화 예약을 맡는다 */
private readonly _transcripts: MeetingTranscriptStore = createSqliteMeetingTranscriptStore(),
) {
super()
// 이 서비스가 내는 'error' 는 알림용이다 — 듣는 쪽이 없어도 throw 되지 않게 기본 수신자를 둔다
// (EventEmitter 는 리스너 없는 'error' 를 던져 후처리 catch 를 깨뜨렸다).
@ -255,6 +287,8 @@ class MeetingModeService extends EventEmitter {
createdAt: now,
updatedAt: now,
}).run()
// 이 기기에서 시작한 녹음 — 앱이 끊기면 다음 시작 때 이것만 복구한다(다른 기기 회의는 건드리지 않음).
this._markLocalRecording(sessionId)
const { getAudioCaptureService, calculateRMS } = await import('./AudioCaptureService')
const audioCaptureService = getAudioCaptureService()
@ -306,6 +340,7 @@ class MeetingModeService extends EventEmitter {
session.detach()
if (this._current === session) this._current = null
this._meetingModeActive = false
this._clearLocalRecording(sessionId)
db.update(meetingSessions).set({
status: 'error',
@ -318,6 +353,9 @@ class MeetingModeService extends EventEmitter {
throw err
}
// 인식이 계속 실패하면(사이드카 다운·모델 로드 실패) 회의가 조용히 빈 전사로 끝나지 않게 알린다.
this._watchCaptionFailures(captionService, sessionId)
// 오디오 레벨 모니터링 + WAV 저장용 버퍼 (Phase 15.5-2)
session.attachAudio()
this._audioLevelTimer = setInterval(() => {
@ -439,6 +477,7 @@ class MeetingModeService extends EventEmitter {
/**
* 이 DB 에 'recording'/'processing' 으로 남은 회의(앱 강제 종료·정전 등)를 닫는다.
* 저장된 전사가 있으면 'completed', 없으면 'error'. 진행 중인 녹음은 건드리지 않는다.
* 이 기기에서 시작한 녹음만 닫는다 — 동기화로 들어온 폰의 진행 중인 회의는 폰이 끝낸다.
* @returns 정리한 회의 수
*/
recoverInterruptedSessions(): number {
@ -453,6 +492,7 @@ class MeetingModeService extends EventEmitter {
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
@ -464,6 +504,7 @@ class MeetingModeService extends EventEmitter {
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}건을 정리했다`)
@ -550,17 +591,22 @@ class MeetingModeService extends EventEmitter {
const db = getDatabase()
const rawTranscript = buildTranscriptFromSegments([...snapshot.segments], snapshot.startedAt)
const hasTranscript = rawTranscript.trim().length > 0
const status = options.interrupted && !hasTranscript ? 'error' : 'completed'
// 전사가 비었는데 녹음 동안 인식이 실패했다면 '완료'가 아니다 — 사용자가 끝난 뒤에야 빈 회의를 발견했다.
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: INTERRUPTED_MESSAGE } : {}),
...(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 {
@ -593,7 +639,49 @@ class MeetingModeService extends EventEmitter {
}
}
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
@ -831,19 +919,27 @@ class MeetingModeService extends EventEmitter {
// ── Phase 14.5: 전사 수정 ──
updateTranscript(sessionId: string, editedTranscript: string): void {
const db = getDatabase()
const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, sessionId)).get()
if (!row) {
// 사용자의 수동 저장(실시간 세그먼트 반영 포함)은 기준본 확인 없이 쓴다 — 렌더러 계약은 그대로다.
if (this._transcripts.writeEdited(sessionId, editedTranscript) === 'not-found') {
throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`)
}
db.update(meetingSessions).set({
editedTranscript,
updatedAt: Date.now(),
}).where(eq(meetingSessions.id, sessionId)).run()
getCloudSyncService().pushOne('meetings', 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> {
@ -1181,26 +1277,22 @@ class MeetingModeService extends EventEmitter {
// ── Phase 15: Auto Polish ──
async polishTranscript(sessionId: 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 base = this._transcripts.read(sessionId)
if (!base) throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션 없음: ${sessionId}`)
const transcript = row.rawTranscript
// 기준본은 수정본(사용자 편집·화자 라벨) 우선 — 원문으로 다듬으면 편집과 라벨이 통째로 사라졌다.
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]은 그대로 유지하세요.',
'다음 음성 전사 텍스트를 다듬어주세요. 필러 단어(음, 어, 그, 아 등)를 제거하고, 문장 구조를 자연스럽게 교정하되, 원래 의미와 내용은 절대 변경하지 마세요. 타임스탬프 형식 [MM:SS]과 화자 표기([화자 N] 등)는 그대로 유지하세요.',
ErrorCode.MeetingPolishFailed,
)
db.update(meetingSessions).set({
editedTranscript: polished,
updatedAt: Date.now(),
}).where(eq(meetingSessions.id, sessionId)).run()
getCloudSyncService().pushOne('meetings', sessionId)
this._writeRewrite(sessionId, polished, base, ErrorCode.MeetingPolishFailed)
logger.info(`Auto Polish 완료: sessionId=${sessionId}`)
return polished
@ -1217,26 +1309,34 @@ class MeetingModeService extends EventEmitter {
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 result = await llm.generate(chunk, {
systemPrompt,
// 화자 추정은 조각 사이에 화자 번호를 이어 준다 — 앞 조각의 라벨된 끝부분과 지금까지의 화자 목록.
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,
})
if (looksTruncatedRewrite(chunk, result.text)) {
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(result.text.trim())
outputs.push(text.trim())
if (carry) previousTail = lastLines(text, DIARIZATION_CONTEXT_LINES)
}
return outputs.join('\n')
}
@ -1360,10 +1460,9 @@ ${excerpt.text}`
// ── Phase 15.5: 화자 구분 ──
async diarizeSession(sessionId: string, numSpeakers?: number): Promise<void> {
const db = getDatabase()
const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, sessionId)).get()
const row = this._transcripts.read(sessionId)
if (!row) throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션 없음: ${sessionId}`)
if (!row.rawTranscript) throw new D3ROError(ErrorCode.DiarizationFailed, '전사 텍스트가 없습니다')
if (!row.raw) throw new D3ROError(ErrorCode.DiarizationFailed, '전사 텍스트가 없습니다')
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 10 })
@ -1410,7 +1509,7 @@ ${excerpt.text}`
// 전사 줄과 화자 구간 매칭 — 줄 형식 규칙은 core meeting-transcript 한 곳에서만 해석한다.
// 화자는 덧붙이지 않고 교체하므로 다시 돌려도 라벨이 쌓이지 않는다.
const transcript = row.editedTranscript ?? row.rawTranscript ?? ''
const transcript = transcriptBase(row) ?? ''
const labeledLines = applySpeakerLabels(
parseTranscriptLines(transcript),
diarResult.segments,
@ -1419,11 +1518,7 @@ ${excerpt.text}`
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 85 })
db.update(meetingSessions).set({
editedTranscript: formatTranscriptLines(labeledLines),
updatedAt: Date.now(),
}).where(eq(meetingSessions.id, sessionId)).run()
getCloudSyncService().pushOne('meetings', sessionId)
this._writeRewrite(sessionId, formatTranscriptLines(labeledLines), row, ErrorCode.DiarizationFailed)
logger.info(`pyannote 화자 구분 완료: ${diarResult.num_speakers}명, sessionId=${sessionId}`)
} catch (err) {
@ -1442,14 +1537,14 @@ ${excerpt.text}`
private async _diarizeLLMFallback(
sessionId: string,
row: { rawTranscript: string | null; editedTranscript: string | null },
row: TranscriptRevision,
numSpeakers?: number,
): Promise<void> {
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 30 })
const llm = await this._resolveMeetingLlm()
const transcript = row.editedTranscript ?? row.rawTranscript ?? ''
const transcript = transcriptBase(row) ?? ''
const speakerHint = numSpeakers && numSpeakers > 0
? `회의에는 총 ${numSpeakers}명의 화자가 있습니다.`
: '화자 수는 문맥에서 추정하세요.'
@ -1464,16 +1559,12 @@ ${speakerHint}
발언 내용, 어조, 문맥을 기반으로 화자를 추정하세요.
원문의 타임스탬프와 내용은 변경하지 마세요.`,
ErrorCode.DiarizationFailed,
{ carrySpeakerContext: true },
)
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 80 })
const db = getDatabase()
db.update(meetingSessions).set({
editedTranscript: labeled,
updatedAt: Date.now(),
}).where(eq(meetingSessions.id, sessionId)).run()
getCloudSyncService().pushOne('meetings', sessionId)
this._writeRewrite(sessionId, labeled, row, ErrorCode.DiarizationFailed)
}
private _buildPdfHtml(session: MeetingSessionDetail): string {
@ -1488,6 +1579,26 @@ ${speakerHint}
}
// ── 싱글톤 ──
/** 기본 전사 저장소 — 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 {