opensoma 0.3.0 → 0.5.0

package/src/formatters.ts

@@ -1,14 +1,15 @@
 import { type HTMLElement, parse } from 'node-html-parser'
 
+import { decodeHtmlEntities } from './shared/utils/html'
 import {
-  ApplicationHistoryItemSchema,
   type ApplicationHistoryItem,
-  ApprovalListItemSchema,
+  ApplicationHistoryItemSchema,
   type ApprovalListItem,
-  DashboardSchema,
-  EventListItemSchema,
+  ApprovalListItemSchema,
   type Dashboard,
+  DashboardSchema,
   type EventListItem,
+  EventListItemSchema,
   type MemberInfo,
   MemberInfoSchema,
   type MentoringDetail,
@@ -98,7 +99,7 @@ export function parseMentoringDetail(html: string, id = 0): MentoringDetail {
     status: extractStatus(labels.상태 || rawTitle),
     author: labels['작성자'] || '',
     createdAt: labels['등록일'] || '',
-    content: contentNode?.innerHTML.trim() ?? '',
+    content: decodeHtmlEntities(contentNode?.innerHTML.trim() ?? ''),
     venue: labels['장소'] || '',
     applicants,
   })
@@ -131,20 +132,7 @@ export function parseRoomSlots(html: string): RoomCard['timeSlots'] {
     return parseTimeSlotsFromRoot(root)
   }
 
-  return slots
-    .map((slot) => {
-      const hour = slot.getAttribute('data-hour') ?? ''
-      const minute = slot.getAttribute('data-minute') ?? ''
-      const checkbox = slot.querySelector('input[type="checkbox"]')
-      const className = slot.getAttribute('class') ?? ''
-      const time = hour && minute ? `${hour}:${minute}` : normalizeTime(cleanText(slot.querySelector('label') ?? slot))
-
-      return {
-        time,
-        available: !checkbox?.hasAttribute('disabled') && !className.includes('disabled'),
-      }
-    })
-    .filter((slot) => Boolean(slot.time))
+  return slots.map(parseRoomTimeSlot).filter((slot) => Boolean(slot.time))
 }
 
 export function parseDashboard(html: string): Dashboard {
@@ -202,7 +190,7 @@ export function parseNoticeDetail(html: string, id = 0): NoticeDetail {
     title: cleanText(top?.querySelector('.tit')) || labels['제목'] || cleanText(root.querySelector('h1, h2, .title')),
     author,
     createdAt,
-    content: contentNode?.innerHTML.trim() ?? '',
+    content: decodeHtmlEntities(contentNode?.innerHTML.trim() ?? ''),
   })
 }
 
