opensoma 0.5.1 → 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'
 
@@ -54,6 +60,8 @@ 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?: {
@@ -71,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>
@@ -93,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: {
@@ -126,17 +146,17 @@ 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 = {}) {
@@ -165,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) => {
@@ -189,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)) {
@@ -225,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 }),
         }
       },
     }
@@ -279,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
       },
     }
@@ -308,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) => {
@@ -335,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) => {
@@ -429,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, '팀 탈퇴에 실패했습니다.')
       },
     }
 
@@ -452,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)
       },
     }
   }
@@ -490,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()
     }
 
@@ -499,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
@@ -523,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()
   }
@@ -544,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"',
@@ -554,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*([^<]+)/)
@@ -571,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),
+  )