opensoma 0.4.0 → 0.5.1

package/src/token-extractor.ts

@@ -8,7 +8,7 @@ import { basename, dirname, join } from 'node:path'
 const require = createRequire(import.meta.url)
 
 const COOKIE_QUERY =
-  "SELECT encrypted_value, last_access_utc, value FROM cookies WHERE host_key LIKE '%swmaestro.ai' AND name = 'JSESSIONID' ORDER BY last_access_utc DESC LIMIT 1"
+  "SELECT encrypted_value, last_access_utc, value FROM cookies WHERE (host_key LIKE '%swmaestro.ai' OR host_key LIKE '%opensoma.dev') AND name = 'JSESSIONID' ORDER BY last_access_utc DESC LIMIT 1"
 const CHROMIUM_SALT = 'saltysalt'
 const CHROMIUM_IV = Buffer.alloc(16, 0x20)
 const PROFILE_DIR_PATTERN = /^Profile\s+\d+$/
@@ -124,11 +124,36 @@ function queryCookieDb(dbPath: string): CookieRow | undefined {
   }
 }
 
+export type TokenExtractorOptions = {
+  platform?: NodeJS.Platform
+  homeDirectory?: string
+  debug?: boolean
+}
+
 export class TokenExtractor {
-  constructor(
-    private readonly platform: NodeJS.Platform = process.platform,
-    private readonly homeDirectory: string = homedir(),
-  ) {}
+  private readonly platform: NodeJS.Platform
+  private readonly homeDirectory: string
+  private readonly debugEnabled: boolean
+
+  constructor(options?: TokenExtractorOptions)
+  constructor(platform?: NodeJS.Platform, homeDirectory?: string, debug?: boolean)
+  constructor(platformOrOptions?: NodeJS.Platform | TokenExtractorOptions, homeDirectory?: string, debug?: boolean) {
+    if (typeof platformOrOptions === 'object' && platformOrOptions !== null) {
+      this.platform = platformOrOptions.platform ?? process.platform
+      this.homeDirectory = platformOrOptions.homeDirectory ?? homedir()
+      this.debugEnabled = platformOrOptions.debug ?? false
+    } else {
+      this.platform = platformOrOptions ?? process.platform
+      this.homeDirectory = homeDirectory ?? homedir()
+      this.debugEnabled = debug ?? false
+    }
+  }
+
+  private log(...args: unknown[]): void {
+    if (!this.debugEnabled) return
+    const message = args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ')
+    process.stderr.write(`[extract] ${message}\n`)
+  }
 
   async extract(): Promise<{ sessionCookie: string } | null> {
     const candidates = await this.extractCandidates()
@@ -143,28 +168,35 @@ export class TokenExtractor {
 
   async extractCandidates(): Promise<ExtractedSessionCandidate[]> {
     const candidates = new Map<string, ExtractedSessionCandidate>()
+    const cookieDatabases = this.findCookieDatabases()
+    this.log(`Found ${cookieDatabases.length} cookie database(s)`)
 
-    for (const databasePath of this.findCookieDatabases()) {
+    for (const databasePath of cookieDatabases) {
       const browser = this.getBrowserByPath(databasePath)
       if (!browser) {
+        this.log(`Skipping ${databasePath} (no matching browser config)`)
         continue
       }
 
       const profile = basename(dirname(databasePath))
+      this.log(`Processing ${browser.name} / ${profile}`)
 
       const tempDirectory = mkdtempSync(join(tmpdir(), 'opensoma-cookie-db-'))
       const tempDatabasePath = join(tempDirectory, 'Cookies')
 
       try {
         copySqliteDatabase(databasePath, tempDatabasePath)
+        this.log(`  Copied DB to ${tempDatabasePath}`)
 
         const row = queryCookieDb(tempDatabasePath)
         if (!row) {
+          this.log('  No JSESSIONID cookie found')
           continue
         }
 
         const plaintextValue = normalizeCookieText(row.value)
         if (plaintextValue) {
+          this.log(`  Found plaintext cookie (${plaintextValue.length} chars)`)
           this.addCandidate(candidates, {
             browser: browser.name,
             lastAccessUtc: this.normalizeLastAccessUtc(row.last_access_utc),
@@ -176,29 +208,40 @@ export class TokenExtractor {
 
         const encryptedValue = normalizeCookieBytes(row.encrypted_value)
         if (!encryptedValue || encryptedValue.length === 0) {
+          this.log('  No plaintext or encrypted value')
           continue
         }
 
+        this.log(`  Decrypting encrypted cookie (${encryptedValue.length} bytes)...`)
         const decryptedValue = await this.decryptCookie(encryptedValue, browser.name)
         if (decryptedValue) {
+          this.log(`  Decrypted successfully (${decryptedValue.length} chars)`)
           this.addCandidate(candidates, {
             browser: browser.name,
             lastAccessUtc: this.normalizeLastAccessUtc(row.last_access_utc),
             profile,
             sessionCookie: decryptedValue,
           })
+        } else {
+          this.log('  Decryption returned empty value')
         }
-      } catch {
+      } catch (error) {
+        this.log(`  Error: ${error instanceof Error ? error.message : String(error)}`)
       } finally {
         rmSync(tempDirectory, { recursive: true, force: true })
       }
     }
 
+    this.log(`Total unique candidates: ${candidates.size}`)
     return [...candidates.values()].sort((left, right) => right.lastAccessUtc - left.lastAccessUtc)
   }
 
   findCookieDatabases(): string[] {
-    return BROWSERS.flatMap((browser) => this.findBrowserCookieDatabases(browser))
+    const results = BROWSERS.flatMap((browser) => this.findBrowserCookieDatabases(browser))
+    if (results.length === 0) {
+      this.log('No cookie databases found. Searched browsers:', BROWSERS.map((b) => b.name).join(', '))
+    }
+    return results
   }
 
   private async decryptCookie(encryptedValue: Buffer, browserName: string): Promise<string> {
@@ -207,14 +250,18 @@ export class TokenExtractor {
     }
 
     if (this.platform === 'linux') {
+      this.log('  Using Linux PBKDF2 decryption')
       return this.decryptChromiumValue(encryptedValue, pbkdf2Sync('peanuts', CHROMIUM_SALT, 1, 16, 'sha1'))
     }
 
     if (this.platform === 'darwin') {
+      this.log(`  Fetching macOS Keychain key for ${browserName}...`)
       const key = await this.getMacOSEncryptionKey(browserName)
+      this.log('  Keychain key obtained')
       return this.decryptChromiumValue(encryptedValue, key)
     }
 
+    this.log(`  Unsupported platform for decryption: ${this.platform}`)
     return ''
   }
 
@@ -224,11 +271,10 @@ export class TokenExtractor {
       throw new Error(`Unsupported browser: ${browserName}`)
     }
 
-    const password = execSync(
-      `security find-generic-password -s ${JSON.stringify(browser.keychainService)} -a ${JSON.stringify(browser.keychainAccount)} -w`,
-      { encoding: 'utf8' },
-    ).trimEnd()
+    const command = `security find-generic-password -s ${JSON.stringify(browser.keychainService)} -a ${JSON.stringify(browser.keychainAccount)} -w`
+    this.log(`  Keychain command: ${command}`)
 
+    const password = execSync(command, { encoding: 'utf8' }).trimEnd()
     return pbkdf2Sync(password, CHROMIUM_SALT, 1003, 16, 'sha1')
   }
 
@@ -266,14 +312,20 @@ export class TokenExtractor {
   private findBrowserCookieDatabases(browser: BrowserConfig): string[] {
     const browserRoot = this.getBrowserRoot(browser)
     if (!browserRoot || !existsSync(browserRoot)) {
+      this.log(`${browser.name}: not found at ${browserRoot ?? '(unsupported platform)'}`)
       return []
     }
 
-    return readdirSync(browserRoot, { withFileTypes: true })
+    const profiles = readdirSync(browserRoot, { withFileTypes: true })
       .filter((entry) => entry.isDirectory() && this.isSupportedProfileDirectory(entry.name))
       .sort((left, right) => left.name.localeCompare(right.name))
+
+    const databases = profiles
       .map((entry) => join(browserRoot, entry.name, 'Cookies'))
       .filter((databasePath) => existsSync(databasePath))
+
+    this.log(`${browser.name}: ${profiles.length} profile(s), ${databases.length} cookie DB(s)`)
+    return databases
   }
 
   private getBrowserRoot(browser: BrowserConfig): string | null {

package/src/toz-formatters.test.ts

@@ -0,0 +1,197 @@
+import { describe, expect, it } from 'bun:test'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import {
+  isReservationConfirmSuccess,
+  parseBookingPageBranches,
+  parseBookingPageMeetings,
+  parseMypageReservations,
+  parseTozBoothes,
+  parseTozDurations,
+  parseTozReserved,
+} from './toz-formatters'
+
+const FIXTURES_DIR = join(__dirname, '__fixtures__', 'toz')
+
+function readFixture(name: string): string {
+  return readFileSync(join(FIXTURES_DIR, name), 'utf8')
+}
+
+function readJsonFixture<T>(name: string): T {
+  return JSON.parse(readFixture(name)) as T
+}
+
+describe('parseBookingPageBranches', () => {
+  it('extracts all 9 SW마에스트로 partner branches', () => {
+    const html = readFixture('toz_booking.html')
+    const branches = parseBookingPageBranches(html)
+
+    expect(branches).toEqual([
+      { id: 27, name: '강남토즈타워점' },
+      { id: 145, name: '강남컨퍼런스센터' },
+      { id: 19, name: '양재점' },
+      { id: 20, name: '건대점' },
+      { id: 15, name: '선릉점' },
+      { id: 139, name: '마이스 역삼센터' },
+      { id: 134, name: '마이스 광화문센터' },
+      { id: 30, name: '신촌비즈센터' },
+      { id: 149, name: '홍대점' },
+    ])
+  })
+})
+
+describe('parseBookingPageMeetings', () => {
+  it('extracts meeting options excluding placeholder and 새모임', () => {
+    const html = readFixture('toz_booking.html')
+    const meetings = parseBookingPageMeetings(html)
+
+    expect(meetings.length).toBeGreaterThan(50)
+    expect(meetings[0]).toEqual({ id: 2305094, name: '멘토특강_김현동 님' })
+    expect(meetings.find((m) => m.id === 2322942)).toEqual({
+      id: 2322942,
+      name: '자유멘토링_SW마에스트로',
+    })
+
+    expect(meetings.find((m) => m.name === '[새 모임]')).toBeUndefined()
+    for (const meeting of meetings) {
+      expect(Number.isInteger(meeting.id)).toBe(true)
+      expect(meeting.id).toBeGreaterThan(0)
+    }
+  })
+})
+
+describe('parseTozDurations', () => {
+  it('parses duration JSON with computed minutes', () => {
+    const json = readJsonFixture('toz_duration.json')
+    const durations = parseTozDurations(json)
+
+    expect(durations[0]).toEqual({ key: '0200', value: '2시간', minutes: 120 })
+    expect(durations[1]).toEqual({ key: '0230', value: '2시간 30분', minutes: 150 })
+    expect(durations[2]).toEqual({ key: '0300', value: '3시간', minutes: 180 })
+  })
+
+  it('returns [] for non-array', () => {
+    expect(parseTozDurations(null)).toEqual([])
+    expect(parseTozDurations({})).toEqual([])
+  })
+})
+
+describe('parseTozBoothes', () => {
+  it('parses booth JSON array', () => {
+    const json = readJsonFixture('toz_boothes.json')
+    const boothes = parseTozBoothes(json)
+
+    expect(boothes).toHaveLength(3)
+    expect(boothes[0]).toEqual({
+      id: 740,
+      name: '304 _ A',
+      branchName: '토즈타워점',
+      branchTel: '02-3454-0116',
+      minUseUserCount: 1,
+      enableMaxUserCount: 2,
+      boothGroupName: '2인부스 A타입',
+      boothGroupUrl: 'https://moim.toz.co.kr/branchDetail?branch_id=28&url=&path=',
+      boothMemoForUser: '15,000원(기본2시간)  / 기업, 학생할인 적용',
+      isLargeBooth: false,
+    })
+  })
+
+  it('throws on non-SUCCESS error response', () => {
+    const error = [{ resultMsg: '예약 가능한 부스가 없습니다.' }]
+    expect(() => parseTozBoothes(error)).toThrow('예약 가능한 부스가 없습니다.')
+  })
+
+  it('returns [] for empty', () => {
+    expect(parseTozBoothes([])).toEqual([])
+    expect(parseTozBoothes(null)).toEqual([])
+  })
+})
+
+describe('parseTozReserved', () => {
+  it('parses successful booth reservation response', () => {
+    const reserved = parseTozReserved({
+      result: 'SUCCESS',
+      resultMsg: 'abc-123',
+      branchName: '토즈타워점',
+      branchTel: '02-3454-0116',
+      boothGroupName: '2인부스 A타입',
+      boothIsLarge: false,
+      entitys: [],
+    })
+
+    expect(reserved).toEqual({
+      reservationId: 'abc-123',
+      branchName: '토즈타워점',
+      branchTel: '02-3454-0116',
+      boothGroupName: '2인부스 A타입',
+      isLargeBooth: false,
+    })
+  })
+
+  it('throws on failure response', () => {
+    expect(() => parseTozReserved({ result: 'FAIL', resultMsg: '이미 예약된 부스입니다.' })).toThrow(
+      '이미 예약된 부스입니다.',
+    )
+  })
+})
+
+describe('isReservationConfirmSuccess', () => {
+  it('detects standard success', () => {
+    expect(isReservationConfirmSuccess('예약 되었습니다.')).toBe(true)
+  })
+
+  it('detects large-booth success', () => {
+    expect(isReservationConfirmSuccess('대형부스 예약 신청되었습니다. 지점에서 확인 전화를 드릴 예정입니다.')).toBe(
+      true,
+    )
+  })
+
+  it('rejects error messages', () => {
+    expect(isReservationConfirmSuccess('인증번호가 올바르지 않습니다.')).toBe(false)
+  })
+})
+
+describe('parseMypageReservations', () => {
+  it('returns empty array when no reservations', () => {
+    const html = readFixture('toz_mypage_response.html')
+    expect(parseMypageReservations(html)).toEqual([])
+  })
+
+  it('parses synthetic reservation row', () => {
+    const html = `
+      <html><body>
+        <table class="reservation"><thead><tr><th>NO</th></tr></thead><tbody>
+          <tr><td colspan="7">예약 요청 정보가 없습니다.</td></tr>
+        </tbody></table>
+        <table class="reservation"><thead></thead><tbody>
+          <tr>
+            <td>1</td>
+            <td>자유멘토링_홍길동</td>
+            <td>2026-04-21</td>
+            <td>14:00 ~ 16:00</td>
+            <td>토즈타워점</td>
+            <td>304 _ A</td>
+            <td>2026-04-17 18:45</td>
+            <td>예약완료 <a href="javascript:destroyReservation(987654)">취소</a></td>
+          </tr>
+        </tbody></table>
+      </body></html>
+    `
+
+    expect(parseMypageReservations(html)).toEqual([
+      {
+        no: 1,
+        reservationId: 987654,
+        meetingName: '자유멘토링_홍길동',
+        date: '2026-04-21',
+        startTime: '14:00',
+        endTime: '16:00',
+        branchName: '토즈타워점',
+        boothName: '304 _ A',
+        reservedAt: '2026-04-17 18:45',
+        status: '예약완료 취소',
+      },
+    ])
+  })
+})

package/src/toz-formatters.ts

@@ -0,0 +1,211 @@
+import { parse } from 'node-html-parser'
+
+import { decodeHtmlEntities } from './shared/utils/html'
+import { parseDurationKey } from './shared/utils/toz'
+import {
+  type TozBooth,
+  TozBoothSchema,
+  type TozBranch,
+  TozBranchSchema,
+  type TozDuration,
+  TozDurationSchema,
+  type TozMeeting,
+  TozMeetingSchema,
+  type TozReservation,
+  TozReservationSchema,
+  type TozReserved,
+  TozReservedSchema,
+} from './types'
+
+interface RawBooth {
+  resultMsg?: string
+  id?: number
+  name?: string
+  branchName?: string
+  branchTel?: string
+  minUseUserCount?: number
+  enableMaxUserCount?: number
+  boothGroupName?: string
+  boothGroupUrl?: string | null
+  boothMemoForUser?: string
+  isLargeBooth?: boolean
+}
+
+interface RawReserved {
+  result?: string
+  resultMsg?: string
+  branchName?: string
+  branchTel?: string
+  boothGroupName?: string
+  boothIsLarge?: boolean
+}
+
+interface RawDuration {
+  key: string
+  value: string
+}
+
+export function parseBookingPageBranches(html: string): TozBranch[] {
+  const root = parse(html)
+  const inputs = root.querySelectorAll('input[name="branch_id"]')
+  const branches: TozBranch[] = []
+
+  for (const input of inputs) {
+    const value = input.getAttribute('value')
+    if (!value) continue
+    const id = Number.parseInt(value, 10)
+    if (!Number.isFinite(id)) continue
+
+    const label = input.parentNode
+    const name = label ? cleanText(label.text) : ''
+    if (!name) continue
+
+    branches.push(TozBranchSchema.parse({ id, name }))
+  }
+
+  return branches
+}
+
+export function parseBookingPageMeetings(html: string): TozMeeting[] {
+  const root = parse(html)
+  const select = root.querySelector('select[name="meeting_id"]')
+  if (!select) return []
+
+  const meetings: TozMeeting[] = []
+  for (const option of select.querySelectorAll('option')) {
+    const value = option.getAttribute('value')
+    if (!value || value === '새모임') continue
+    const id = Number.parseInt(value, 10)
+    if (!Number.isFinite(id)) continue
+
+    const name = cleanText(option.text)
+    if (!name) continue
+
+    meetings.push(TozMeetingSchema.parse({ id, name }))
+  }
+
+  return meetings
+}
+
+export function parseTozDurations(json: unknown): TozDuration[] {
+  if (!Array.isArray(json)) return []
+  const seen = new Set<string>()
+  const durations: TozDuration[] = []
+
+  for (const raw of json as RawDuration[]) {
+    if (!raw?.key || !raw?.value || seen.has(raw.key)) continue
+    seen.add(raw.key)
+    durations.push(
+      TozDurationSchema.parse({
+        key: raw.key,
+        value: raw.value,
+        minutes: parseDurationKey(raw.key),
+      }),
+    )
+  }
+
+  return durations
+}
+
+export function parseTozBoothes(json: unknown): TozBooth[] {
+  if (!Array.isArray(json)) return []
+  const items = json as RawBooth[]
+  if (items.length === 0) return []
+
+  const first = items[0]
+  if (first?.resultMsg && first.resultMsg !== 'SUCCESS') {
+    throw new Error(first.resultMsg)
+  }
+
+  return items
+    .filter((raw) => raw.id !== undefined && raw.id !== null)
+    .map((raw) =>
+      TozBoothSchema.parse({
+        id: raw.id,
+        name: raw.name ?? '',
+        branchName: raw.branchName ?? '',
+        branchTel: raw.branchTel ?? '',
+        minUseUserCount: raw.minUseUserCount ?? 0,
+        enableMaxUserCount: raw.enableMaxUserCount ?? 0,
+        boothGroupName: raw.boothGroupName ?? '',
+        boothGroupUrl: raw.boothGroupUrl ?? null,
+        boothMemoForUser: raw.boothMemoForUser ?? '',
+        isLargeBooth: Boolean(raw.isLargeBooth),
+      }),
+    )
+}
+
+export function parseTozReserved(json: unknown): TozReserved {
+  const raw = json as RawReserved | null
+  if (!raw || raw.result !== 'SUCCESS' || !raw.resultMsg) {
+    throw new Error(raw?.resultMsg || '부스 예약에 실패했습니다.')
+  }
+
+  return TozReservedSchema.parse({
+    reservationId: raw.resultMsg,
+    branchName: raw.branchName ?? '',
+    branchTel: raw.branchTel ?? '',
+    boothGroupName: raw.boothGroupName ?? '',
+    isLargeBooth: Boolean(raw.boothIsLarge),
+  })
+}
+
+const SUCCESS_PATTERNS = ['예약 되었습니다', '대형부스 예약 신청되었습니다']
+
+export function isReservationConfirmSuccess(resultMsg: string): boolean {
+  return SUCCESS_PATTERNS.some((p) => resultMsg.includes(p))
+}
+
+export function parseMypageReservations(html: string): TozReservation[] {
+  const root = parse(html)
+  // The 실시간예약 table is the second table.reservation in the page.
+  // The 상담요청 table (first) lives inside a parent <table style="display:none">.
+  const tables = root.querySelectorAll('table.reservation')
+  if (tables.length === 0) return []
+
+  const target = tables[tables.length - 1]
+  const rows = target.querySelectorAll('tbody tr')
+  const reservations: TozReservation[] = []
+
+  for (const row of rows) {
+    const cells = row.querySelectorAll('td')
+    if (cells.length !== 8) continue
+
+    const [no, meetingName, date, time, branch, booth, reservedAt, statusCell] = cells
+    const cancelLink = statusCell.querySelector('a')
+    const reservationId = extractReservationIdFromOnclick(cancelLink?.getAttribute('href'))
+
+    reservations.push(
+      TozReservationSchema.parse({
+        no: Number.parseInt(cleanText(no.text), 10) || 0,
+        reservationId,
+        meetingName: cleanText(meetingName.text),
+        date: cleanText(date.text),
+        ...splitTimeRange(cleanText(time.text)),
+        branchName: cleanText(branch.text),
+        boothName: cleanText(booth.text),
+        reservedAt: cleanText(reservedAt.text),
+        status: cleanText(statusCell.text),
+      }),
+    )
+  }
+
+  return reservations
+}
+
+function splitTimeRange(text: string): { startTime: string; endTime: string } {
+  const match = /(\d{1,2}:\d{2})\s*[~-]\s*(\d{1,2}:\d{2})/.exec(text)
+  if (!match) return { startTime: text, endTime: '' }
+  return { startTime: match[1], endTime: match[2] }
+}
+
+function extractReservationIdFromOnclick(href: string | undefined): number | null {
+  if (!href) return null
+  const match = /destroyReservation\(\s*(\d+)\s*\)/.exec(href)
+  if (!match) return null
+  return Number.parseInt(match[1], 10)
+}
+
+function cleanText(text: string): string {
+  return decodeHtmlEntities(text).replace(/\s+/g, ' ').trim()
+}