@@ -311,12 +299,40 @@ export function parseReportList(html: string): ReportListItem[] {
 
 export function parseReportDetail(html: string, id = 0): ReportDetail {
   const root = parse(html)
-  const labels = extractLabelMap(root)
+  const labels = { ...extractLabelMap(root), ...extractGroupMap(root) }
 
   const progressTimeText = labels['진행시간'] || ''
   const exceptTimeText = labels['제외시간'] || ''
-  const progressTimes = progressTimeText.split(/\s*~\s*/)
-  const exceptTimes = exceptTimeText.split(/\s*~\s*/)
+  const progressTimeMatch = progressTimeText.match(/(\d{2}:\d{2})\s*~\s*(\d{2}:\d{2})/)
+  const exceptTimeMatch = exceptTimeText.match(/(\d{2}:\d{2})\s*~\s*(\d{2}:\d{2})/)
+
+  let subject = labels['주제'] || ''
+  if (!subject) {
+    for (const group of root.querySelectorAll('.group')) {
+      if (cleanText(group.querySelector('strong.t')) === '주제') {
+        subject = group.querySelector('input')?.getAttribute('value')?.trim() || ''
+        break
+      }
+    }
+  }
+
+  const findGroupTextarea = (...names: string[]): string => {
+    for (const group of root.querySelectorAll('.group')) {
+      const label = cleanText(group.querySelector('strong.t')).replace(/:$/, '')
+      if (names.includes(label)) {
+        const textarea = group.querySelector('textarea')
+        if (textarea) return textarea.text.trim()
+        return cleanText(group.querySelector('.c'))
+      }
+    }
+    return ''
+  }
+
+  const files = root
+    .querySelectorAll('.file_list_new a')
+    .map((a) => a.getAttribute('href') || '')
+    .filter(Boolean)
+    .map((href) => (href.startsWith('http') ? href : `https://www.swmaestro.ai${href}`))
 
   return ReportDetailSchema.parse({
     id,
@@ -324,27 +340,27 @@ export function parseReportDetail(html: string, id = 0): ReportDetail {
     title: labels['제목'] || '',
     progressDate: labels['진행 날짜'] || '',
     status: labels['상태'] || '',
-    author: labels['작성자'] || '',
+    author: labels['작성자'] || labels['진행 멘토 명'] || '',
     createdAt: labels['등록일'] || '',
     acceptedTime: labels['인정시간'] || '',
     payAmount: labels['지급액'] || '',
-    content: labels['추진 내용'] || '',
-    subject: labels['주제'] || '',
-    menteeRegion: labels['멘토링 대상'] || '',
+    content: findGroupTextarea('추진내용', '추진 내용') || labels['추진내용'] || labels['추진 내용'] || '',
+    subject,
+    menteeRegion: labels['멘토링대상'] || labels['멘토링 대상'] || '',
     reportType: labels['구분'] || '',
     teamNames: labels['팀명'] || '',
     venue: labels['진행 장소'] || '',
-    attendanceCount: extractNumber(labels['참석 연수생'] || ''),
+    attendanceCount: extractNumber(labels['참석자 인원'] || labels['참석 연수생'] || ''),
     attendanceNames: labels['참석자 이름'] || '',
-    progressStartTime: progressTimes[0] || '',
-    progressEndTime: progressTimes[1] || '',
-    exceptStartTime: exceptTimes[0] || '',
-    exceptEndTime: exceptTimes[1] || '',
-    exceptReason: labels['제외 사유'] || labels['제외이유'] || '',
-    mentorOpinion: labels['멘토 의견'] || '',
+    progressStartTime: progressTimeMatch?.[1] || '',
+    progressEndTime: progressTimeMatch?.[2] || '',
+    exceptStartTime: exceptTimeMatch?.[1] || '',
+    exceptEndTime: exceptTimeMatch?.[2] || '',
+    exceptReason: labels['제외사유'] || labels['제외 사유'] || labels['제외이유'] || '',
+    mentorOpinion: findGroupTextarea('멘토의견', '멘토 의견') || labels['멘토의견'] || labels['멘토 의견'] || '',
     nonAttendanceNames: labels['무단불참자'] || '',
-    etc: labels['특이사항'] || '',
-    files: [],
+    etc: findGroupTextarea('기타', '특이사항') || labels['기타'] || labels['특이사항'] || '',
+    files,
   })
 }
 
@@ -464,15 +480,46 @@ function parseTimeSlotsFromRoot(root: HTMLElement): RoomCard['timeSlots'] {
     ? grid.querySelectorAll('span')
     : root.querySelectorAll('.time-grid span, [class*="time-slot"], .slot')
 
-  return spans
-    .map((slot) => ({
-      time: cleanText(slot),
-      available:
-        !(slot.getAttribute('class') ?? '').includes('not-reserve') &&
-        !(slot.getAttribute('class') ?? '').includes('booked') &&
-        !(slot.getAttribute('class') ?? '').includes('disabled'),
-    }))
-    .filter((slot) => Boolean(slot.time))
+  return spans.map(parseRoomTimeSlot).filter((slot) => Boolean(slot.time))
+}
+
+function parseRoomTimeSlot(slot: HTMLElement): RoomCard['timeSlots'][number] {
+  const label = slot.querySelector('label')
+  const hour = slot.getAttribute('data-hour') ?? ''
+  const minute = slot.getAttribute('data-minute') ?? ''
+  const checkbox = slot.querySelector('input[type="checkbox"]')
+  const className = slot.getAttribute('class') ?? ''
+  const available =
+    !checkbox?.hasAttribute('disabled') &&
+    !className.includes('not-reserve') &&
+    !className.includes('booked') &&
+    !className.includes('disabled')
+  const time = hour && minute ? `${hour}:${minute}` : normalizeTime(cleanText(label ?? slot))
+  const reservation = !available ? extractReservation(label) : undefined
+
+  return {
+    time,
+    available,
+    ...(reservation ? { reservation } : {}),
+  }
+}
+
+function extractReservation(label: HTMLElement | null): { title: string; bookedBy: string } | undefined {
+  const rawTitle = label?.getAttribute('title')
+  if (!rawTitle) {
+    return undefined
+  }
+
+  const [title = '', bookedByLine = ''] = decodeHtmlEntities(rawTitle)
+    .split(/<br\s*\/?>/i)
+    .map((part) => part.trim())
+  const bookedBy = bookedByLine.replace(/^예약자\s*:\s*/, '').trim()
+
+  if (!title || !bookedBy) {
+    return undefined
+  }
+
+  return { title, bookedBy }
 }
 
 function findDashboardValue(items: HTMLElement[], label: string): string {

package/src/http.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, mock, test } from 'bun:test'
 
 import { MENU_NO } from './constants'
+import { AuthenticationError } from './errors'
 import { SomaHttp } from './http'
 
 const originalFetch = globalThis.fetch
@@ -209,6 +210,41 @@ describe('SomaHttp', () => {
     })
   })
 
