opensoma 0.6.0 → 0.8.0

package/src/credential-manager.ts

@@ -1,9 +1,9 @@
 import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto'
 import { existsSync } from 'node:fs'
 import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
-import { homedir } from 'node:os'
 import { join } from 'node:path'
 
+import { getConfigDir } from './shared/utils/config-dir'
 import type { Credentials } from './types'
 
 interface EncryptedSecret {
@@ -26,7 +26,7 @@ export class CredentialManager {
   private encryptionKeyPath: string
 
   constructor(configDir?: string) {
-    this.configDir = configDir ?? join(homedir(), '.config', 'opensoma')
+    this.configDir = configDir ?? getConfigDir()
     this.credentialsPath = join(this.configDir, 'credentials.json')
     this.encryptionKeyPath = join(this.configDir, 'credentials.key')
   }
@@ -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/shared/utils/config-dir.test.ts

@@ -0,0 +1,41 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import { CONFIG_DIR_ENV_VAR, getConfigDir } from './config-dir'
+
+let originalValue: string | undefined
+
+beforeEach(() => {
+  originalValue = process.env[CONFIG_DIR_ENV_VAR]
+  delete process.env[CONFIG_DIR_ENV_VAR]
+})
+
+afterEach(() => {
+  if (originalValue === undefined) {
+    delete process.env[CONFIG_DIR_ENV_VAR]
+  } else {
+    process.env[CONFIG_DIR_ENV_VAR] = originalValue
+  }
+})
+
+describe('getConfigDir', () => {
+  it('falls back to ~/.config/opensoma when env var is unset', () => {
+    expect(getConfigDir()).toBe(join(homedir(), '.config', 'opensoma'))
+  })
+
+  it('returns OPENSOMA_CONFIG_DIR when set', () => {
+    process.env[CONFIG_DIR_ENV_VAR] = '/custom/config/path'
+    expect(getConfigDir()).toBe('/custom/config/path')
+  })
+
+  it('falls back to default when env var is empty string', () => {
+    process.env[CONFIG_DIR_ENV_VAR] = ''
+    expect(getConfigDir()).toBe(join(homedir(), '.config', 'opensoma'))
+  })
+
+  it('preserves relative paths verbatim', () => {
+    process.env[CONFIG_DIR_ENV_VAR] = './local-config'
+    expect(getConfigDir()).toBe('./local-config')
+  })
+})

package/src/shared/utils/config-dir.ts

@@ -0,0 +1,20 @@
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+export const CONFIG_DIR_ENV_VAR = 'OPENSOMA_CONFIG_DIR'
+
+/**
+ * Resolves the directory used to persist opensoma state (credentials, pending
+ * reservations, etc.).
+ *
+ * Resolution order:
+ *   1. `OPENSOMA_CONFIG_DIR` environment variable (if set and non-empty)
+ *   2. `~/.config/opensoma`
+ */
+export function getConfigDir(): string {
+  const fromEnv = process.env[CONFIG_DIR_ENV_VAR]
+  if (fromEnv && fromEnv.length > 0) {
+    return fromEnv
+  }
+  return join(homedir(), '.config', 'opensoma')
+}

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