opensoma 0.1.0

package/src/http.ts

@@ -0,0 +1,196 @@
+import { BASE_URL, MENU_NO } from '@/constants'
+import { parseCsrfToken } from '@/formatters'
+
+interface RequestOptions {
+  sessionCookie?: string
+  csrfToken?: string
+}
+
+interface CheckLoginResponse {
+  resultCode?: string
+  userVO?: { userId?: string; userNm?: string; userSn?: number }
+}
+
+export interface UserIdentity {
+  userId: string
+  userNm: string
+}
+
+interface HeadersWithCookieHelpers extends Omit<Headers, 'getSetCookie'> {
+  getSetCookie?: () => string[]
+}
+
+export class SomaHttp {
+  private cookies = new Map<string, string>()
+  private csrfToken: string | null
+
+  constructor(options?: RequestOptions) {
+    this.csrfToken = options?.csrfToken ?? null
+
+    if (options?.sessionCookie) {
+      this.setCookie(
+        options.sessionCookie.includes('=') ? options.sessionCookie : `JSESSIONID=${options.sessionCookie}`,
+      )
+    }
+  }
+
+  async get(path: string, params?: Record<string, string>): Promise<string> {
+    const response = await fetch(this.buildUrl(path, params), {
+      method: 'GET',
+      headers: this.buildHeaders(),
+    })
+
+    this.updateFromResponse(response)
+    return response.text()
+  }
+
+  async post(path: string, body: Record<string, string>): Promise<string> {
+    const formBody = new URLSearchParams(this.buildBody(body))
+    const response = await fetch(this.buildUrl(path), {
+      method: 'POST',
+      headers: {
+        ...this.buildHeaders(),
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: formBody.toString(),
+    })
+
+    this.updateFromResponse(response)
+    return response.text()
+  }
+
+  async postJson<T>(path: string, body: Record<string, string>): Promise<T> {
+    const formBody = new URLSearchParams(this.buildBody(body))
+    const response = await fetch(this.buildUrl(path), {
+      method: 'POST',
+      headers: {
+        ...this.buildHeaders(),
+        Accept: 'application/json',
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: formBody.toString(),
+    })
+
+    this.updateFromResponse(response)
+    return (await response.json()) as T
+  }
+
+  async login(username: string, password: string): Promise<void> {
+    const csrfToken = await this.extractCsrfToken()
+
+    await this.post('/member/user/toLogin.do', {
+      username,
+      password,
+      csrfToken,
+      loginFlag: '',
+      menuNo: MENU_NO.LOGIN,
+    })
+  }
+
+  async checkLogin(): Promise<UserIdentity | null> {
+    const response = await fetch(this.buildUrl('/member/user/checkLogin.json'), {
+      method: 'GET',
+      headers: {
+        ...this.buildHeaders(),
+        Accept: 'application/json',
+      },
+    })
+
+    this.updateFromResponse(response)
+    const json = (await response.json()) as CheckLoginResponse
+    const userId = json.userVO?.userId
+    if (!userId) return null
+    return { userId, userNm: json.userVO?.userNm ?? '' }
+  }
+
+  async logout(): Promise<void> {
+    await this.get('/member/user/logout.do')
+  }
+
+  async extractCsrfToken(): Promise<string> {
+    const html = await this.get('/member/user/forLogin.do', { menuNo: MENU_NO.LOGIN })
+    const token = parseCsrfToken(html)
+    this.csrfToken = token
+    return token
+  }
+
+  getCookies(): Record<string, string> {
+    return Object.fromEntries(this.cookies)
+  }
+
+  getSessionCookie(): string | undefined {
+    return this.cookies.get('JSESSIONID')
+  }
+
+  getCsrfToken(): string | null {
+    return this.csrfToken
+  }
+
+  private buildUrl(path: string, params?: Record<string, string>): string {
+    const normalizedPath = path.startsWith('/') ? path.slice(1) : path
+    const url = new URL(normalizedPath, `${BASE_URL}/`)
+
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value)
+      }
+    }
+
+    return url.toString()
+  }
+
+  private buildHeaders(): Record<string, string> {
+    const cookieHeader = this.serializeCookies()
+    return cookieHeader ? { cookie: cookieHeader } : {}
+  }
+
+  private buildBody(body: Record<string, string>): Record<string, string> {
+    if (this.csrfToken && !('csrfToken' in body)) {
+      return { ...body, csrfToken: this.csrfToken }
+    }
+
+    return body
+  }
+
+  private updateFromResponse(response: Response): void {
+    const setCookies = this.readSetCookies(response.headers)
+
+    for (const cookie of setCookies) {
+      this.setCookie(cookie)
+    }
+  }
+
+  private readSetCookies(headers: Headers): string[] {
+    const enhancedHeaders = headers as HeadersWithCookieHelpers
+
+    if (typeof enhancedHeaders.getSetCookie === 'function') {
+      return enhancedHeaders.getSetCookie()
+    }
+
+    const singleHeader = headers.get('set-cookie')
+    return singleHeader ? [singleHeader] : []
+  }
+
+  private setCookie(cookieHeader: string): void {
+    const cookiePair = cookieHeader.split(';')[0]?.trim()
+    if (!cookiePair) {
+      return
+    }
+
+    const separatorIndex = cookiePair.indexOf('=')
+    if (separatorIndex === -1) {
+      return
+    }
+
+    const name = cookiePair.slice(0, separatorIndex).trim()
+    const value = cookiePair.slice(separatorIndex + 1).trim()
+
+    if (name) {
+      this.cookies.set(name, value)
+    }
+  }
+
+  private serializeCookies(): string {
+    return [...this.cookies.entries()].map(([name, value]) => `${name}=${value}`).join('; ')
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export { SomaClient } from './client'
+export type { SomaClientOptions } from './client'
+export { SomaHttp } from './http'
+export { CredentialManager } from './credential-manager'
+export * from './types'
+export * from './constants'

package/src/shared/utils/error-handler.ts

@@ -0,0 +1,7 @@
+import { error } from './stderr'
+
+export function handleError(err: unknown): void {
+  const message = err instanceof Error ? err.message : typeof err === 'string' ? err : 'Unknown error'
+  error(JSON.stringify({ error: message }))
+  process.exit(1)
+}

package/src/shared/utils/mentoring-params.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, test } from 'bun:test'
+
+import { MENU_NO, REPORT_CD } from '@/constants'
+
+import { buildMentoringListParams, parseSearchQuery } from './mentoring-params'
+
+describe('parseSearchQuery', () => {
+  test('plain text defaults to title', () => {
+    expect(parseSearchQuery('OpenCode')).toEqual({ field: 'title', value: 'OpenCode' })
+  })
+
+  test('title: prefix', () => {
+    expect(parseSearchQuery('title:OpenCode')).toEqual({ field: 'title', value: 'OpenCode' })
+  })
+
+  test('author: prefix', () => {
+    expect(parseSearchQuery('author:전수열')).toEqual({ field: 'author', value: '전수열' })
+  })
+
+  test('author:@me sets me flag', () => {
+    expect(parseSearchQuery('author:@me')).toEqual({ field: 'author', value: '@me', me: true })
+  })
+
+  test('content: prefix', () => {
+    expect(parseSearchQuery('content:하네스')).toEqual({ field: 'content', value: '하네스' })
+  })
+
+  test('unknown prefix treated as plain title search', () => {
+    expect(parseSearchQuery('foo:bar')).toEqual({ field: 'title', value: 'foo:bar' })
+  })
+
+  test('value with colons preserves everything after first colon', () => {
+    expect(parseSearchQuery('title:foo:bar')).toEqual({ field: 'title', value: 'foo:bar' })
+  })
+})
+
+describe('buildMentoringListParams', () => {
+  test('no options returns only menuNo', () => {
+    expect(buildMentoringListParams()).toEqual({ menuNo: MENU_NO.MENTORING })
+  })
+
+  test('status maps open to A, closed to C', () => {
+    expect(buildMentoringListParams({ status: 'open' })).toEqual({ menuNo: MENU_NO.MENTORING, searchStatMentolec: 'A' })
+    expect(buildMentoringListParams({ status: 'closed' })).toEqual({
+      menuNo: MENU_NO.MENTORING,
+      searchStatMentolec: 'C',
+    })
+  })
+
+  test('type maps public and lecture to report codes', () => {
+    expect(buildMentoringListParams({ type: 'public' })).toEqual({
+      menuNo: MENU_NO.MENTORING,
+      searchGubunMentolec: REPORT_CD.PUBLIC_MENTORING,
+    })
+    expect(buildMentoringListParams({ type: 'lecture' })).toEqual({
+      menuNo: MENU_NO.MENTORING,
+      searchGubunMentolec: REPORT_CD.MENTOR_LECTURE,
+    })
+  })
+
+  test('title search sets searchCnd=1', () => {
+    expect(buildMentoringListParams({ search: { field: 'title', value: 'OpenCode' } })).toEqual({
+      menuNo: MENU_NO.MENTORING,
+      searchCnd: '1',
+      searchWrd: 'OpenCode',
+    })
+  })
+
+  test('author search sets searchCnd=2', () => {
+    expect(buildMentoringListParams({ search: { field: 'author', value: '전수열' } })).toEqual({
+      menuNo: MENU_NO.MENTORING,
+      searchCnd: '2',
+      searchWrd: '전수열',
+    })
+  })
+
+  test('author:@me with user sets searchId and userNm', () => {
+    expect(
+      buildMentoringListParams({
+        search: { field: 'author', value: '@me', me: true },
+        user: { userId: 'neo@example.com', userNm: '전수열' },
+      }),
+    ).toEqual({
+      menuNo: MENU_NO.MENTORING,
+      searchCnd: '2',
+      searchId: 'neo@example.com',
+      searchWrd: '전수열',
+    })
+  })
+
+  test('search composes with status and type', () => {
+    expect(
+      buildMentoringListParams({
+        status: 'open',
+        type: 'lecture',
+        search: { field: 'author', value: '@me', me: true },
+        user: { userId: 'neo@example.com', userNm: '전수열' },
+      }),
+    ).toEqual({
+      menuNo: MENU_NO.MENTORING,
+      searchStatMentolec: 'A',
+      searchGubunMentolec: REPORT_CD.MENTOR_LECTURE,
+      searchCnd: '2',
+      searchId: 'neo@example.com',
+      searchWrd: '전수열',
+    })
+  })
+
+  test('page sets pageIndex', () => {
+    expect(buildMentoringListParams({ page: 3 })).toEqual({ menuNo: MENU_NO.MENTORING, pageIndex: '3' })
+  })
+})

