opensoma 0.2.1 → 0.3.0

package/src/formatters.ts

@@ -3,6 +3,8 @@ import { type HTMLElement, parse } from 'node-html-parser'
 import {
   ApplicationHistoryItemSchema,
   type ApplicationHistoryItem,
+  ApprovalListItemSchema,
+  type ApprovalListItem,
   DashboardSchema,
   EventListItemSchema,
   type Dashboard,
@@ -19,6 +21,10 @@ import {
   NoticeListItemSchema,
   type Pagination,
   PaginationSchema,
+  type ReportDetail,
+  ReportDetailSchema,
+  type ReportListItem,
+  ReportListItemSchema,
   type RoomCard,
   RoomCardSchema,
   type TeamInfo,
@@ -59,6 +65,19 @@ export function parseMentoringDetail(html: string, id = 0): MentoringDetail {
     root.querySelector('.view-content') ??
     root.querySelector('.content-body') ??
     root.querySelector('#contents')
+  const applicantTable = root.querySelectorAll('table').find((table) => {
+    const headers = table.querySelectorAll('thead th')
+    return headers.length === 5 && cleanText(headers[1]) === '연수생'
+  })
+  const applicants = (applicantTable?.querySelectorAll('tbody tr') ?? [])
+    .map((row) => row.querySelectorAll('td'))
+    .filter((cells) => cells.length === 5)
+    .map((cells) => ({
+      name: cleanText(cells[1]),
+      appliedAt: cleanText(cells[2]),
+      cancelledAt: cleanText(cells[3]),
+      status: stripWrappingBrackets(cleanText(cells[4])),
+    }))
 
   return MentoringDetailSchema.parse({
     id: id || extractNumber(root.querySelector('[name="qustnrSn"]')?.getAttribute('value') ?? ''),
@@ -81,6 +100,7 @@ export function parseMentoringDetail(html: string, id = 0): MentoringDetail {
     createdAt: labels['등록일'] || '',
     content: contentNode?.innerHTML.trim() ?? '',
     venue: labels['장소'] || '',
+    applicants,
   })
 }
 
@@ -271,6 +291,91 @@ export function parseCsrfToken(html: string): string {
   return token
 }
 
+export function parseReportList(html: string): ReportListItem[] {
+  return findTableRows(html, 9).map((cells) => {
+    const link = cells[2]?.querySelector('a')
+
+    return ReportListItemSchema.parse({
+      id: extractUrlParam(link?.getAttribute('href'), 'reportId'),
+      category: cleanText(cells[1]),
+      title: cleanText(link ?? cells[2]),
+      progressDate: cleanText(cells[3]),
+      status: cleanText(cells[4]),
+      author: cleanText(cells[5]),
+      createdAt: cleanText(cells[6]),
+      acceptedTime: cleanText(cells[7]),
+      payAmount: cleanText(cells[8]),
+    })
+  })
+}
+
+export function parseReportDetail(html: string, id = 0): ReportDetail {
+  const root = parse(html)
+  const labels = extractLabelMap(root)
+
+  const progressTimeText = labels['진행시간'] || ''
+  const exceptTimeText = labels['제외시간'] || ''
+  const progressTimes = progressTimeText.split(/\s*~\s*/)
+  const exceptTimes = exceptTimeText.split(/\s*~\s*/)
+
+  return ReportDetailSchema.parse({
+    id,
+    category: labels['구분'] || '',
+    title: labels['제목'] || '',
+    progressDate: labels['진행 날짜'] || '',
+    status: labels['상태'] || '',
+    author: labels['작성자'] || '',
+    createdAt: labels['등록일'] || '',
+    acceptedTime: labels['인정시간'] || '',
+    payAmount: labels['지급액'] || '',
+    content: labels['추진 내용'] || '',
+    subject: labels['주제'] || '',
+    menteeRegion: labels['멘토링 대상'] || '',
+    reportType: labels['구분'] || '',
+    teamNames: labels['팀명'] || '',
+    venue: labels['진행 장소'] || '',
+    attendanceCount: extractNumber(labels['참석 연수생'] || ''),
+    attendanceNames: labels['참석자 이름'] || '',
+    progressStartTime: progressTimes[0] || '',
+    progressEndTime: progressTimes[1] || '',
+    exceptStartTime: exceptTimes[0] || '',
+    exceptEndTime: exceptTimes[1] || '',
+    exceptReason: labels['제외 사유'] || labels['제외이유'] || '',
+    mentorOpinion: labels['멘토 의견'] || '',
+    nonAttendanceNames: labels['무단불참자'] || '',
+    etc: labels['특이사항'] || '',
+    files: [],
+  })
+}
+
+export function parseApprovalList(html: string): ApprovalListItem[] {
+  const rows = findTableRows(html, 10)
+
+  if (rows.length === 1) {
+    const firstRow = rows[0]
+    if (firstRow[0]?.getAttribute('colspan') || cleanText(firstRow[0]).includes('데이터가 없습니다')) {
+      return []
+    }
+  }
+
+  return rows.map((cells) => {
+    const link = cells[2]?.querySelector('a')
+
+    return ApprovalListItemSchema.parse({
+      id: extractUrlParam(link?.getAttribute('href'), 'reportId'),
+      category: cleanText(cells[1]),
+      title: cleanText(link ?? cells[2]),
+      progressDate: cleanText(cells[3]),
+      status: cleanText(cells[4]),
+      author: cleanText(cells[5]),
+      createdAt: cleanText(cells[6]),
+      acceptedTime: cleanText(cells[7]),
+      travelExpense: cleanText(cells[8]),
+      mentoringAllowance: cleanText(cells[9]),
+    })
+  })
+}
+
 function findTableRows(html: string, cellCount: number): HTMLElement[][] {
   return parse(html)
     .querySelectorAll('table tbody tr')

package/src/http.test.ts

@@ -52,6 +52,163 @@ describe('SomaHttp', () => {
     expect(html).toBe('<html>ok</html>')
   })
 
+  test('post surfaces alert errors from script tags with attributes', async () => {
+    const fetchMock = mock(async () =>
+      createResponse(
+        `<html><head><title>빈페이지</title></head><body><script type='text/javascript'>alert('아이디 혹은 비밀번호가 일치 하지 않습니다.');location.href='/login';</script></body></html>`,
+      ),
+    )
+    globalThis.fetch = fetchMock as typeof fetch
+
+    const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+    await expect(http.post('/member/user/toLogin.do', { username: 'neo@example.com' })).rejects.toThrow(
+      '아이디 혹은 비밀번호가 일치 하지 않습니다.',
+    )
+  })
+
+  test('post surfaces alert errors followed by history.back()', async () => {
+    const fetchMock = mock(async () =>
+      createResponse(
+        `<html><head></head><body><script language='JavaScript'>\nalert('잘못된 접근입니다.');\nhistory.back();\n</script></body></html>`,
+      ),
+    )
+    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('post ignores alert() inside function bodies (form validation scripts)', async () => {
+    const pageWithValidationScript = `<html><head><title>AI·SW마에스트로 서울</title></head><body>
+      <ul class="bbs-reserve"><li class="item">room data</li></ul>
+      <script>
+      function fn_search() {
+        var searchWrd = document.getElementById('searchWrd');
+        if (searchWrd.value == '') {
+          alert('검색어를 입력하세요.');
+          return;
+        }
+        document.forms[0].submit();
+      }
+      </script>
+    </body></html>`
+
+    const fetchMock = mock(async () => createResponse(pageWithValidationScript))
+    globalThis.fetch = fetchMock as typeof fetch
+
+    const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+    const html = await http.post('/mypage/officeMng/list.do', { menuNo: '200058' })
+    expect(html).toContain('room data')
+  })
+
+  describe('postMultipart', () => {
+    test('passes FormData to fetch', async () => {
+      const fetchMock = mock(async (_input: RequestInfo | URL, init?: RequestInit) => {
+        expect(init?.body).toBeInstanceOf(FormData)
+        return createResponse('<html>ok</html>')
+      })
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.postMultipart('/test', new FormData())).resolves.toBe('<html>ok</html>')
+    })
+
+    test('does not set Content-Type manually', async () => {
+      const fetchMock = mock(async (_input: RequestInfo | URL, init?: RequestInit) => {
+        expect(init?.headers).toEqual({
+          'Accept-Language': 'ko,en-US;q=0.9,en;q=0.8',
+          'User-Agent':
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36',
+          cookie: 'JSESSIONID=session-1',
+          Referer: 'https://www.swmaestro.ai/sw/test',
+        })
+        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.postMultipart('/test', new FormData())
+    })
+
+    test('appends csrf token to FormData', async () => {
+      const fetchMock = mock(async (_input: RequestInfo | URL, init?: RequestInit) => {
+        const body = init?.body
+        expect(body).toBeInstanceOf(FormData)
+        expect((body as FormData).get('csrfToken')).toBe('csrf-known')
+        return createResponse('<html>ok</html>')
+      })
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ csrfToken: 'csrf-known' })
+
+      await http.postMultipart('/test', new FormData())
+    })
+
+    test('follows redirects manually', async () => {
+      const fetchMock = mock(async (input: RequestInfo | URL, init?: RequestInit) => {
+        const url = String(input)
+
+        if (url === 'https://www.swmaestro.ai/sw/test') {
+          expect(init).toMatchObject({
+            method: 'POST',
+            redirect: 'manual',
+          })
+          return createResponse('', [], 'text/html', {
+            status: 302,
+            headers: { Location: '/mypage/mentoLec/result.do' },
+          })
+        }
+
+        expect(url).toBe('https://www.swmaestro.ai/mypage/mentoLec/result.do')
+        expect(init).toEqual({
+          method: 'GET',
+          redirect: 'manual',
+          headers: {
+            'Accept-Language': 'ko,en-US;q=0.9,en;q=0.8',
+            'User-Agent':
+              'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36',
+            cookie: 'JSESSIONID=session-1',
+          },
+        })
+        return createResponse('<html>redirected</html>')
+      })
+      globalThis.fetch = fetchMock as typeof fetch
+
+      const http = new SomaHttp({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+
+      await expect(http.postMultipart('/test', new FormData())).resolves.toBe('<html>redirected</html>')
+      expect(fetchMock).toHaveBeenCalledTimes(2)
+    })
+
+    test('keeps existing post() behavior unchanged', async () => {
+      const fetchMock = mock(async (_input: RequestInfo | URL, init?: RequestInit) => {
+        expect(init?.method).toBe('POST')
+        expect(init?.headers).toEqual({
+          'Accept-Language': 'ko,en-US;q=0.9,en;q=0.8',
+          'User-Agent':
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36',
+          cookie: 'JSESSIONID=session-1',
+          'Content-Type': 'application/x-www-form-urlencoded',
+        })
+        expect(init?.body).toBe('title=%ED%85%8C%EC%8A%A4%ED%8A%B8&csrfToken=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.post('/mypage/mentoLec/insert.do', { title: '테스트' })).resolves.toBe('<html>ok</html>')
+    })
+  })
+
   test('postJson returns parsed json', async () => {
     const fetchMock = mock(async (_input: RequestInfo | URL, init?: RequestInit) => {
       expect(init?.headers).toEqual({
@@ -204,7 +361,7 @@ function createResponse(
   contentType = 'text/html',
   options: { status?: number; headers?: Record<string, string> } = {},
 ): Response {
-  const headers = new Headers({ 'Content-Type': contentType, ...(options.headers ?? {}) })
+  const headers = new Headers({ 'Content-Type': contentType, ...options.headers })
   const response = new Response(body, { headers, status: options.status })
   const cookieHeaders = cookies
 

package/src/http.ts

@@ -134,6 +134,75 @@ export class SomaHttp {
     return finalBody
   }
 
+  async postMultipart(path: string, formData: FormData): Promise<string> {
+    const url = this.buildUrl(path)
+
+    if (this.csrfToken) {
+      formData.append('csrfToken', this.csrfToken)
+    }
+
+    let response = await fetch(url, {
+      method: 'POST',
+      headers: this.buildMultipartHeaders(url),
+      body: formData,
+      redirect: 'manual',
+    })
+
+    this.updateFromResponse(response)
+
+    if (response.status >= 300 && response.status < 400) {
+      const location = response.headers.get('location')
+      const intermediateBody = await response.clone().text()
+      const errorInfo = this.extractErrorFromResponse(intermediateBody, location, path)
+      if (errorInfo) {
+        if (errorInfo === '__AUTH_ERROR__') {
+          throw new AuthenticationError()
+        }
+        throw new Error(errorInfo)
+      }
+    }
+
+    let finalUrl = url
+    while (response.status >= 300 && response.status < 400) {
+      const location = response.headers.get('location')
+      if (!location) break
+
+      const redirectUrl = location.startsWith('http') ? location : new URL(location, `${BASE_URL}/`).toString()
+      finalUrl = redirectUrl
+      response = await fetch(redirectUrl, {
+        method: 'GET',
+        headers: this.buildHeaders(),
+        redirect: 'manual',
+      })
+      this.updateFromResponse(response)
+    }
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+    }
+
+    const finalBody = await response.text()
+    this.log('POST MULTIPART', path, '-> Final URL:', finalUrl)
+    this.log('POST MULTIPART', path, '-> Response body (first 200 chars):', finalBody.slice(0, 200))
+
+    const finalPath = new URL(finalUrl).pathname
+    const errorInfo = this.extractErrorFromResponse(finalBody, null, finalPath)
+    if (errorInfo) {
+      this.log('POST MULTIPART', path, '-> Error detected:', errorInfo)
+      if (errorInfo === '__AUTH_ERROR__') {
+        throw new AuthenticationError()
+      }
+      throw new Error(errorInfo)
+    }
+
+    if (finalPath.includes('insertForm') || finalPath.includes('error') || finalPath.includes('fail')) {
+      this.log('POST MULTIPART', path, '-> Suspicious final URL:', finalUrl)
+      throw new Error('멘토링 등록에 실패했습니다.')
+    }
+
+    return finalBody
+  }
+
   private extractErrorFromResponse(body: string, location: string | null, path?: string): string | null {
     this.log(
       'extractErrorFromResponse',
@@ -144,7 +213,7 @@ export class SomaHttp {
       body.match(/<title>([^<]*)<\/title>/)?.[1],
     )
 
-    const alertMatch = body.match(/<script>\s*alert\(['"](.+?)['"]\)\s*<\/script>/)
+    const alertMatch = body.match(/<script\b[^>]*>\s*alert\(['"](.+?)['"]\);?\s*(history\.|location\.)/i)
     if (alertMatch) {
       this.log('Found alert match:', alertMatch[1])
       return alertMatch[1]
@@ -343,6 +412,13 @@ export class SomaHttp {
     }
   }
 
+  private buildMultipartHeaders(referer: string): Record<string, string> {
+    return {
+      ...this.buildHeaders(),
+      Referer: referer,
+    }
+  }
+
   private isAuthRedirect(location: string | null): boolean {
     if (!location) {
       return false

package/src/shared/utils/report-params.ts

@@ -0,0 +1,41 @@
+export function buildReportListParams(options?: {
+  page?: number
+  searchField?: string // '' | '0' | '1' (전체/제목/내용)
+  searchKeyword?: string
+}): Record<string, string> {
+  const params: Record<string, string> = {
+    pageIndex: String(options?.page ?? 1),
+    menuNo: '200049',
+  }
+
+  if (options?.searchField !== undefined) {
+    params.searchCnd = options.searchField
+  }
+
+  if (options?.searchKeyword) {
+    params.searchWrd = options.searchKeyword
+  }
+
+  return params
+}
+
+export function buildApprovalListParams(options?: {
+  page?: number
+  month?: string // '01'-'12' or 'all'
+  reportType?: string // '' | 'MRC010' | 'MRC020'
+}): Record<string, string> {
+  const params: Record<string, string> = {
+    pageIndex: String(options?.page ?? 1),
+    menuNo: '200073',
+  }
+
+  if (options?.month) {
+    params.searchMonth = options.month
+  }
+
+  if (options?.reportType !== undefined) {
+    params.searchReport = options.reportType
+  }
+
+  return params
+}

package/src/shared/utils/swmaestro.ts

@@ -1,7 +1,7 @@
 import { parse } from 'node-html-parser'
 
 import { MENU_NO, REPORT_CD, ROOM_IDS, TIME_SLOTS } from '../../constants'
-import { ApplicationHistoryItemSchema, type ApplicationHistoryItem } from '../../types'
+import { type ApplicationHistoryItem, ApplicationHistoryItemSchema } from '../../types'
 
 export function toReportCd(type: 'public' | 'lecture'): string {
   return type === 'lecture' ? REPORT_CD.MENTOR_LECTURE : REPORT_CD.PUBLIC_MENTORING
@@ -41,6 +41,16 @@ export function buildMentoringPayload(params: {
   }
 }
 
+export function buildUpdateMentoringPayload(
+  id: number,
+  params: Parameters<typeof buildMentoringPayload>[0],
+): Record<string, string> {
+  return {
+    ...buildMentoringPayload(params),
+    qustnrSn: String(id),
+  }
+}
+
 export function buildDeleteMentoringPayload(id: number): Record<string, string> {
   return {
     menuNo: MENU_NO.MENTORING,
@@ -178,10 +188,8 @@ export function parseEventDetail(html: string): Record<string, unknown> {
     root.querySelector('.content-body')
 
   return {
-    id: extractNumber(
-      labels.NO ?? labels['번호'] ?? root.querySelector('[name="bbsId"]')?.getAttribute('value') ?? '0',
-    ),
-    title: labels['제목'] ?? cleanText(root.querySelector('h1, h2, .title')?.text),
+    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() ?? '',
     fields: labels,
   }
@@ -216,3 +224,67 @@ function extractNumber(value: string): number {
   const match = value.match(/\d+/)
   return match ? Number.parseInt(match[0], 10) : 0
 }
+
+export function toRegionCode(region: string): 'S' | 'B' {
+  if (region.includes('부산') || region === 'B') return 'B'
+  return 'S'
+}
+
+export function toReportTypeCd(type: string): 'MRC010' | 'MRC020' {
+  if (type.includes('특강') || type === 'MRC020') return 'MRC020'
+  return 'MRC010'
+}
+
+export function buildReportPayload(options: {
+  menteeRegion: 'S' | 'B'
+  reportType: 'MRC010' | 'MRC020'
+  progressDate: string // yyyy-mm-dd
+  teamNames?: string
+  venue: string
+  attendanceCount: number
+  attendanceNames: string
+  progressStartTime: string // HH:mm
+  progressEndTime: string // HH:mm
+  exceptStartTime?: string
+  exceptEndTime?: string
+  exceptReason?: string
+  subject: string
+  content: string
+  mentorOpinion?: string
+  nonAttendanceNames?: string
+  etc?: string
+  menuNo?: string
+  reportId?: number
+}): Record<string, string> {
+  const { progressDate, reportType } = options
+  const [year, month, day] = progressDate.split('-')
+  const typeNames: Record<string, string> = {
+    MRC010: '자유 멘토링',
+    MRC020: '멘토 특강',
+  }
+  const typeName = typeNames[reportType] ?? reportType
+  const nttSj = `[${typeName}] ${year}년 ${month}월 ${day}일 멘토링 보고`
+
+  return {
+    menuNo: options.menuNo ?? '200049',
+    menteeRegionCd: options.menteeRegion,
+    reportGubunCd: reportType,
+    progressDt: progressDate,
+    teamNms: options.teamNames ?? '',
+    progressPlace: options.venue,
+    attendanceCnt: String(options.attendanceCount),
+    attendanceNms: options.attendanceNames,
+    progressStime: options.progressStartTime,
+    progressEtime: options.progressEndTime,
+    exceptStime: options.exceptStartTime ?? '',
+    exceptEtime: options.exceptEndTime ?? '',
+    exceptReason: options.exceptReason ?? '',
+    subject: options.subject,
+    nttCn: options.content,
+    mentoOpn: options.mentorOpinion ?? '',
+    nonAttendanceNms: options.nonAttendanceNames ?? '',
+    etc: options.etc ?? '',
+    nttSj,
+    ...(options.reportId !== undefined ? { reportId: String(options.reportId) } : {}),
+  }
+}

package/src/token-extractor.ts

@@ -22,9 +22,9 @@ type BrowserConfig = {
 }
 
 type CookieRow = {
-  encrypted_value: Uint8Array | Buffer | null
+  encrypted_value: ArrayBuffer | Uint8Array | Buffer | null
   last_access_utc?: number | bigint | null
-  value: string | null
+  value: ArrayBuffer | Uint8Array | Buffer | string | null
 }
 
 export interface ExtractedSessionCandidate {
@@ -92,6 +92,20 @@ function queryCookieDb(dbPath: string): CookieRow | undefined {
   }
 
   try {
+    const Database = require('better-sqlite3') as new (
+      path: string,
+      options?: { readonly?: boolean },
+    ) => {
+      close: () => void
+      prepare: (query: string) => { get: () => CookieRow | undefined }
+    }
+    const db = new Database(dbPath, { readonly: true })
+    try {
+      return db.prepare(COOKIE_QUERY).get() ?? undefined
+    } finally {
+      db.close()
+    }
+  } catch {
     const { DatabaseSync } = require('node:sqlite') as {
       DatabaseSync: new (
         path: string,
@@ -107,20 +121,6 @@ function queryCookieDb(dbPath: string): CookieRow | undefined {
     } finally {
       db.close()
     }
-  } catch {
-    const Database = require('better-sqlite3') as new (
-      path: string,
-      options?: { readonly?: boolean },
-    ) => {
-      close: () => void
-      prepare: (query: string) => { get: () => CookieRow | undefined }
-    }
-    const db = new Database(dbPath, { readonly: true })
-    try {
-      return db.prepare(COOKIE_QUERY).get() ?? undefined
-    } finally {
-      db.close()
-    }
   }
 }
 
@@ -156,14 +156,14 @@ export class TokenExtractor {
       const tempDatabasePath = join(tempDirectory, 'Cookies')
 
       try {
-        copyFileSync(databasePath, tempDatabasePath)
+        copySqliteDatabase(databasePath, tempDatabasePath)
 
         const row = queryCookieDb(tempDatabasePath)
         if (!row) {
           continue
         }
 
-        const plaintextValue = typeof row.value === 'string' ? row.value.trim() : ''
+        const plaintextValue = normalizeCookieText(row.value)
         if (plaintextValue) {
           this.addCandidate(candidates, {
             browser: browser.name,
@@ -174,11 +174,12 @@ export class TokenExtractor {
           continue
         }
 
-        if (!row.encrypted_value || row.encrypted_value.length === 0) {
+        const encryptedValue = normalizeCookieBytes(row.encrypted_value)
+        if (!encryptedValue || encryptedValue.length === 0) {
           continue
         }
 
-        const decryptedValue = await this.decryptCookie(Buffer.from(row.encrypted_value), browser.name)
+        const decryptedValue = await this.decryptCookie(encryptedValue, browser.name)
         if (decryptedValue) {
           this.addCandidate(candidates, {
             browser: browser.name,
@@ -299,3 +300,41 @@ export class TokenExtractor {
     return typeof lastAccessUtc === 'number' ? lastAccessUtc : 0
   }
 }
+
+function copySqliteDatabase(sourcePath: string, targetPath: string): void {
+  copyFileSync(sourcePath, targetPath)
+
+  for (const suffix of ['-wal', '-shm']) {
+    const sidecarSourcePath = `${sourcePath}${suffix}`
+    if (!existsSync(sidecarSourcePath)) {
+      continue
+    }
+
+    copyFileSync(sidecarSourcePath, `${targetPath}${suffix}`)
+  }
+}
+
+function normalizeCookieBytes(value: ArrayBuffer | Uint8Array | Buffer | null): Buffer | null {
+  if (!value) {
+    return null
+  }
+
+  if (Buffer.isBuffer(value)) {
+    return value
+  }
+
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value)
+  }
+
+  return Buffer.from(value)
+}
+
+function normalizeCookieText(value: ArrayBuffer | Uint8Array | Buffer | string | null): string {
+  if (typeof value === 'string') {
+    return value.trim()
+  }
+
+  const bytes = normalizeCookieBytes(value)
+  return bytes ? bytes.toString('utf8').trim() : ''
+}