opensoma 0.3.0 → 0.5.0

package/src/commands/auth.ts

@@ -1,3 +1,5 @@
+import { createInterface, type Interface as ReadlineInterface } from 'node:readline'
+
 import { Command } from 'commander'
 
 import { CredentialManager } from '../credential-manager'
@@ -7,63 +9,99 @@ import { handleError } from '../shared/utils/error-handler'
 import { formatOutput } from '../shared/utils/output'
 import type { ExtractedSessionCandidate } from '../token-extractor'
 
-async function promptInput(message: string): Promise<string> {
-  process.stdout.write(message)
-  const input = await Bun.stdin.text()
-  return input.trim()
+function ask(rl: ReadlineInterface, message: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      resolve(answer.trim())
+    })
+  })
 }
 
-async function promptPassword(message: string): Promise<string> {
+async function promptPasswordTTY(message: string): Promise<string> {
   process.stdout.write(message)
 
-  const originalStdin = process.stdin.isTTY
-    ? (process.stdin as typeof process.stdin & { setRawMode?: (mode: boolean) => void })
-    : null
-
-  if (originalStdin?.setRawMode) {
-    originalStdin.setRawMode(true)
+  const stdin = process.stdin as typeof process.stdin & { setRawMode?: (mode: boolean) => void }
+  if (stdin.setRawMode) {
+    stdin.setRawMode(true)
   }
+  stdin.resume()
 
   let password = ''
-  const decoder = new TextDecoder()
 
   try {
-    for await (const chunk of Bun.stdin.stream()) {
-      const text = decoder.decode(chunk)
-      for (const char of text) {
-        const code = char.charCodeAt(0)
-        if (code === 13 || code === 10) {
-          // Enter key
-          process.stdout.write('\n')
-          return password
-        } else if (code === 3) {
-          // Ctrl+C
-          process.exit(1)
-        } else if (code === 127) {
-          // Backspace
-          if (password.length > 0) {
-            password = password.slice(0, -1)
-            process.stdout.write('\b \b')
+    return await new Promise<string>((resolve) => {
+      const onData = (chunk: Buffer | string): void => {
+        const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8')
+        for (const char of text) {
+          const code = char.charCodeAt(0)
+          if (code === 13 || code === 10) {
+            // Enter key
+            stdin.removeListener('data', onData)
+            process.stdout.write('\n')
+            resolve(password)
+            return
+          } else if (code === 3) {
+            // Ctrl+C
+            stdin.removeListener('data', onData)
+            process.exit(1)
+          } else if (code === 127 || code === 8) {
+            // Backspace / Delete
+            if (password.length > 0) {
+              password = password.slice(0, -1)
+              process.stdout.write('\b \b')
+            }
+          } else if (code >= 32 && code <= 126) {
+            // Printable characters
+            password += char
+            process.stdout.write('*')
           }
-        } else if (code >= 32 && code <= 126) {
-          // Printable characters
-          password += char
-          process.stdout.write('*')
         }
       }
-    }
+
+      stdin.on('data', onData)
+    })
   } finally {
-    if (originalStdin?.setRawMode) {
-      originalStdin.setRawMode(false)
+    if (stdin.setRawMode) {
+      stdin.setRawMode(false)
     }
+    stdin.pause()
   }
+}
+
+async function promptCredentials(
+  needUsername: boolean,
+  needPassword: boolean,
+): Promise<{ username?: string; password?: string }> {
+  const result: { username?: string; password?: string } = {}
 
-  return password
+  if (needUsername) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false })
+    try {
+      result.username = await ask(rl, 'Username: ')
+    } finally {
+      rl.close()
+    }
+  }
+
+  if (needPassword) {
+    if (process.stdin.isTTY) {
+      result.password = await promptPasswordTTY('Password: ')
+    } else {
+      const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false })
+      try {
+        result.password = await ask(rl, 'Password: ')
+      } finally {
+        rl.close()
+      }
+    }
+  }
+
+  return result
 }
 
 type LoginOptions = { username?: string; password?: string; pretty?: boolean }
 type StatusOptions = { pretty?: boolean }
-type ExtractOptions = { pretty?: boolean }
+type ExtractOptions = { debug?: boolean; pretty?: boolean }
 type ExtractedSessionValidator = Pick<SomaHttp, 'checkLogin' | 'extractCsrfToken'>
 type CredentialStore = Pick<CredentialManager, 'getCredentials' | 'remove' | 'setCredentials'>
 type StatusValidator = Pick<SomaHttp, 'checkLogin'>
@@ -87,21 +125,34 @@ export async function resolveExtractedCredentials(
   candidates: ExtractedSessionCandidate[],
   createValidator: (sessionCookie: string) => ExtractedSessionValidator = (sessionCookie) =>
     new SomaHttp({ sessionCookie }),
+  debug?: (message: string) => void,
 ): Promise<{ csrfToken: string; sessionCookie: string } | null> {
+  debug?.(`Validating ${candidates.length} candidate(s) against server...`)
+
   for (const candidate of candidates) {
     const http = createValidator(candidate.sessionCookie)
+    debug?.(`  ${candidate.browser} / ${candidate.profile}: checkLogin...`)
 
     try {
       const valid = Boolean(await http.checkLogin())
       if (!valid) {
+        debug?.(`  ${candidate.browser} / ${candidate.profile}: session invalid`)
         continue
       }
 
+      debug?.(`  ${candidate.browser} / ${candidate.profile}: valid! Extracting CSRF token...`)
+      const csrfToken = await http.extractCsrfToken()
+      debug?.(`  CSRF token obtained (${csrfToken.length} chars)`)
+
       return {
         sessionCookie: candidate.sessionCookie,
-        csrfToken: await http.extractCsrfToken(),
+        csrfToken,
       }
-    } catch {}
+    } catch (error) {
+      debug?.(
+        `  ${candidate.browser} / ${candidate.profile}: error: ${error instanceof Error ? error.message : String(error)}`,
+      )
+    }
   }
 
   return null
@@ -112,12 +163,9 @@ async function loginAction(options: LoginOptions): Promise<void> {
     let username = options.username ?? process.env.OPENSOMA_USERNAME
     let password = options.password ?? process.env.OPENSOMA_PASSWORD
 
-    if (!username) {
-      username = await promptInput('Username: ')
-    }
-    if (!password) {
-      password = await promptPassword('Password: ')
-    }
+    const prompted = await promptCredentials(!username, !password)
+    username ??= prompted.username
+    password ??= prompted.password
 
     if (!username || !password) {
       throw new Error('Username and password are required')
@@ -264,22 +312,30 @@ async function statusAction(options: StatusOptions): Promise<void> {
 }
 
 async function extractAction(options: ExtractOptions): Promise<void> {
+  const log = options.debug ? (message: string) => process.stderr.write(`[extract] ${message}\n`) : undefined
+
   try {
     const { TokenExtractor } = (await import('../token-extractor')) as {
-      TokenExtractor: new () => { extractCandidates: () => Promise<ExtractedSessionCandidate[]> }
+      TokenExtractor: new (options?: { debug?: boolean }) => {
+        extractCandidates: () => Promise<ExtractedSessionCandidate[]>
+      }
     }
-    const extractor = new TokenExtractor()
+    const extractor = new TokenExtractor({ debug: options.debug })
     const candidates = await extractor.extractCandidates()
     if (candidates.length === 0) {
       throw new Error(
-        'No SWMaestro session found in any browser. Login to swmaestro.ai in a supported Chromium browser (Chrome, Edge, Brave, Arc, Vivaldi) first.',
+        'No SWMaestro session found in any browser. Login to swmaestro.ai or opensoma.dev in a supported Chromium browser (Chrome, Edge, Brave, Arc, Vivaldi) first.',
       )
     }
 
-    const credentials = await resolveExtractedCredentials(candidates)
+    log?.(
+      `Extracted ${candidates.length} candidate(s): ${candidates.map((c) => `${c.browser}/${c.profile}`).join(', ')}`,
+    )
+
+    const credentials = await resolveExtractedCredentials(candidates, undefined, log)
     if (!credentials) {
       throw new Error(
-        'Found SWMaestro session cookies in supported browsers, but none are valid. Refresh your swmaestro.ai login in a supported Chromium browser and try again.',
+        'Found SWMaestro session cookies in supported browsers, but none are valid. Refresh your swmaestro.ai or opensoma.dev login in a supported Chromium browser and try again.',
       )
     }
 
@@ -319,6 +375,7 @@ export const authCommand = new Command('auth')
   .addCommand(
     new Command('extract')
       .description('Extract browser credentials')
+      .option('--debug', 'Show debug output')
       .option('--pretty', 'Pretty print JSON output')
       .action(extractAction),
   )

package/src/commands/mentoring.ts

@@ -11,6 +11,7 @@ import {
   buildDeleteMentoringPayload,
   buildMentoringPayload,
   buildUpdateMentoringPayload,
+  toMentoringType,
 } from '../shared/utils/swmaestro'
 import { getHttpOrExit } from './helpers'
 
@@ -36,12 +37,12 @@ type CreateOptions = {
   pretty?: boolean
 }
 type UpdateOptions = {
-  title: string
-  type: 'public' | 'lecture'
-  date: string
-  start: string
-  end: string
-  venue: string
+  title?: string
+  type?: 'public' | 'lecture'
+  date?: string
+  start?: string
+  end?: string
+  venue?: string
   maxAttendees?: string
   regStart?: string
   regEnd?: string
@@ -96,7 +97,7 @@ async function getAction(id: string, options: GetOptions): Promise<void> {
 async function createAction(options: CreateOptions): Promise<void> {
   try {
     const http = await getHttpOrExit()
-    await http.post(
+    await http.postForm(
       '/mypage/mentoLec/insert.do',
       buildMentoringPayload({
         title: options.title,
@@ -120,19 +121,26 @@ async function createAction(options: CreateOptions): Promise<void> {
 async function updateAction(id: string, options: UpdateOptions): Promise<void> {
   try {
     const http = await getHttpOrExit()
-    await http.post(
+    const numId = Number.parseInt(id, 10)
+    const html = await http.get('/mypage/mentoLec/view.do', {
+      menuNo: MENU_NO.MENTORING,
+      qustnrSn: id,
+    })
+    const existing = formatters.parseMentoringDetail(html, numId)
+
+    await http.postForm(
       '/mypage/mentoLec/update.do',
-      buildUpdateMentoringPayload(Number.parseInt(id, 10), {
-        title: options.title,
-        type: options.type,
-        date: options.date,
-        startTime: options.start,
-        endTime: options.end,
-        venue: options.venue,
-        maxAttendees: options.maxAttendees ? Number.parseInt(options.maxAttendees, 10) : undefined,
-        regStart: options.regStart,
-        regEnd: options.regEnd,
-        content: options.content,
+      buildUpdateMentoringPayload(numId, {
+        title: options.title ?? existing.title,
+        type: options.type ?? toMentoringType(existing.type),
+        date: options.date ?? existing.sessionDate,
+        startTime: options.start ?? existing.sessionTime.start,
+        endTime: options.end ?? existing.sessionTime.end,
+        venue: options.venue ?? existing.venue,
+        maxAttendees: options.maxAttendees ? Number.parseInt(options.maxAttendees, 10) : existing.attendees.max,
+        regStart: options.regStart ?? existing.registrationPeriod.start,
+        regEnd: options.regEnd ?? existing.registrationPeriod.end,
+        content: options.content ?? existing.content,
       }),
     )
     console.log(formatOutput({ ok: true }, options.pretty))
@@ -235,14 +243,14 @@ export const mentoringCommand = new Command('mentoring')
   )
   .addCommand(
     new Command('update')
-      .description('Update a mentoring session')
+      .description('Update a mentoring session (partial update - only specified fields are changed)')
       .argument('<id>')
-      .requiredOption('--title <title>', 'Title')
-      .requiredOption('--type <type>', 'Mentoring type (public|lecture)')
-      .requiredOption('--date <date>', 'Session date')
-      .requiredOption('--start <time>', 'Start time')
-      .requiredOption('--end <time>', 'End time')
-      .requiredOption('--venue <venue>', 'Venue')
+      .option('--title <title>', 'Title')
+      .option('--type <type>', 'Mentoring type (public|lecture)')
+      .option('--date <date>', 'Session date')
+      .option('--start <time>', 'Start time')
+      .option('--end <time>', 'End time')
+      .option('--venue <venue>', 'Venue')
       .option('--max-attendees <count>', 'Maximum attendees')
       .option('--reg-start <date>', 'Registration start date')
       .option('--reg-end <date>', 'Registration end date')

package/src/commands/room.ts

@@ -6,7 +6,7 @@ import { formatOutput } from '../shared/utils/output'
 import { buildRoomReservationPayload, resolveRoomId } from '../shared/utils/swmaestro'
 import { getHttpOrExit } from './helpers'
 
-type ListOptions = { date?: string; room?: string; pretty?: boolean }
+type ListOptions = { date?: string; room?: string; reservations?: boolean; pretty?: boolean }
 type AvailableOptions = { date: string; pretty?: boolean }
 type ReserveOptions = {
   room: string
@@ -21,12 +21,39 @@ type ReserveOptions = {
 async function listAction(options: ListOptions): Promise<void> {
   try {
     const http = await getHttpOrExit()
+    const date = options.date ?? new Date().toISOString().slice(0, 10)
     const html = await http.post('/mypage/officeMng/list.do', {
       menuNo: '200058',
-      sdate: options.date ?? new Date().toISOString().slice(0, 10),
+      sdate: date,
       searchItemId: options.room ? String(resolveRoomId(options.room)) : '',
     })
-    console.log(formatOutput(formatters.parseRoomList(html), options.pretty))
+    const rooms = formatters.parseRoomList(html)
+
+    if (!options.reservations) {
+      console.log(formatOutput(rooms, options.pretty))
+      return
+    }
+
+    const enrichedRooms = await Promise.all(
+      rooms.map(async (room) => {
+        try {
+          const detailHtml = await http.post('/mypage/officeMng/rentTime.do', {
+            viewType: 'CONTBODY',
+            itemId: String(room.itemId),
+            rentDt: date,
+          })
+
+          return {
+            ...room,
+            timeSlots: formatters.parseRoomSlots(detailHtml),
+          }
+        } catch {
+          return room
+        }
+      }),
+    )
+
+    console.log(formatOutput(enrichedRooms, options.pretty))
   } catch (error) {
     handleError(error)
   }
@@ -76,6 +103,7 @@ export const roomCommand = new Command('room')
       .description('List rooms')
       .option('--date <date>', 'Reservation date')
       .option('--room <room>', 'Room filter')
+      .option('--reservations', 'Include reservation info in time slots')
       .option('--pretty', 'Pretty print JSON output')
       .action(listAction),
   )

package/src/constants.ts

@@ -26,15 +26,15 @@ export const ROOM_IDS: Record<string, number> = {
 }
 
 export const VENUES = {
-  TOZ_GWANGHWAMUN: '광화문점',
-  TOZ_YANGJAE: '양재점',
-  TOZ_GANGNAM_CONFERENCE_CENTER: '강남컨퍼런스센터점',
-  TOZ_KONKUK: '건대점',
-  TOZ_GANGNAM_TOWER: '강남역토즈타워점',
-  TOZ_SEOLLEUNG: '선릉점',
-  TOZ_YEOKSAM: '역삼점',
-  TOZ_HONGDAE: '홍대점',
-  TOZ_SINCHON_BUSINESS_CENTER: '신촌비즈니스센터점',
+  TOZ_GWANGHWAMUN: '토즈-광화문점',
+  TOZ_YANGJAE: '토즈-양재점',
+  TOZ_GANGNAM_CONFERENCE_CENTER: '토즈-강남컨퍼런스센터점',
+  TOZ_KONKUK: '토즈-건대점',
+  TOZ_GANGNAM_TOWER: '토즈-강남역토즈타워점',
+  TOZ_SEOLLEUNG: '토즈-선릉점',
+  TOZ_YEOKSAM: '토즈-역삼점',
+  TOZ_HONGDAE: '토즈-홍대점',
+  TOZ_SINCHON_BUSINESS_CENTER: '토즈-신촌비즈니스센터점',
   ONLINE_WEBEX: '온라인(Webex)',
   SPACE_A1: '스페이스 A1',
   SPACE_A2: '스페이스 A2',
@@ -47,8 +47,23 @@ export const VENUES = {
   SPACE_M1: '스페이스 M1',
   SPACE_M2: '스페이스 M2',
   SPACE_S: '스페이스 S',
+  EXPERT_LOUNGE: '(엑스퍼트) 연수센터_라운지',
+  EXPERT_CAFE: '(엑스퍼트) 외부_카페',
 } as const
 
+export const VENUE_ALIASES: Record<string, string> = {
+  광화문점: '토즈-광화문점',
+  양재점: '토즈-양재점',
+  강남컨퍼런스센터점: '토즈-강남컨퍼런스센터점',
+  건대점: '토즈-건대점',
+  강남역토즈타워점: '토즈-강남역토즈타워점',
+  선릉점: '토즈-선릉점',
+  역삼점: '토즈-역삼점',
+  홍대점: '토즈-홍대점',
+  신촌비즈니스센터점: '연수센터-7',
+  '토즈-신촌비즈니스센터점': '연수센터-7',
+}
+
 export const REPORT_CD = {
   PUBLIC_MENTORING: 'MRC010',
   MENTOR_LECTURE: 'MRC020',
@@ -70,3 +85,53 @@ function createTimeSlots(): string[] {
 function formatTime(hour: number, minute: number): string {
   return `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`
 }
+
+export const TOZ_BASE_URL = 'http://partner.toz.co.kr/partner/reservation/fkii3/swmaestro'
+export const TOZ_PARTNER = 'fkii3'
+export const TOZ_COMPANY = 'swmaestro'
+export const TOZ_MEMBER_COMPANY_ID = '25408'
+
+// Static fallback list extracted from booking.htm. Use TozClient.branches() at runtime
+// to fetch the live list — the SW마에스트로 partnership branch set may change.
+export const TOZ_BRANCHES = [
+  { 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: '홍대점' },
+] as const
+
+export const TOZ_PHONE_PREFIXES = ['010', '011', '016', '017', '018', '019'] as const
+
+export const TOZ_EMAIL_DOMAINS = [
+  'hanmail.net',
+  'gmail.com',
+  'nate.com',
+  'naver.com',
+  'daum.net',
+  'dreamwiz.com',
+  'yahoo.com',
+  'yahoo.co.kr',
+  'msn.com',
+  'paran.com',
+  'korea.com',
+  'freechal.com',
+  'lycos.co.kr',
+  'msn.co.kr',
+  'empal.com',
+  'hotmail.com',
+] as const
+
+export const TOZ_EMAIL_DOMAIN_CUSTOM = '직접입력'
+
+export const TOZ_NEW_MEETING_VALUE = '새모임'
+
+export const TOZ_MIN_DURATION_MINUTES = 120
+export const TOZ_MAX_DURATION_MINUTES = 180
+export const TOZ_SESSION_HOLD_SECONDS = 300
+
+export const TOZ_MAX_CHECK_TIMES = 6

package/src/formatters.test.ts

@@ -214,14 +214,18 @@ describe('formatters', () => {
       <input type="hidden" name="chkData_1" value="09:00" />
       <span class="ck-st2 disabled" data-hour="12" data-minute="00">
         <input type="checkbox" name="time" id="time1_7" value="7" disabled="disabled">
-        <label for="time1_7">PM 12:00</label>
+        <label for="time1_7" title="점심 회의&lt;br&gt;예약자 : 김오픈">PM 12:00</label>
       </span>
       <input type="hidden" name="chkData_7" value="12:00" />
     `
 
     expect(parseRoomSlots(html)).toEqual([
       { time: '09:00', available: true },
-      { time: '12:00', available: false },
+      {
+        time: '12:00',
+        available: false,
+        reservation: { title: '점심 회의', bookedBy: '김오픈' },
+      },
     ])
   })