package/src/shared/utils/mentoring-params.ts

@@ -0,0 +1,57 @@
+import { MENU_NO, REPORT_CD } from '@/constants'
+import type { UserIdentity } from '@/http'
+
+const STATUS_MAP: Record<string, string> = { open: 'A', closed: 'C' }
+const TYPE_MAP: Record<string, string> = { public: REPORT_CD.PUBLIC_MENTORING, lecture: REPORT_CD.MENTOR_LECTURE }
+const SEARCH_FIELD_MAP: Record<string, string> = { title: '1', author: '2', content: '3' }
+
+export interface MentoringSearchQuery {
+  field: 'title' | 'author' | 'content'
+  value: string
+  me?: boolean
+}
+
+export function parseSearchQuery(raw: string): MentoringSearchQuery {
+  const colonIndex = raw.indexOf(':')
+  if (colonIndex === -1) {
+    return { field: 'title', value: raw }
+  }
+
+  const field = raw.slice(0, colonIndex) as MentoringSearchQuery['field']
+  if (!(field in SEARCH_FIELD_MAP)) {
+    return { field: 'title', value: raw }
+  }
+
+  const value = raw.slice(colonIndex + 1)
+  const me = field === 'author' && value === '@me'
+  return me ? { field, value, me } : { field, value }
+}
+
+export function buildMentoringListParams(options?: {
+  status?: string
+  type?: string
+  page?: string | number
+  search?: MentoringSearchQuery
+  user?: UserIdentity
+}): Record<string, string> {
+  const params: Record<string, string> = { menuNo: MENU_NO.MENTORING }
+
+  if (options?.status) {
+    params.searchStatMentolec = STATUS_MAP[options.status] ?? options.status
+  }
+
+  if (options?.search) {
+    params.searchCnd = SEARCH_FIELD_MAP[options.search.field]
+    if (options.search.me && options.user) {
+      params.searchId = options.user.userId
+      params.searchWrd = options.user.userNm
+    } else {
+      params.searchWrd = options.search.value
+    }
+  }
+
+  if (options?.type) params.searchGubunMentolec = TYPE_MAP[options.type] ?? options.type
+  if (options?.page) params.pageIndex = String(options.page)
+
+  return params
+}

