opensoma 0.6.0 → 0.7.0

package/src/credential-manager.ts

@@ -78,8 +78,8 @@ export class CredentialManager {
 
   /**
    * Wipe ephemeral session fields (sessionCookie, csrfToken, loggedInAt) while
-   * preserving long-term re-login material (username, password). Used when the
-   * server-side session expired but we still want automatic recovery on the
+   * preserving long-term material (username, password, TOZ identity). Used when
+   * the server-side session expired but we still want automatic recovery on the
    * next run via `recoverSession()`.
    *
    * No-op when no credentials file exists or no recovery material is stored.
@@ -90,7 +90,7 @@ export class CredentialManager {
       return
     }
 
-    if (!current.username && !current.password) {
+    if (!current.username && !current.password && !current.tozName && !current.tozPhone) {
       await this.remove()
       return
     }
@@ -100,9 +100,32 @@ export class CredentialManager {
       csrfToken: '',
       username: current.username,
       password: current.password,
+      tozName: current.tozName,
+      tozPhone: current.tozPhone,
     })
   }
 
+  async setTozIdentity(name: string, phone: string): Promise<void> {
+    const existing = await this.getCredentials()
+    if (!existing) {
+      throw new Error('SWMaestro credentials not found. Run: opensoma auth login first.')
+    }
+    await this.setCredentials({ ...existing, tozName: name, tozPhone: phone })
+  }
+
+  async clearTozIdentity(): Promise<void> {
+    const existing = await this.getCredentials()
+    if (!existing) return
+    const { tozName: _name, tozPhone: _phone, ...rest } = existing
+    await this.setCredentials(rest)
+  }
+
+  async getTozIdentity(): Promise<{ name: string; phone: string } | null> {
+    const creds = await this.getCredentials()
+    if (!creds?.tozName || !creds?.tozPhone) return null
+    return { name: creds.tozName, phone: creds.tozPhone }
+  }
+
   private async hydrateCredentials(credentials: StoredCredentials): Promise<Credentials> {
     if (!credentials.encryptedPassword) {
       return credentials

package/src/index.ts

@@ -14,6 +14,19 @@ export type { UserIdentity } from './http'
 export { CredentialManager } from './credential-manager'
 export { TozHttp } from './toz-http'
 export type { TozHttpOptions, TozHttpState } from './toz-http'
+export { TozClient } from './toz-client'
+export type {
+  TozAvailabilityQuery,
+  TozCancelArgs,
+  TozCheckQuery,
+  TozCheckResult,
+  TozClientOptions,
+  TozConfirmArgs,
+  TozReserveBoothArgs,
+  TozSearchArgs,
+} from './toz-client'
+export { TozPendingStore } from './toz-pending-store'
+export type { TozPendingReservation } from './toz-pending-store'
 export * from './toz-formatters'
 export * from './types'
 export * from './constants'

package/src/session-recovery.ts

@@ -51,6 +51,8 @@ function buildRefreshedCredentials(
     csrfToken,
     username: identity.userId || credentials.username,
     password: credentials.password,
+    tozName: credentials.tozName,
+    tozPhone: credentials.tozPhone,
     loggedInAt: new Date().toISOString(),
   }
 }

package/src/toz-client.test.ts

@@ -0,0 +1,243 @@
+import { afterEach, describe, expect, mock, test } from 'bun:test'
+
+import { TOZ_BASE_URL } from './constants'
+import { TozClient } from './toz-client'
+
+const originalFetch = globalThis.fetch
+
+afterEach(() => {
+  globalThis.fetch = originalFetch
+  mock.restore()
+})
+
+function jsonResponse(body: unknown, cookies: string[] = []): Response {
+  const response = new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { 'Content-Type': 'application/json' },
+  })
+  Object.defineProperty(response.headers, 'getSetCookie', {
+    value: () => cookies,
+    configurable: true,
+  })
+  return response
+}
+
+function textResponse(body: string, cookies: string[] = []): Response {
+  const response = new Response(body, { status: 200, headers: { 'Content-Type': 'text/html' } })
+  Object.defineProperty(response.headers, 'getSetCookie', {
+    value: () => cookies,
+    configurable: true,
+  })
+  return response
+}
+
+describe('TozClient.available', () => {
+  test('builds correct AJAX payload and parses booth response', async () => {
+    const calls: { url: string; body: string }[] = []
+    globalThis.fetch = mock(async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = String(input)
+      const body = String(init?.body ?? '')
+      calls.push({ url, body })
+
+      if (url.endsWith('/index.htm')) return textResponse('ok', ['JSESSIONID=ABC'])
+      if (url.endsWith('/ajaxGetEnableBoothes.htm')) {
+        return jsonResponse([
+          {
+            resultMsg: 'SUCCESS',
+            id: 740,
+            name: '304 _ A',
+            branchName: '토즈타워점',
+            branchTel: '02-3454-0116',
+            minUseUserCount: 1,
+            enableMaxUserCount: 2,
+            boothGroupName: '2인부스 A타입',
+            boothGroupUrl: null,
+            boothMemoForUser: '15,000원',
+            isLargeBooth: false,
+          },
+        ])
+      }
+      throw new Error(`Unexpected URL: ${url}`)
+    }) as typeof fetch
+
+    const client = new TozClient()
+    const booths = await client.available({
+      date: '2026-04-21',
+      startTime: '14:00',
+      durationMinutes: 120,
+      userCount: 2,
+      branchIds: [27, 145],
+    })
+
+    expect(booths).toHaveLength(1)
+    expect(booths[0]?.id).toBe(740)
+    expect(calls[1]?.url).toBe(`${TOZ_BASE_URL}/ajaxGetEnableBoothes.htm`)
+    expect(calls[1]?.body).toBe(
+      'basedate=2026-04-21&starttime=1400&durationTime=0200&userCount=2&branchIds=27%2C145%2C',
+    )
+  })
+
+  test('throws on out-of-range duration', async () => {
+    const client = new TozClient()
+    await expect(
+      client.available({ date: '2026-04-21', startTime: '14:00', durationMinutes: 60, userCount: 2, branchIds: [27] }),
+    ).rejects.toThrow(/2h and 3h/)
+  })
+})
+
+describe('TozClient.check', () => {
+  test('rejects empty time list', async () => {
+    const client = new TozClient()
+    await expect(
+      client.check({ date: '2026-04-21', startTimes: [], durationMinutes: 120, userCount: 2, branchIds: [27] }),
+    ).rejects.toThrow(/at least one --time/)
+  })
+
+  test('rejects more than 6 times', async () => {
+    const client = new TozClient()
+    await expect(
+      client.check({
+        date: '2026-04-21',
+        startTimes: ['10:00', '11:00', '12:00', '13:00', '14:00', '15:00', '16:00'],
+        durationMinutes: 120,
+        userCount: 2,
+        branchIds: [27],
+      }),
+    ).rejects.toThrow(/Too many times/)
+  })
+
+  test('returns one result per time, captures errors per slot', async () => {
+    let call = 0
+    globalThis.fetch = mock(async (input: RequestInfo | URL) => {
+      const url = String(input)
+      if (url.endsWith('/index.htm')) return textResponse('ok', ['JSESSIONID=A'])
+      call += 1
+      if (call === 1) return jsonResponse([])
+      if (call === 2) return jsonResponse([{ resultMsg: '예약 가능한 부스가 없습니다.' }])
+      throw new Error(`Unexpected call ${call}`)
+    }) as typeof fetch
+
+    const client = new TozClient()
+    const results = await client.check({
+      date: '2026-04-21',
+      startTimes: ['10:00', '14:00'],
+      durationMinutes: 120,
+      userCount: 2,
+      branchIds: [27],
+    })
+
+    expect(results).toHaveLength(2)
+    expect(results[0]).toEqual({ startTime: '10:00', booths: [] })
+    expect(results[1]?.startTime).toBe('14:00')
+    expect(results[1]?.error).toContain('예약 가능한 부스가 없습니다.')
+  })
+
+  test('does not sleep after the last slot (single-time check is near-instant)', async () => {
+    globalThis.fetch = mock(async (input: RequestInfo | URL) => {
+      const url = String(input)
+      if (url.endsWith('/index.htm')) return textResponse('ok', ['JSESSIONID=A'])
+      return jsonResponse([])
+    }) as typeof fetch
+
+    const client = new TozClient()
+    const start = Date.now()
+    await client.check({
+      date: '2026-04-21',
+      startTimes: ['10:00'],
+      durationMinutes: 120,
+      userCount: 2,
+      branchIds: [27],
+    })
+    expect(Date.now() - start).toBeLessThan(400)
+  })
+})
+
+describe('TozClient identity fallback', () => {
+  test('uses constructor-provided name/phone when args omit them', async () => {
+    const calls: { url: string; body: string }[] = []
+    globalThis.fetch = mock(async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = String(input)
+      calls.push({ url, body: String(init?.body ?? '') })
+      if (url.endsWith('/index.htm')) return textResponse('ok', ['JSESSIONID=A'])
+      if (url.endsWith('/mypage_login_.htm')) return textResponse('ok')
+      if (url.endsWith('/mypage.htm')) return textResponse('<html></html>')
+      throw new Error(`Unexpected ${url}`)
+    }) as typeof fetch
+
+    const client = new TozClient({ name: '홍길동', phone: '010-1234-5678' })
+    await client.myReservations()
+
+    const loginCall = calls.find((c) => c.url.endsWith('/mypage_login_.htm'))
+    expect(loginCall?.body).toContain('name=%ED%99%8D%EA%B8%B8%EB%8F%99')
+    expect(loginCall?.body).toContain('phone1=010')
+    expect(loginCall?.body).toContain('phone2=1234')
+    expect(loginCall?.body).toContain('phone3=5678')
+  })
+
+  test('throws a clear error when neither args nor identity are provided', async () => {
+    const client = new TozClient()
+    await expect(client.myReservations()).rejects.toThrow(/name is required/)
+  })
+})
+
+describe('TozClient.reserveBooth', () => {
+  test('rejects large booth', async () => {
+    globalThis.fetch = mock(async (input: RequestInfo | URL) => {
+      const url = String(input)
+      if (url.endsWith('/index.htm')) return textResponse('ok', ['JSESSIONID=A'])
+      if (url.endsWith('/ajaxReservationBooth.htm')) {
+        return jsonResponse({
+          result: 'SUCCESS',
+          resultMsg: 'res-1',
+          branchName: 'X',
+          branchTel: 'tel',
+          boothGroupName: '대형부스',
+          boothIsLarge: true,
+        })
+      }
+      throw new Error(url)
+    }) as typeof fetch
+
+    const client = new TozClient()
+    await expect(
+      client.reserveBooth({ date: '2026-04-21', startTime: '14:00', durationMinutes: 120, userCount: 8, boothId: 999 }),
+    ).rejects.toThrow(/대형부스/)
+  })
+})
+
+describe('TozClient.confirm', () => {
+  test('throws on non-success message', async () => {
+    globalThis.fetch = mock(async () => jsonResponse({ resultMsg: '인증번호가 올바르지 않습니다.' })) as typeof fetch
+
+    const client = new TozClient({ sessionCookie: 'A' })
+    await expect(
+      client.confirm({
+        reservationId: 'r1',
+        date: '2026-04-21',
+        startTime: '14:00',
+        durationMinutes: 120,
+        name: '홍길동',
+        phone: '010-1234-5678',
+        email: 'me@gmail.com',
+        pinNum: '000000',
+        meetingId: 1234,
+      }),
+    ).rejects.toThrow('인증번호가 올바르지 않습니다.')
+  })
+
+  test('requires meetingId or newMeetingName', async () => {
+    const client = new TozClient({ sessionCookie: 'A' })
+    await expect(
+      client.confirm({
+        reservationId: 'r1',
+        date: '2026-04-21',
+        startTime: '14:00',
+        durationMinutes: 120,
+        name: '홍길동',
+        phone: '010-1234-5678',
+        email: 'me@gmail.com',
+        pinNum: '123456',
+      }),
+    ).rejects.toThrow(/meetingId/)
+  })
+})

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))
+}