opensoma 0.6.0 → 0.8.0

package/src/toz-client.ts

@@ -0,0 +1,311 @@
+import {
+  assertDurationInRange,
+  buildBranchIdsParam,
+  buildStartTimeParam,
+  formatDuration,
+  formatPhone,
+  parseEmail,
+  parsePhone,
+} from './shared/utils/toz'
+import {
+  isReservationConfirmSuccess,
+  parseBookingPageBranches,
+  parseBookingPageMeetings,
+  parseMypageReservations,
+  parseTozBoothes,
+  parseTozDurations,
+  parseTozReserved,
+} from './toz-formatters'
+import { TozHttp, type TozHttpOptions } from './toz-http'
+import type { TozBooth, TozBranch, TozDuration, TozMeeting, TozReservation, TozReserved } from './types'
+
+export interface TozAvailabilityQuery {
+  date: string
+  startTime: string
+  durationMinutes: number
+  userCount: number
+  branchIds: readonly number[]
+}
+
+export interface TozCheckQuery {
+  date: string
+  startTimes: readonly string[]
+  durationMinutes: number
+  userCount: number
+  branchIds: readonly number[]
+}
+
+export interface TozCheckResult {
+  startTime: string
+  booths: TozBooth[]
+  error?: string
+}
+
+export interface TozReserveBoothArgs {
+  date: string
+  startTime: string
+  durationMinutes: number
+  userCount: number
+  boothId: number
+}
+
+export interface TozConfirmArgs {
+  reservationId: string
+  date: string
+  startTime: string
+  durationMinutes: number
+  name: string
+  phone: string
+  email: string
+  pinNum: string
+  meetingId?: number
+  newMeetingName?: string
+  memo?: string
+}
+
+export interface TozSearchArgs {
+  name?: string
+  phone?: string
+  startDate?: string
+  endDate?: string
+  meetingName?: string
+}
+
+export interface TozCancelArgs {
+  reservationId: number
+  name?: string
+  phone?: string
+}
+
+export interface TozClientOptions extends TozHttpOptions {
+  name?: string
+  phone?: string
+}
+
+export class TozClient {
+  readonly http: TozHttp
+  readonly identity: { name?: string; phone?: string }
+
+  constructor(options: TozClientOptions = {}) {
+    const { name, phone, ...httpOptions } = options
+    this.http = new TozHttp(httpOptions)
+    this.identity = { name, phone }
+  }
+
+  async branches(): Promise<TozBranch[]> {
+    await this.http.bootstrap()
+    return parseBookingPageBranches(await this.http.get('/booking.htm'))
+  }
+
+  async meetings(): Promise<TozMeeting[]> {
+    await this.http.bootstrap()
+    return parseBookingPageMeetings(await this.http.get('/booking.htm'))
+  }
+
+  async durations(date: string, startTime: string): Promise<TozDuration[]> {
+    await this.http.bootstrap()
+    const param = buildStartTimeParam(startTime)
+    const json = await this.http.postJson<unknown>('/ajaxCheckDurationTime.htm', {
+      basedate: date,
+      hour: param.slice(0, 2),
+      minute: param.slice(2, 4),
+    })
+    return parseTozDurations(json)
+  }
+
+  async available(query: TozAvailabilityQuery): Promise<TozBooth[]> {
+    assertDurationInRange(query.durationMinutes)
+    await this.http.bootstrap()
+    const json = await this.http.postJson<unknown>('/ajaxGetEnableBoothes.htm', {
+      basedate: query.date,
+      starttime: buildStartTimeParam(query.startTime),
+      durationTime: formatDuration(query.durationMinutes),
+      userCount: String(query.userCount),
+      branchIds: buildBranchIdsParam(query.branchIds),
+    })
+    return parseTozBoothes(json)
+  }
+
+  async check(query: TozCheckQuery): Promise<TozCheckResult[]> {
+    if (query.startTimes.length === 0) {
+      throw new Error('toz check requires at least one --time. For a single slot, use `toz available` instead.')
+    }
+    if (query.startTimes.length > 6) {
+      throw new Error(
+        'Too many times (max 6 per invocation). Consider `toz available` for a single slot, or split into multiple invocations.',
+      )
+    }
+    assertDurationInRange(query.durationMinutes)
+    await this.http.bootstrap()
+
+    const results: TozCheckResult[] = []
+    for (let i = 0; i < query.startTimes.length; i += 1) {
+      const startTime = query.startTimes[i]!
+      try {
+        const booths = await this.available({
+          date: query.date,
+          startTime,
+          durationMinutes: query.durationMinutes,
+          userCount: query.userCount,
+          branchIds: query.branchIds,
+        })
+        results.push({ startTime, booths })
+      } catch (error) {
+        results.push({
+          startTime,
+          booths: [],
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+      if (i < query.startTimes.length - 1) await sleep(500)
+    }
+    return results
+  }
+
+  async reserveBooth(args: TozReserveBoothArgs): Promise<TozReserved> {
+    assertDurationInRange(args.durationMinutes)
+    await this.http.bootstrap()
+    const json = await this.http.postJson<unknown>('/ajaxReservationBooth.htm', {
+      basedate: args.date,
+      starttime: buildStartTimeParam(args.startTime),
+      durationTime: formatDuration(args.durationMinutes),
+      userCount: String(args.userCount),
+      booth_id: String(args.boothId),
+    })
+    const reserved = parseTozReserved(json)
+    if (reserved.isLargeBooth) {
+      throw new Error('대형부스 예약은 선입금 약관 동의가 필요합니다. v1에서는 지원하지 않습니다 (small booths only).')
+    }
+    return reserved
+  }
+
+  async skipEquipment(args: {
+    reservationId: string
+    date: string
+    startTime: string
+    durationMinutes: number
+  }): Promise<void> {
+    await this.http.postText('/ajaxReservationEquipment.htm', {
+      reservationId: args.reservationId,
+      basedate: args.date,
+      starttime: buildStartTimeParam(args.startTime),
+      durationTime: formatDuration(args.durationMinutes),
+      equipmentNotebookChecked: 'false',
+      equipmentProjectorChecked: 'false',
+      equipmentMonitorChecked: 'false',
+      equipmentPlayerChecked: 'false',
+      equipmentSpeakerChecked: 'false',
+      equipmentNotebookCnt: '0',
+      equipmentProjectorCnt: '0',
+      equipmentMonitorCnt: '0',
+      equipmentPlayerCnt: '0',
+      equipmentSpeakerCnt: '0',
+    })
+  }
+
+  async sendOtp(phone?: string): Promise<void> {
+    const parts = parsePhone(this.requirePhone(phone))
+    const result = await this.http.postText('/ajaxHpVerify.htm', { ...parts })
+    if (result !== 'SUCCESS') {
+      throw new Error(`OTP 발송 실패: ${result}`)
+    }
+  }
+
+  async confirm(args: TozConfirmArgs): Promise<{ resultMsg: string; isLargeBooth: boolean }> {
+    if (!args.meetingId && !args.newMeetingName) {
+      throw new Error('meetingId 또는 newMeetingName 중 하나는 필수입니다.')
+    }
+    const phoneParts = parsePhone(args.phone)
+    const emailParts = parseEmail(args.email)
+
+    const json = await this.http.postJson<{ resultMsg?: string; message3?: string | null }>(
+      '/ajaxReservationConfirm.htm',
+      {
+        reservationId: args.reservationId,
+        phone: formatPhone(phoneParts),
+        ...phoneParts,
+        name: args.name,
+        pinNum: args.pinNum,
+        ...emailParts,
+        meeting_id: args.meetingId ? String(args.meetingId) : '새모임',
+        newMeetingName: args.newMeetingName ?? '',
+        prepareMemo: args.memo ?? '',
+        projectSeq: '',
+        tozApplyType: '',
+        addedInfo: '',
+        attendType: '',
+        isMobile: 'false',
+      },
+    )
+
+    const resultMsg = json.resultMsg ?? ''
+    if (!isReservationConfirmSuccess(resultMsg)) {
+      throw new Error(resultMsg || '예약 확정에 실패했습니다.')
+    }
+    return { resultMsg, isLargeBooth: resultMsg.includes('대형부스') }
+  }
+
+  async destroyHold(): Promise<void> {
+    await this.http.postText('/ajaxDestroyReservation.htm', {})
+  }
+
+  async myReservations(args: TozSearchArgs = {}): Promise<TozReservation[]> {
+    await this.http.bootstrap()
+    await this.mypageLogin(this.requireName(args.name), this.requirePhone(args.phone))
+
+    const html = await this.http.post('/mypage.htm', {
+      opage: '1',
+      rpage: '1',
+      key: '',
+      projectSeq: '',
+      tozApplyType: '',
+      addedInfo: '',
+      startdate: args.startDate ?? '',
+      enddate: args.endDate ?? '',
+      meetingName: args.meetingName ?? '',
+    })
+    return parseMypageReservations(html)
+  }
+
+  async cancel(args: TozCancelArgs): Promise<void> {
+    await this.http.bootstrap()
+    await this.mypageLogin(this.requireName(args.name), this.requirePhone(args.phone))
+
+    const result = await this.http.postText('/ajaxCancelReservation.htm', {
+      reservation_id: String(args.reservationId),
+    })
+    if (result !== 'SUCCESS') {
+      if (result === 'FAILED') throw new Error('취소하지 못했습니다.')
+      throw new Error(result || '취소하지 못했습니다.')
+    }
+  }
+
+  private requireName(name: string | undefined): string {
+    const resolved = name ?? this.identity.name
+    if (!resolved) throw new Error('Toz name is required (pass via args or TozClient({ name }))')
+    return resolved
+  }
+
+  private requirePhone(phone: string | undefined): string {
+    const resolved = phone ?? this.identity.phone
+    if (!resolved) throw new Error('Toz phone is required (pass via args or TozClient({ phone }))')
+    return resolved
+  }
+
+  private async mypageLogin(name: string, phone: string): Promise<void> {
+    const parts = parsePhone(phone)
+    await this.http.post('/mypage_login_.htm', {
+      key: '',
+      projectSeq: '',
+      tozApplyType: '',
+      addedInfo: '',
+      email: '',
+      name,
+      ...parts,
+    })
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}

package/src/toz-pending-store.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { mkdtempSync } from 'node:fs'
+import { readdir, stat } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { TozPendingStore, type TozPendingReservation } from './toz-pending-store'
+
+let configDir: string
+const cleanups: (() => void)[] = []
+
+function freshStore(): TozPendingStore {
+  configDir = mkdtempSync(join(tmpdir(), 'toz-pending-'))
+  cleanups.push(() => {
+    require('node:fs').rmSync(configDir, { recursive: true, force: true })
+  })
+  return new TozPendingStore(configDir)
+}
+
+afterEach(() => {
+  while (cleanups.length > 0) cleanups.pop()?.()
+})
+
+const sample: TozPendingReservation = {
+  reservationId: 'abc-123',
+  cookies: { JSESSIONID: 'XYZ' },
+  branchName: '토즈타워점',
+  branchTel: '02-3454-0116',
+  boothGroupName: '2인부스 A타입',
+  isLargeBooth: false,
+  date: '2026-04-21',
+  startTime: '14:00',
+  endTime: '16:00',
+  durationMinutes: 120,
+  userCount: 2,
+  boothId: 740,
+  meetingId: 2305094,
+  email: 'me@gmail.com',
+  name: '홍길동',
+  phone: '010-1234-5678',
+  createdAt: '2026-04-17T18:42:13.291Z',
+  expiresAt: '2026-04-17T18:47:13.291Z',
+}
+
+describe('TozPendingStore', () => {
+  test('returns null when no pending file exists', async () => {
+    const store = freshStore()
+    expect(await store.get()).toBeNull()
+  })
+
+  test('round-trips a reservation through set/get', async () => {
+    const store = freshStore()
+    await store.set(sample)
+    expect(await store.get()).toEqual(sample)
+  })
+
+  test('clear removes the file', async () => {
+    const store = freshStore()
+    await store.set(sample)
+    await store.clear()
+    expect(await store.get()).toBeNull()
+  })
+
+  test('clear is no-op when file does not exist', async () => {
+    const store = freshStore()
+    await store.clear()
+    expect(await store.get()).toBeNull()
+  })
+
+  test('overwrites an existing reservation', async () => {
+    const store = freshStore()
+    await store.set(sample)
+    const updated = { ...sample, reservationId: 'new-id' }
+    await store.set(updated)
+    expect(await store.get()).toEqual(updated)
+  })
+
+  test('writes file with 0o600 permissions at creation (no widened window)', async () => {
+    const store = freshStore()
+    await store.set(sample)
+    const fileStat = await stat(join(configDir, 'toz-pending.json'))
+    expect(fileStat.mode & 0o777).toBe(0o600)
+  })
+
+  test('leaves no temp file behind after set', async () => {
+    const store = freshStore()
+    await store.set(sample)
+    const entries = await readdir(configDir)
+    expect(entries).toEqual(['toz-pending.json'])
+  })
+})

package/src/toz-pending-store.ts

@@ -0,0 +1,63 @@
+import { existsSync } from 'node:fs'
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+
+import { getConfigDir } from './shared/utils/config-dir'
+
+export interface TozPendingReservation {
+  reservationId: string
+  cookies: Record<string, string>
+  branchName: string
+  branchTel: string
+  boothGroupName: string
+  isLargeBooth: boolean
+  date: string
+  startTime: string
+  endTime: string
+  durationMinutes: number
+  userCount: number
+  boothId: number
+  meetingId?: number
+  newMeetingName?: string
+  email: string
+  memo?: string
+  name: string
+  phone: string
+  createdAt: string
+  expiresAt: string
+}
+
+export class TozPendingStore {
+  private readonly path: string
+
+  constructor(configDir?: string) {
+    const dir = configDir ?? getConfigDir()
+    this.path = join(dir, 'toz-pending.json')
+  }
+
+  async get(): Promise<TozPendingReservation | null> {
+    if (!existsSync(this.path)) return null
+
+    try {
+      const raw = await readFile(this.path, 'utf8')
+      return JSON.parse(raw) as TozPendingReservation
+    } catch {
+      return null
+    }
+  }
+
+  async set(reservation: TozPendingReservation): Promise<void> {
+    const dir = dirname(this.path)
+    await mkdir(dir, { recursive: true })
+    // Write to a temp file with 0o600 from creation, then rename atomically.
+    // Avoids the default 0o644 window between writeFile() and chmod() that
+    // would briefly expose the cookie + phone number to other users on the system.
+    const tmp = `${this.path}.tmp-${process.pid}-${Date.now()}`
+    await writeFile(tmp, JSON.stringify(reservation, null, 2), { mode: 0o600 })
+    await rename(tmp, this.path)
+  }
+
+  async clear(): Promise<void> {
+    await rm(this.path, { force: true })
+  }
+}