package/src/shared/utils/output.ts

@@ -0,0 +1,3 @@
+export function formatOutput(data: unknown, pretty?: boolean): string {
+  return pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data)
+}

package/src/shared/utils/stderr.ts

@@ -0,0 +1,23 @@
+const isTTY = process.stderr.isTTY ?? false
+
+function colorize(code: number, text: string): string {
+  return isTTY ? `\x1b[${code}m${text}\x1b[0m` : text
+}
+
+export function info(message: string): void {
+  process.stderr.write(`${colorize(36, message)}\n`)
+}
+
+export function warn(message: string): void {
+  process.stderr.write(`${colorize(33, message)}\n`)
+}
+
+export function error(message: string): void {
+  process.stderr.write(`${colorize(31, message)}\n`)
+}
+
+export function debug(message: string): void {
+  if (process.env.DEBUG) {
+    process.stderr.write(`${colorize(90, message)}\n`)
+  }
+}

package/src/shared/utils/swmaestro.ts

@@ -0,0 +1,218 @@
+import { parse } from 'node-html-parser'
+
+import { MENU_NO, REPORT_CD, ROOM_IDS, TIME_SLOTS } from '@/constants'
+import { ApplicationHistoryItemSchema, type ApplicationHistoryItem } from '@/types'
+
+export function toReportCd(type: 'public' | 'lecture'): string {
+  return type === 'lecture' ? REPORT_CD.MENTOR_LECTURE : REPORT_CD.PUBLIC_MENTORING
+}
+
+export function buildMentoringPayload(params: {
+  title: string
+  type: 'public' | 'lecture'
+  date: string
+  startTime: string
+  endTime: string
+  venue: string
+  maxAttendees?: number
+  regStart?: string
+  regEnd?: string
+  content?: string
+}): Record<string, string> {
+  return {
+    menuNo: MENU_NO.MENTORING,
+    reportCd: toReportCd(params.type),
+    qustnrSj: params.title,
+    bgnde: params.regStart ?? params.date,
+    endde: params.regEnd ?? params.date,
+    applyCnt: String(params.maxAttendees ?? (params.type === 'lecture' ? 6 : 1)),
+    eventDt: params.date,
+    eventStime: params.startTime,
+    eventEtime: params.endTime,
+    place: params.venue,
+    qestnarCn: params.content ?? '',
+    atchFileId: '',
+    fileFieldNm_1: '',
+    stateCd: 'QST020',
+    openAt: 'Y',
+    qustnrAt: 'Y',
+    qustnrSn: '',
+    pageQueryString: '',
+  }
+}
+
+export function buildDeleteMentoringPayload(id: number): Record<string, string> {
+  return {
+    menuNo: MENU_NO.MENTORING,
+    qustnrSn: String(id),
+    pageQueryString: '',
+  }
+}
+
+export function buildApplicationPayload(id: number): Record<string, string> {
+  return {
+    menuNo: MENU_NO.EVENT,
+    qustnrSn: String(id),
+    applyGb: 'C',
+    stepHeader: '0',
+  }
+}
+
+export function buildCancelApplicationPayload(params: { applySn: number; qustnrSn: number }): Record<string, string> {
+  return {
+    menuNo: MENU_NO.APPLICATION_HISTORY,
+    applySn: String(params.applySn),
+    qustnrSn: String(params.qustnrSn),
+  }
+}
+
+export function resolveRoomId(room: string | number): number {
+  if (typeof room === 'number') {
+    return room
+  }
+
+  const normalized = room.trim().toUpperCase()
+  const mapped = ROOM_IDS[normalized]
+  if (mapped) {
+    return mapped
+  }
+
+  const numeric = Number.parseInt(room, 10)
+  if (Number.isNaN(numeric)) {
+    throw new Error(`Unknown room: ${room}`)
+  }
+
+  return numeric
+}
+
+export function validateReservationSlots(slots: string[]): void {
+  if (slots.length === 0) {
+    throw new Error('At least one time slot is required')
+  }
+
+  if (slots.length > 8) {
+    throw new Error('You can reserve up to 8 consecutive slots')
+  }
+
+  const indices = slots.map((slot) => {
+    const index = TIME_SLOTS.indexOf(slot)
+    if (index === -1) {
+      throw new Error(`Invalid time slot: ${slot}`)
+    }
+    return index
+  })
+
+  for (let index = 1; index < indices.length; index += 1) {
+    if (indices[index] !== indices[index - 1] + 1) {
+      throw new Error('Time slots must be consecutive')
+    }
+  }
+}
+
+export function buildRoomReservationPayload(params: {
+  roomId: number
+  date: string
+  slots: string[]
+  title: string
+  attendees?: number
+  notes?: string
+}): Record<string, string> {
+  validateReservationSlots(params.slots)
+
+  const firstSlot = params.slots[0]
+  const lastSlot = params.slots[params.slots.length - 1]
+  const endSlot = TIME_SLOTS[TIME_SLOTS.indexOf(lastSlot) + 1]
+
+  if (!endSlot) {
+    throw new Error('Reservation end time is out of range')
+  }
+
+  const payload: Record<string, string> = {
+    menuNo: MENU_NO.ROOM,
+    itemId: String(params.roomId),
+    rentBgnde: `${params.date} ${firstSlot}:00`,
+    rentEndde: `${params.date} ${endSlot}:00`,
+    title: params.title,
+    rentDt: params.date,
+    rentNum: String(params.attendees ?? 1),
+    infoCn: params.notes ?? '',
+    rentId: '',
+    pageQueryString: '',
+  }
+
+  params.slots.forEach((slot, index) => {
+    payload[`time[${index}]`] = slot
+    payload[`chkData_${index + 1}`] = `${params.date}|${slot}|${params.roomId}`
+  })
+
+  return payload
+}
+
+export function parseApplicationHistory(html: string): ApplicationHistoryItem[] {
+  const root = parse(html)
+  const rows =
+    root.querySelectorAll('table tbody tr').length > 0
+      ? root.querySelectorAll('table tbody tr')
+      : root.querySelectorAll('table tr').slice(1)
+
+  return rows
+    .map((row) => row.querySelectorAll('td'))
+    .filter((cells) => cells.length >= 4)
+    .map((cells) =>
+      ApplicationHistoryItemSchema.parse({
+        id: extractNumber(cleanText(cells[0]?.text)),
+        title: cleanText(cells[1]?.text),
+        appliedAt: cleanText(cells[2]?.text),
+        status: cleanText(cells[3]?.text),
+      }),
+    )
+}
+
+export function parseEventDetail(html: string): Record<string, unknown> {
+  const root = parse(html)
+  const labels = extractLabelMap(root)
+  const contentNode =
+    root.querySelector('[data-content]') ??
+    root.querySelector('.board-view-content') ??
+    root.querySelector('.view-content') ??
+    root.querySelector('.content-body')
+
+  return {
+    id: extractNumber(
+      labels.NO ?? labels['번호'] ?? root.querySelector('[name="bbsId"]')?.getAttribute('value') ?? '0',
+    ),
+    title: labels['제목'] ?? cleanText(root.querySelector('h1, h2, .title')?.text),
+    content: contentNode?.innerHTML.trim() ?? '',
+    fields: labels,
+  }
+}
+
+function extractLabelMap(root: ReturnType<typeof parse>): Record<string, string> {
+  const map: Record<string, string> = {}
+
+  for (const row of root.querySelectorAll('tr')) {
+    const headers = row.querySelectorAll('th')
+    const values = row.querySelectorAll('td')
+
+    if (headers.length === 1 && values.length === 1) {
+      map[cleanText(headers[0]?.text).replace(/:$/, '')] = cleanText(values[0]?.text)
+    }
+
+    if (headers.length > 1 && headers.length === values.length) {
+      headers.forEach((header, index) => {
+        map[cleanText(header.text).replace(/:$/, '')] = cleanText(values[index]?.text)
+      })
+    }
+  }
+
+  return map
+}
+
+function cleanText(value: string | null | undefined): string {
+  return (value ?? '').replace(/\s+/g, ' ').replace(/\[|\]/g, '').trim()
+}
+
+function extractNumber(value: string): number {
+  const match = value.match(/\d+/)
+  return match ? Number.parseInt(match[0], 10) : 0
+}