+  describe('postForm', () => {
+    test('converts Record to FormData and delegates to postMultipart', async () => {
+      const fetchMock = mock(async (_input: RequestInfo | URL, init?: RequestInit) => {
+        const body = init?.body
+        expect(body).toBeInstanceOf(FormData)
+        const fd = body as FormData
+        expect(fd.get('title')).toBe('테스트')
+        expect(fd.get('qestnarCn')).toBe('<p>멘토링 내용</p>')
+        expect(fd.get('csrfToken')).toBe('csrf-1')
+        return createResponse('<html>ok</html>')
+      })
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(
+        http.postForm('/mypage/mentoLec/insert.do', { title: '테스트', qestnarCn: '<p>멘토링 내용</p>' }),
+      ).resolves.toBe('<html>ok</html>')
+    })
+
+    test('does not set Content-Type header (lets FormData set multipart boundary)', async () => {
+      const fetchMock = mock(async (_input: RequestInfo | URL, init?: RequestInit) => {
+        const headers = init?.headers as Record<string, string> | undefined
+        expect(headers?.['Content-Type']).toBeUndefined()
+        expect(headers?.['content-type']).toBeUndefined()
+        return createResponse('<html>ok</html>')
+      })
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await http.postForm('/test', { key: 'value' })
+    })
+  })
+
   test('postJson returns parsed json', async () => {
     const fetchMock = mock(async (_input: RequestInfo | URL, init?: RequestInit) => {
       expect(init?.headers).toEqual({
@@ -353,6 +389,185 @@ describe('SomaHttp', () => {
     await expect(http.extractCsrfToken()).resolves.toBe('csrf-token')
     expect(http.getCsrfToken()).toBe('csrf-token')
   })
+
+  describe('session-expired alert errors', () => {
+    function sessionExpiredAlert(message: string): string {
+      return `<html><head></head><body><script language='JavaScript'>\nalert('${message}');\nhistory.back();\n</script></body></html>`
+    }
+
+    const expiredMessage = '잘못된 접근입니다. 해당 세션을 전체 초기화 하였습니다.'
+
+    test('post throws AuthenticationError for session-expired alert', async () => {
+      const fetchMock = mock(async () => createResponse(sessionExpiredAlert(expiredMessage)))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.post('/mypage/officeMng/list.do', { menuNo: '200058' })).rejects.toThrow(AuthenticationError)
+    })
+
+    test('get throws AuthenticationError for session-expired alert', async () => {
+      const fetchMock = mock(async () => createResponse(sessionExpiredAlert(expiredMessage)))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1' })
+
+      await expect(http.get('/mypage/officeMng/list.do')).rejects.toThrow(AuthenticationError)
+    })
+
+    test('postMultipart throws AuthenticationError for session-expired alert', async () => {
+      const fetchMock = mock(async () => createResponse(sessionExpiredAlert(expiredMessage)))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.postMultipart('/mypage/test.do', new FormData())).rejects.toThrow(AuthenticationError)
+    })
+
+    test('alert with 세션 + invalidation keyword variants are treated as auth error', async () => {
+      const variants = ['세션이 만료되었습니다.', '해당 세션을 초기화하였습니다.', '세션 정보가 유효하지 않습니다.']
+
+      for (const message of variants) {
+        const fetchMock = mock(async () => createResponse(sessionExpiredAlert(message)))
+        globalThis.fetch = fetchMock as typeof fetch
+
+        const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+        await expect(http.post('/test', {})).rejects.toThrow(AuthenticationError)
+      }
+    })
+
+    test('alert containing 세션 without invalidation keyword is not treated as auth error', async () => {
+      const fetchMock = mock(async () => createResponse(sessionExpiredAlert('멘토링 세션이 이미 마감되었습니다.')))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.post('/mypage/test.do', {})).rejects.toThrow('멘토링 세션이 이미 마감되었습니다.')
+    })
+
+    test('non-session alert still throws regular Error', async () => {
+      const fetchMock = mock(async () => createResponse(sessionExpiredAlert('잘못된 접근입니다.')))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.post('/mypage/test.do', {})).rejects.toThrow('잘못된 접근입니다.')
+    })
+
+    test('get throws regular Error for non-session alert', async () => {
+      const fetchMock = mock(async () => createResponse(sessionExpiredAlert('잘못된 접근입니다.')))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1' })
+
+      await expect(http.get('/mypage/test.do')).rejects.toThrow('잘못된 접근입니다.')
+    })
+
+    test('session-expired alert with double quotes is detected', async () => {
+      const doubleQuoteAlert = `<html><body><script language='JavaScript'>\nalert("${expiredMessage}");\nhistory.back();\n</script></body></html>`
+      const fetchMock = mock(async () => createResponse(doubleQuoteAlert))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.post('/mypage/test.do', {})).rejects.toThrow(AuthenticationError)
+    })
+  })
+
+  describe('JSON error responses', () => {
+    const sessionExpiredJson = JSON.stringify({
+      error: '잘못된 접근입니다. 해당 세션을 전체 초기화 하였습니다.',
+    })
+    const genericErrorJson = JSON.stringify({ error: '처리 중 오류가 발생했습니다.' })
+
+    test('post throws AuthenticationError for session-expired JSON', async () => {
+      const fetchMock = mock(async () => createResponse(sessionExpiredJson, [], 'application/json'))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.post('/mypage/officeMng/list.do', { menuNo: '200058' })).rejects.toThrow(AuthenticationError)
+    })
+
+    test('post throws Error for non-session JSON error', async () => {
+      const fetchMock = mock(async () => createResponse(genericErrorJson, [], 'application/json'))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.post('/mypage/test.do', {})).rejects.toThrow('처리 중 오류가 발생했습니다.')
+    })
+
+    test('postJson throws AuthenticationError for session-expired JSON', async () => {
+      const fetchMock = mock(async () => createResponse(sessionExpiredJson, [], 'application/json'))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.postJson('/mypage/officeMng/rentTime.do', { itemId: '17' })).rejects.toThrow(
+        AuthenticationError,
+      )
+    })
+
+    test('postJson throws Error for non-session JSON error', async () => {
+      const fetchMock = mock(async () => createResponse(genericErrorJson, [], 'application/json'))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.postJson('/mypage/test.do', {})).rejects.toThrow('처리 중 오류가 발생했습니다.')
+    })
+
+    test('postJson still parses valid JSON when no error field', async () => {
+      const fetchMock = mock(async () =>
+        createResponse(JSON.stringify({ resultCode: 'SUCCESS' }), [], 'application/json'),
+      )
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.postJson('/mypage/test.do', {})).resolves.toEqual({ resultCode: 'SUCCESS' })
+    })
+
+    test('non-JSON body starting with { does not false-positive', async () => {
+      const fetchMock = mock(async () => createResponse('{malformed json', [], 'text/html'))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1' })
+
+      await expect(http.get('/test')).resolves.toBe('{malformed json')
+    })
+
+    test('JSON error with leading whitespace is still detected', async () => {
+      const paddedJson = `  \n  ${sessionExpiredJson}`
+      const fetchMock = mock(async () => createResponse(paddedJson, [], 'application/json'))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.post('/mypage/test.do', {})).rejects.toThrow(AuthenticationError)
+    })
+
+    test('get throws Error for non-session JSON error', async () => {
+      const fetchMock = mock(async () => createResponse(genericErrorJson, [], 'application/json'))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1' })
+
+      await expect(http.get('/mypage/test.do')).rejects.toThrow('처리 중 오류가 발생했습니다.')
+    })
+
+    test('postJson throws AuthenticationError for HTML login page response', async () => {
+      const loginPageHtml =
+        '<html><head><title>AI·SW마에스트로</title></head><body><form><input name="username"><input name="password"></form></body></html>'
+      const fetchMock = mock(async () => createResponse(loginPageHtml))
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.postJson('/mypage/officeMng/rentTime.do', {})).rejects.toThrow(AuthenticationError)
+    })
+  })
 })
 
 function createResponse(

package/src/http.ts

@@ -60,6 +60,9 @@ export class SomaHttp {
     if (errorInfo === '__AUTH_ERROR__') {
       throw new AuthenticationError()
     }
+    if (errorInfo) {
+      throw new Error(errorInfo)
+    }
 
     return body
   }
@@ -134,6 +137,14 @@ export class SomaHttp {
     return finalBody
   }
 
+  async postForm(path: string, body: Record<string, string>): Promise<string> {
+    const formData = new FormData()
+    for (const [key, value] of Object.entries(body)) {
+      formData.append(key, value)
+    }
+    return this.postMultipart(path, formData)
+  }
+
   async postMultipart(path: string, formData: FormData): Promise<string> {
     const url = this.buildUrl(path)
 
@@ -203,6 +214,23 @@ export class SomaHttp {
     return finalBody
   }
 
+  private extractJsonError(body: string): string | null {
+    if (!body.trimStart().startsWith('{')) return null
+    try {
+      const json = JSON.parse(body) as Record<string, unknown>
+      if (typeof json.error === 'string') {
+        return this.isSessionExpiredError(json.error) ? '__AUTH_ERROR__' : json.error
+      }
+    } catch {
+      // Not valid JSON
+    }
+    return null
+  }
+
+  private isSessionExpiredError(message: string): boolean {
+    return message.includes('세션') && /초기화|만료|유효하지/.test(message)
+  }
+
   private extractErrorFromResponse(body: string, location: string | null, path?: string): string | null {
     this.log(
       'extractErrorFromResponse',
@@ -213,9 +241,15 @@ export class SomaHttp {
       body.match(/<title>([^<]*)<\/title>/)?.[1],
     )
 
+    const jsonError = this.extractJsonError(body)
+    if (jsonError) return jsonError
+
     const alertMatch = body.match(/<script\b[^>]*>\s*alert\(['"](.+?)['"]\);?\s*(history\.|location\.)/i)
     if (alertMatch) {
       this.log('Found alert match:', alertMatch[1])
+      if (this.isSessionExpiredError(alertMatch[1])) {
+        return '__AUTH_ERROR__'
+      }
       return alertMatch[1]
     }
 
@@ -284,7 +318,17 @@ export class SomaHttp {
     })
 
     this.updateFromResponse(response)
-    return (await response.json()) as T
+    const text = await response.text()
+
+    const errorInfo = this.extractErrorFromResponse(text, null, path)
+    if (errorInfo === '__AUTH_ERROR__') {
+      throw new AuthenticationError()
+    }
+    if (errorInfo) {
+      throw new Error(errorInfo)
+    }
+
+    return JSON.parse(text) as T
   }
 
   async login(username: string, password: string): Promise<void> {

package/src/index.ts

@@ -3,5 +3,8 @@ export type { SomaClientOptions } from './client'
 export { AuthenticationError } from './errors'
 export { SomaHttp } from './http'
 export { CredentialManager } from './credential-manager'
+export { TozHttp } from './toz-http'
+export type { TozHttpOptions, TozHttpState } from './toz-http'
+export * from './toz-formatters'
 export * from './types'
 export * from './constants'

package/src/shared/utils/html.ts

@@ -0,0 +1,12 @@
+export function decodeHtmlEntities(html: string): string {
+  return html
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&amp;/g, '&') // must be last to avoid double-decoding
+}
+
+export function escapeHtml(text: string): string {
+  return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+}

package/src/shared/utils/swmaestro.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from 'bun:test'
+
+import { resolveVenue } from './swmaestro'
+
+describe('resolveVenue', () => {
+  test('adds 토즈- prefix to bare toz location names', () => {
+    expect(resolveVenue('광화문점')).toBe('토즈-광화문점')
+    expect(resolveVenue('양재점')).toBe('토즈-양재점')
+    expect(resolveVenue('강남컨퍼런스센터점')).toBe('토즈-강남컨퍼런스센터점')
+    expect(resolveVenue('건대점')).toBe('토즈-건대점')
+    expect(resolveVenue('강남역토즈타워점')).toBe('토즈-강남역토즈타워점')
+    expect(resolveVenue('선릉점')).toBe('토즈-선릉점')
+    expect(resolveVenue('역삼점')).toBe('토즈-역삼점')
+    expect(resolveVenue('홍대점')).toBe('토즈-홍대점')
+  })
+
+  test('passes through already-prefixed toz locations', () => {
+    expect(resolveVenue('토즈-광화문점')).toBe('토즈-광화문점')
+    expect(resolveVenue('토즈-강남역토즈타워점')).toBe('토즈-강남역토즈타워점')
+  })
+
+  test('resolves 신촌비즈니스센터점 to 연수센터-7', () => {
+    expect(resolveVenue('신촌비즈니스센터점')).toBe('연수센터-7')
+    expect(resolveVenue('토즈-신촌비즈니스센터점')).toBe('연수센터-7')
+  })
+
+  test('passes through non-toz venues unchanged', () => {
+    expect(resolveVenue('온라인(Webex)')).toBe('온라인(Webex)')
+    expect(resolveVenue('스페이스 A1')).toBe('스페이스 A1')
+    expect(resolveVenue('스페이스 M1')).toBe('스페이스 M1')
+    expect(resolveVenue('스페이스 S')).toBe('스페이스 S')
+    expect(resolveVenue('(엑스퍼트) 연수센터_라운지')).toBe('(엑스퍼트) 연수센터_라운지')
+    expect(resolveVenue('(엑스퍼트) 외부_카페')).toBe('(엑스퍼트) 외부_카페')
+  })
+
+  test('trims whitespace from input', () => {
+    expect(resolveVenue('  강남역토즈타워점  ')).toBe('토즈-강남역토즈타워점')
+    expect(resolveVenue(' 스페이스 A1 ')).toBe('스페이스 A1')
+  })
+
+  test('passes through unknown venues unchanged', () => {
+    expect(resolveVenue('기타 장소')).toBe('기타 장소')
+  })
+})

package/src/shared/utils/swmaestro.ts

@@ -1,12 +1,18 @@
 import { parse } from 'node-html-parser'
 
-import { MENU_NO, REPORT_CD, ROOM_IDS, TIME_SLOTS } from '../../constants'
+import { MENU_NO, REPORT_CD, ROOM_IDS, TIME_SLOTS, VENUE_ALIASES } from '../../constants'
 import { type ApplicationHistoryItem, ApplicationHistoryItemSchema } from '../../types'
+import { decodeHtmlEntities, escapeHtml } from './html'
 
 export function toReportCd(type: 'public' | 'lecture'): string {
   return type === 'lecture' ? REPORT_CD.MENTOR_LECTURE : REPORT_CD.PUBLIC_MENTORING
 }
 
+export function toMentoringType(type: string): 'public' | 'lecture' {
+  if (type.includes('특강') || type === 'lecture') return 'lecture'
+  return 'public'
+}
+
 export function buildMentoringPayload(params: {
   title: string
   type: 'public' | 'lecture'
@@ -29,8 +35,8 @@ export function buildMentoringPayload(params: {
     eventDt: params.date,
     eventStime: params.startTime,
     eventEtime: params.endTime,
-    place: params.venue,
-    qestnarCn: params.content ?? '',
+    place: resolveVenue(params.venue),
+    qestnarCn: formatEditorContent(params.content ?? ''),
     atchFileId: '',
     fileFieldNm_1: '',
     stateCd: 'QST020',
@@ -76,6 +82,11 @@ export function buildCancelApplicationPayload(params: { applySn: number; qustnrS
   }
 }
 
+export function resolveVenue(venue: string): string {
+  const trimmed = venue.trim()
+  return VENUE_ALIASES[trimmed] ?? trimmed
+}
+
 export function resolveRoomId(room: string | number): number {
   if (typeof room === 'number') {
     return room
@@ -190,7 +201,7 @@ export function parseEventDetail(html: string): Record<string, unknown> {
   return {
     id: extractNumber(labels.NO ?? labels.번호 ?? root.querySelector('[name="bbsId"]')?.getAttribute('value') ?? '0'),
     title: labels.제목 ?? cleanText(root.querySelector('h1, h2, .title')?.text),
-    content: contentNode?.innerHTML.trim() ?? '',
+    content: decodeHtmlEntities(contentNode?.innerHTML.trim() ?? ''),
     fields: labels,
   }
 }
@@ -216,6 +227,20 @@ function extractLabelMap(root: ReturnType<typeof parse>): Record<string, string>
   return map
 }
 
+const EDITOR_P_STYLE = 'font-family: 굴림; font-size: 12pt; line-height: 1.2; margin-top: 0px; margin-bottom: 0px;'
+
+function formatEditorContent(content: string): string {
+  if (!content) return ''
+  const decoded = decodeHtmlEntities(content)
+  if (/<(?:p|div|h[1-6]|ul|ol|table|br)\b/i.test(decoded)) {
+    return decoded
+  }
+  return decoded
+    .split(/\n/)
+    .map((line) => `<p style="${EDITOR_P_STYLE}">${escapeHtml(line) || '&nbsp;'}</p>`)
+    .join('')
+}
+
 function cleanText(value: string | null | undefined): string {
   return (value ?? '').replace(/\s+/g, ' ').replace(/\[|\]/g, '').trim()
 }
@@ -271,7 +296,7 @@ export function buildReportPayload(options: {
     reportGubunCd: reportType,
     progressDt: progressDate,
     teamNms: options.teamNames ?? '',
-    progressPlace: options.venue,
+    progressPlace: resolveVenue(options.venue),
     attendanceCnt: String(options.attendanceCount),
     attendanceNms: options.attendanceNames,
     progressStime: options.progressStartTime,