opensoma 0.5.0 → 0.6.0

package/src/client.ts

@@ -12,19 +12,20 @@ import {
   buildDeleteMentoringPayload,
   buildMentoringPayload,
   buildReportPayload,
+  buildRoomCancelPayload,
   buildRoomReservationPayload,
+  buildRoomUpdatePayload,
   buildUpdateMentoringPayload,
-  parseEventDetail,
   resolveRoomId,
-  toMentoringType,
   toRegionCode,
   toReportTypeCd,
 } from './shared/utils/swmaestro'
+import { buildTeamActionPayload } from './shared/utils/team-action-params'
+import { buildTeamListParams, type TeamSearchQuery } from './shared/utils/team-params'
 import type {
   ApplicationHistoryItem,
   ApprovalListItem,
   Dashboard,
-  EventListItem,
   MemberInfo,
   MentoringDetail,
   MentoringListItem,
@@ -37,6 +38,11 @@ import type {
   ReportListItem,
   ReportUpdateOptions,
   RoomCard,
+  RoomReservationDetail,
+  RoomReservationListItem,
+  RoomReservationStatus,
+  RoomUpdateOptions,
+  ScheduleListItem,
   TeamInfo,
 } from './types'
 
@@ -46,12 +52,16 @@ export interface SomaClientOptions {
   username?: string
   password?: string
   verbose?: boolean
+  /** @internal */
+  http?: SomaHttp
 }
 
 export class SomaClient {
   private readonly http: SomaHttp
   private readonly options: SomaClientOptions
   private loginCredentials: { username: string; password: string } | null
+  // Single-flight guard: SWMaestro kills a session if it sees parallel logins for it.
+  private reloginInFlight: Promise<void> | null = null
 
   readonly mentoring: {
     list(options?: {
@@ -69,8 +79,11 @@ export class SomaClient {
       endTime: string
       venue: string
       maxAttendees?: number
+      receiptType?: 'UNTIL_LECTURE' | 'DIRECT'
       regStart?: string
+      regStartTime?: string
       regEnd?: string
+      regEndTime?: string
       content?: string
     }): Promise<void>
     update(id: number, params: MentoringUpdateOptions): Promise<void>
@@ -91,6 +104,15 @@ export class SomaClient {
       attendees?: number
       notes?: string
     }): Promise<void>
+    get(rentId: number): Promise<RoomReservationDetail>
+    update(rentId: number, params?: RoomUpdateOptions): Promise<void>
+    cancel(rentId: number): Promise<void>
+    reservations(options?: {
+      status?: Exclude<RoomReservationStatus, 'unknown'> | 'all'
+      startDate?: string
+      endDate?: string
+      page?: number
+    }): Promise<{ items: RoomReservationListItem[]; pagination: Pagination }>
   }
 
   readonly dashboard: {
@@ -109,7 +131,7 @@ export class SomaClient {
       searchKeyword?: string
     }): Promise<{ items: ReportListItem[]; pagination: Pagination }>
     get(id: number): Promise<ReportDetail>
-    create(options: ReportCreateOptions, file: Buffer | string, fileName?: string): Promise<void>
+    create(options: ReportCreateOptions, files: Array<{ buffer: Buffer; name: string }>): Promise<void>
     update(
       id: number,
       options: Omit<ReportUpdateOptions, 'id'>,
@@ -124,28 +146,30 @@ export class SomaClient {
   }
 
   readonly team: {
-    show(): Promise<TeamInfo>
+    list(options?: { search?: TeamSearchQuery }): Promise<TeamInfo>
+    join(teamId: string): Promise<void>
+    leave(teamId: string): Promise<void>
   }
 
   readonly member: {
     show(): Promise<MemberInfo>
   }
 
-  readonly event: {
-    list(options?: { page?: number }): Promise<{ items: EventListItem[]; pagination: Pagination }>
-    get(id: number): Promise<unknown>
-    apply(id: number): Promise<void>
+  readonly schedule: {
+    list(options?: { page?: number }): Promise<{ items: ScheduleListItem[]; pagination: Pagination }>
   }
 
   constructor(options: SomaClientOptions = {}) {
     this.options = options
     this.loginCredentials =
       options.username && options.password ? { username: options.username, password: options.password } : null
-    this.http = new SomaHttp({
-      sessionCookie: options.sessionCookie,
-      csrfToken: options.csrfToken,
-      verbose: options.verbose,
-    })
+    this.http =
+      options.http ??
+      new SomaHttp({
+        sessionCookie: options.sessionCookie,
+        csrfToken: options.csrfToken,
+        verbose: options.verbose,
+      })
 
     this.mentoring = {
       list: async (options) => {
@@ -161,9 +185,10 @@ export class SomaClient {
             user,
           }),
         )
+        const items = formatters.parseMentoringList(html)
         return {
-          items: formatters.parseMentoringList(html),
-          pagination: formatters.parsePagination(html),
+          items,
+          pagination: formatters.parsePagination(html, { itemCount: items.length }),
         }
       },
       get: async (id) => {
@@ -185,18 +210,27 @@ export class SomaClient {
       },
       update: async (id, params) => {
         await this.requireAuth()
-        const existing = await this.mentoring.get(id)
+        const [editHtml, viewHtml] = await Promise.all([
+          this.http.get('/mypage/mentoLec/forUpdate.do', { menuNo: MENU_NO.MENTORING, qustnrSn: String(id) }),
+          this.http.get('/mypage/mentoLec/view.do', { menuNo: MENU_NO.MENTORING, qustnrSn: String(id) }),
+        ])
+        const existing = formatters.parseMentoringEditForm(editHtml, id)
+        const existingContent = formatters.parseMentoringDetail(viewHtml, id).content
+
         const merged = buildUpdateMentoringPayload(id, {
           title: params.title ?? existing.title,
-          type: params.type ?? toMentoringType(existing.type),
-          date: params.date ?? existing.sessionDate,
-          startTime: params.startTime ?? existing.sessionTime.start,
-          endTime: params.endTime ?? existing.sessionTime.end,
-          venue: params.venue ?? existing.venue,
-          maxAttendees: params.maxAttendees ?? existing.attendees.max,
-          regStart: params.regStart ?? existing.registrationPeriod.start,
-          regEnd: params.regEnd ?? existing.registrationPeriod.end,
-          content: params.content ?? existing.content,
+          type: params.type ?? (existing.reportCd === 'MRC020' ? 'lecture' : 'public'),
+          date: params.date ?? existing.eventDt,
+          startTime: params.startTime ?? existing.eventStime,
+          endTime: params.endTime ?? existing.eventEtime,
+          venue: params.venue ?? existing.place,
+          maxAttendees: params.maxAttendees ?? existing.applyCnt,
+          receiptType: params.receiptType ?? existing.receiptType,
+          regStart: params.regStart ?? existing.bgndeDate,
+          regStartTime: params.regStartTime ?? existing.bgndeTime,
+          regEnd: params.regEnd ?? existing.enddeDate,
+          regEndTime: params.regEndTime ?? existing.enddeTime,
+          content: params.content ?? existingContent,
         })
         const html = await this.http.postForm('/mypage/mentoLec/update.do', merged)
         if (this.containsErrorIndicator(html)) {
@@ -221,9 +255,10 @@ export class SomaClient {
           menuNo: MENU_NO.APPLICATION_HISTORY,
           ...(options?.page ? { pageIndex: String(options.page) } : {}),
         })
+        const items = formatters.parseApplicationHistory(html)
         return {
-          items: formatters.parseApplicationHistory(html),
-          pagination: formatters.parsePagination(html),
+          items,
+          pagination: formatters.parsePagination(html, { itemCount: items.length }),
         }
       },
     }
@@ -275,24 +310,98 @@ export class SomaClient {
         await this.requireAuth()
         await this.http.post('/mypage/itemRent/insert.do', buildRoomReservationPayload(params))
       },
+      get: async (rentId) => {
+        await this.requireAuth()
+        return formatters.parseRoomReservationDetail(
+          await this.http.get('/mypage/itemRent/view.do', {
+            menuNo: MENU_NO.ROOM,
+            rentId: String(rentId),
+          }),
+        )
+      },
+      update: async (rentId, params = {}) => {
+        await this.requireAuth()
+        const existing = await this.room.get(rentId)
+        await this.postRoomUpdate(buildRoomUpdatePayload(existing, params))
+      },
+      cancel: async (rentId) => {
+        await this.requireAuth()
+        const existing = await this.room.get(rentId)
+        await this.postRoomUpdate(buildRoomCancelPayload(existing))
+      },
+      reservations: async (options) => {
+        await this.requireAuth()
+        const params: Record<string, string> = {
+          menuNo: MENU_NO.ROOM,
+          pageIndex: String(options?.page ?? 1),
+        }
+        if (options?.startDate) params.sdate = options.startDate
+        if (options?.endDate) params.edate = options.endDate
+        const status = options?.status ?? 'confirmed'
+        if (status !== 'all') {
+          params.searchStat = status === 'cancelled' ? 'RS002' : 'RS001'
+        }
+        const html = await this.http.get('/mypage/itemRent/list.do', params)
+        const items = formatters.parseRoomReservationList(html)
+        return {
+          items,
+          pagination: formatters.parsePagination(html, { itemCount: items.length }),
+        }
+      },
     }
 
     this.dashboard = {
       get: async () => {
         await this.requireAuth()
-        const [dashboard, { items: myMentoring }] = await Promise.all([
-          formatters.parseDashboard(await this.http.get('/mypage/myMain/dashboard.do', { menuNo: MENU_NO.DASHBOARD })),
-          this.mentoring.list({ search: { field: 'author', value: '@me', me: true } }),
+        const dashboard = formatters.parseDashboard(
+          await this.http.get('/mypage/myMain/dashboard.do', { menuNo: MENU_NO.DASHBOARD }),
+        )
+        const trainee = isTraineeRole(dashboard.role)
+        const teamSearchField = trainee ? ('member' as const) : ('mentor' as const)
+        if (trainee) {
+          const [firstPage, teams] = await Promise.all([
+            this.mentoring.history(),
+            this.team.list({ search: { field: teamSearchField, value: '@me', me: true } }),
+          ])
+          const remainingPages = await Promise.all(
+            Array.from({ length: Math.max(0, firstPage.pagination.totalPages - 1) }, (_, i) =>
+              this.mentoring.history({ page: i + 2 }),
+            ),
+          )
+          const historyItems = [firstPage, ...remainingPages].flatMap((p) => p.items)
+          dashboard.mentoringSessions = sortDashboardMentoringItems(
+            historyItems
+              .map(applicationHistoryToDashboardItem)
+              .filter((item): item is Dashboard['mentoringSessions'][number] => item !== null),
+          )
+          dashboard.teams = teams.teams
+          return dashboard
+        }
+
+        const search = { field: 'author' as const, value: '@me', me: true }
+        const [firstPage, teams] = await Promise.all([
+          this.mentoring.list({ search }),
+          this.team.list({ search: { field: teamSearchField, value: '@me', me: true } }),
         ])
-        dashboard.mentoringSessions = myMentoring.map((item) => ({
-          title: item.title,
-          url: `/mypage/mentoLec/view.do?qustnrSn=${item.id}`,
-          status: item.status,
-          date: item.sessionDate,
-          time: item.sessionTime.start,
-          timeEnd: item.sessionTime.end,
-          type: item.type,
-        }))
+        // Exhaust pagination: dashboard time totals must span the whole month, not just page 1.
+        const remainingPages = await Promise.all(
+          Array.from({ length: Math.max(0, firstPage.pagination.totalPages - 1) }, (_, i) =>
+            this.mentoring.list({ search, page: i + 2 }),
+          ),
+        )
+        const myMentoring = [firstPage, ...remainingPages].flatMap((p) => p.items)
+        dashboard.mentoringSessions = sortDashboardMentoringItems(
+          myMentoring.map((item) => ({
+            title: item.title,
+            url: `/mypage/mentoLec/view.do?qustnrSn=${item.id}`,
+            status: item.status,
+            date: item.sessionDate,
+            time: item.sessionTime.start,
+            timeEnd: item.sessionTime.end,
+            type: item.type,
+          })),
+        )
+        dashboard.teams = teams.teams
         return dashboard
       },
     }
@@ -304,9 +413,10 @@ export class SomaClient {
           menuNo: MENU_NO.NOTICE,
           ...(options?.page ? { pageIndex: String(options.page) } : {}),
         })
+        const items = formatters.parseNoticeList(html)
         return {
-          items: formatters.parseNoticeList(html),
-          pagination: formatters.parsePagination(html),
+          items,
+          pagination: formatters.parsePagination(html, { itemCount: items.length }),
         }
       },
       get: async (id) => {
@@ -331,9 +441,10 @@ export class SomaClient {
         if (options?.searchField !== undefined) params.searchCnd = options.searchField
         if (options?.searchKeyword) params.searchWrd = options.searchKeyword
         const html = await this.http.get('/mypage/mentoringReport/list.do', params)
+        const items = formatters.parseReportList(html)
         return {
-          items: formatters.parseReportList(html),
-          pagination: formatters.parsePagination(html),
+          items,
+          pagination: formatters.parsePagination(html, { itemCount: items.length }),
         }
       },
       get: async (id) => {
@@ -344,7 +455,7 @@ export class SomaClient {
         })
         return formatters.parseReportDetail(html, id)
       },
-      create: async (options, file, fileName) => {
+      create: async (options, files) => {
         await this.requireAuth()
         const payload = buildReportPayload({
           menteeRegion: options.menteeRegion,
@@ -369,11 +480,11 @@ export class SomaClient {
         for (const [key, value] of Object.entries(payload)) {
           formData.append(key, value)
         }
-        const isBuffer = Buffer.isBuffer(file)
-        const fileBuffer = isBuffer ? file : await readFile(file)
-        const resolvedFileName = isBuffer ? (fileName ?? 'file') : (file.split('/').pop() ?? 'file')
-        const uint8Array = new Uint8Array(fileBuffer.buffer, fileBuffer.byteOffset, fileBuffer.byteLength)
-        formData.append('file_1_1', new Blob([uint8Array as unknown as ArrayBuffer]), resolvedFileName)
+        for (let i = 0; i < files.length; i++) {
+          const { buffer, name } = files[i]
+          const uint8Array = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+          formData.append(`file_1_${i + 1}`, new Blob([uint8Array as unknown as ArrayBuffer]), name)
+        }
         formData.append('fileFieldNm_1', 'file_1')
         formData.append('atchFileId', '')
         await this.http.postMultipart('/mypage/mentoringReport/insert.do', formData)
@@ -425,17 +536,27 @@ export class SomaClient {
         if (options?.month) params.searchMonth = options.month
         if (options?.reportType !== undefined) params.searchReport = options.reportType
         const html = await this.http.get('/mypage/mentoringReport/resultList.do', params)
+        const items = formatters.parseApprovalList(html)
         return {
-          items: formatters.parseApprovalList(html),
-          pagination: formatters.parsePagination(html),
+          items,
+          pagination: formatters.parsePagination(html, { itemCount: items.length }),
         }
       },
     }
 
     this.team = {
-      show: async () => {
+      list: async (options) => {
         await this.requireAuth()
-        return formatters.parseTeamInfo(await this.http.get('/mypage/myTeam/team.do', { menuNo: MENU_NO.TEAM }))
+        const user = options?.search?.me ? await this.resolveUser() : undefined
+        return formatters.parseTeamInfo(
+          await this.http.get('/mypage/myTeam/team.do', buildTeamListParams({ search: options?.search, user })),
+        )
+      },
+      join: async (teamId) => {
+        await this.postTeamAction('/mypage/myTeam/updateUserTeamIn.json', teamId, '팀 참여에 실패했습니다.')
+      },
+      leave: async (teamId) => {
+        await this.postTeamAction('/mypage/myTeam/updateUserTeamOut.json', teamId, '팀 탈퇴에 실패했습니다.')
       },
     }
 
@@ -448,30 +569,14 @@ export class SomaClient {
       },
     }
 
-    this.event = {
+    this.schedule = {
       list: async (options) => {
         await this.requireAuth()
-        const html = await this.http.get('/mypage/applicants/list.do', {
-          menuNo: MENU_NO.EVENT,
+        const html = await this.http.get('/mypage/schedule/list.do', {
+          menuNo: MENU_NO.SCHEDULE,
           ...(options?.page ? { pageIndex: String(options.page) } : {}),
         })
-        return {
-          items: formatters.parseEventList(html),
-          pagination: formatters.parsePagination(html),
-        }
-      },
-      get: async (id) => {
-        await this.requireAuth()
-        return parseEventDetail(
-          await this.http.get('/mypage/applicants/view.do', {
-            menuNo: MENU_NO.EVENT,
-            bbsId: String(id),
-          }),
-        )
-      },
-      apply: async (id) => {
-        await this.requireAuth()
-        await this.http.post('/application/application/application.do', buildApplicationPayload(id))
+        return formatters.parseScheduleList(html)
       },
     }
   }
@@ -486,7 +591,7 @@ export class SomaClient {
   private async requireAuth(): Promise<void> {
     let identity = await this.http.checkLogin()
     if (!identity && this.loginCredentials) {
-      await this.http.login(this.loginCredentials.username, this.loginCredentials.password)
+      await this.relogin()
       identity = await this.http.checkLogin()
     }
 
@@ -495,6 +600,19 @@ export class SomaClient {
     }
   }
 
+  private async relogin(): Promise<void> {
+    if (!this.loginCredentials) {
+      throw new AuthenticationError()
+    }
+    if (!this.reloginInFlight) {
+      const { username, password } = this.loginCredentials
+      this.reloginInFlight = this.http.login(username, password).finally(() => {
+        this.reloginInFlight = null
+      })
+    }
+    await this.reloginInFlight
+  }
+
   private async resolveUser(): Promise<UserIdentity | undefined> {
     const identity = await this.http.checkLogin()
     return identity ?? undefined
@@ -519,6 +637,10 @@ export class SomaClient {
     return Boolean(await this.http.checkLogin())
   }
 
+  async whoami(): Promise<UserIdentity | null> {
+    return this.http.checkLogin()
+  }
+
   async logout(): Promise<void> {
     await this.http.logout()
   }
@@ -540,6 +662,30 @@ export class SomaClient {
     })
   }
 
+  private async postTeamAction(path: string, teamId: string, fallbackMessage: string): Promise<void> {
+    await this.requireAuth()
+    const user = await this.resolveUser()
+    if (!user) throw new AuthenticationError()
+    if (!user.userNo) {
+      throw new Error('현재 사용자의 userNo를 확인할 수 없습니다.')
+    }
+    const response = await this.http.postJson<{ resultCode?: string }>(path, buildTeamActionPayload(teamId, user))
+    if (response.resultCode !== 'success') {
+      throw new Error(fallbackMessage)
+    }
+  }
+
+  private async postRoomUpdate(payload: Record<string, string>): Promise<void> {
+    try {
+      await this.http.post('/mypage/itemRent/update.do', payload)
+    } catch (error) {
+      if (error instanceof Error && isSuccessAlertMessage(error.message)) {
+        return
+      }
+      throw error
+    }
+  }
+
   private containsErrorIndicator(html: string): boolean {
     const errorPatterns = [
       'class="error"',
@@ -550,14 +696,20 @@ export class SomaClient {
       '실패하였습니다',
       '잘못된 접근',
       '권한이 없습니다',
-      '<script>alert(',
     ]
-    return errorPatterns.some((pattern) => html.includes(pattern))
+    if (errorPatterns.some((pattern) => html.includes(pattern))) {
+      return true
+    }
+    const alertMatch = html.match(/<script[^>]*>\s*alert\(['"](.+?)['"]\)/)
+    if (alertMatch && !isSuccessAlertMessage(alertMatch[1])) {
+      return true
+    }
+    return false
   }
 
   private extractErrorMessage(html: string): string | null {
-    const alertMatch = html.match(/<script>alert\(['"](.+?)['"]\)/)
-    if (alertMatch) {
+    const alertMatch = html.match(/<script[^>]*>\s*alert\(['"](.+?)['"]\)/)
+    if (alertMatch && !isSuccessAlertMessage(alertMatch[1])) {
       return alertMatch[1]
     }
     const errorDivMatch = html.match(/class="error[^"]*"[^>]*>\s*([^<]+)/)
@@ -567,3 +719,65 @@ export class SomaClient {
     return null
   }
 }
+
+function isTraineeRole(role: string): boolean {
+  return role.includes('연수생')
+}
+
+function applicationHistoryToDashboardItem(
+  item: ApplicationHistoryItem,
+): Dashboard['mentoringSessions'][number] | null {
+  if (item.applicationStatus.includes('취소')) return null
+
+  const type = applicationCategoryToMentoringType(item.category)
+  if (!type) return null
+
+  const { date, time, timeEnd } = parseApplicationSessionDate(item.sessionDate)
+  if (date && date < new Date().toISOString().slice(0, 10)) return null
+
+  return {
+    title: item.title,
+    url: item.url ?? '/mentoring/history',
+    status: item.applicationStatus,
+    ...(date ? { date } : {}),
+    ...(time ? { time } : {}),
+    ...(timeEnd ? { timeEnd } : {}),
+    type,
+  }
+}
+
+function sortDashboardMentoringItems(items: Dashboard['mentoringSessions']): Dashboard['mentoringSessions'] {
+  return [...items].sort((a, b) => dashboardMentoringSortKey(a).localeCompare(dashboardMentoringSortKey(b)))
+}
+
+function dashboardMentoringSortKey(item: Dashboard['mentoringSessions'][number]): string {
+  return `${item.date || '9999-12-31'} ${item.time || '99:99'}`
+}
+
+function applicationCategoryToMentoringType(category: string): '자유 멘토링' | '멘토 특강' | null {
+  const compact = category.replace(/\s+/g, '')
+  if (compact.includes('특강')) return '멘토 특강'
+  if (compact.includes('멘토링')) return '자유 멘토링'
+  return null
+}
+
+function parseApplicationSessionDate(value: string): { date?: string; time?: string; timeEnd?: string } {
+  const date = value.match(/\d{4}-\d{2}-\d{2}/)?.[0]
+  const times = value.match(/\d{1,2}:\d{2}(?::\d{2})?/g)?.map(normalizeDashboardTime) ?? []
+  return {
+    ...(date ? { date } : {}),
+    ...(times[0] ? { time: times[0] } : {}),
+    ...(times[1] ? { timeEnd: times[1] } : {}),
+  }
+}
+
+function normalizeDashboardTime(value: string): string {
+  const [hours = '', minutes = ''] = value.split(':')
+  return `${hours.padStart(2, '0')}:${minutes}`
+}
+
+function isSuccessAlertMessage(message: string): boolean {
+  return /정상적으로|등록\s?하였습니다|등록\s?되었습니다|수정\s?하였습니다|수정\s?되었습니다|저장\s?되었습니다|완료\s?되었습니다|삭제\s?되었습니다|취소\s?되었습니다/.test(
+    message,
+  )
+}

package/src/commands/agent-browser.ts

@@ -0,0 +1,33 @@
+import { Command } from 'commander'
+
+import { AgentBrowserLauncher } from '../agent-browser-launcher'
+import { handleError } from '../shared/utils/error-handler'
+import { createAuthenticatedHttp } from './helpers'
+
+type LaunchOptions = { binary?: string }
+
+async function launchAction(url: string, options: LaunchOptions): Promise<void> {
+  try {
+    const http = await createAuthenticatedHttp()
+    const sessionCookie = http.getSessionCookie()
+    if (!sessionCookie) {
+      throw new Error('Authenticated session is missing a session cookie. Run: opensoma auth login')
+    }
+
+    const launcher = new AgentBrowserLauncher({ binary: options.binary })
+    const { exitCode } = await launcher.launch({ url, sessionCookie })
+    process.exit(exitCode)
+  } catch (error) {
+    handleError(error)
+  }
+}
+
+export const agentBrowserCommand = new Command('agent-browser')
+  .description('Launch agent-browser pre-authenticated to swmaestro.ai')
+  .addCommand(
+    new Command('launch')
+      .description('Open a swmaestro.ai URL in agent-browser with the current opensoma session injected')
+      .argument('<url>', 'swmaestro.ai URL to open')
+      .option('--binary <path>', 'Path to the agent-browser executable (default: agent-browser on PATH)')
+      .action(launchAction),
+  )