opensoma 0.1.3 → 0.2.1

package/src/commands/mentoring.ts

@@ -1,20 +1,25 @@
 import { Command } from 'commander'
 
-import { MENU_NO } from '@/constants'
-import * as formatters from '@/formatters'
-import { handleError } from '@/shared/utils/error-handler'
-import { formatOutput } from '@/shared/utils/output'
+import { MENU_NO } from '../constants'
+import * as formatters from '../formatters'
+import { handleError } from '../shared/utils/error-handler'
+import { buildMentoringListParams, parseSearchQuery } from '../shared/utils/mentoring-params'
+import { formatOutput } from '../shared/utils/output'
 import {
   buildApplicationPayload,
   buildCancelApplicationPayload,
   buildDeleteMentoringPayload,
   buildMentoringPayload,
-} from '@/shared/utils/swmaestro'
-
+} from '../shared/utils/swmaestro'
 import { getHttpOrExit } from './helpers'
-import { buildMentoringListParams, parseSearchQuery } from '@/shared/utils/mentoring-params'
 
-type ListOptions = { status?: string; type?: string; search?: string; page?: string; pretty?: boolean }
+type ListOptions = {
+  status?: string
+  type?: string
+  search?: string
+  page?: string
+  pretty?: boolean
+}
 type GetOptions = { pretty?: boolean }
 type CreateOptions = {
   title: string
@@ -36,17 +41,23 @@ async function listAction(options: ListOptions): Promise<void> {
   try {
     const http = await getHttpOrExit()
     const search = options.search ? parseSearchQuery(options.search) : undefined
-    const user = search?.me ? (await http.checkLogin()) ?? undefined : undefined
-    const html = await http.get('/mypage/mentoLec/list.do', buildMentoringListParams({
-      status: options.status,
-      type: options.type,
-      page: options.page,
-      search,
-      user,
-    }))
+    const user = search?.me ? ((await http.checkLogin()) ?? undefined) : undefined
+    const html = await http.get(
+      '/mypage/mentoLec/list.do',
+      buildMentoringListParams({
+        status: options.status,
+        type: options.type,
+        page: options.page,
+        search,
+        user,
+      }),
+    )
     console.log(
       formatOutput(
-        { items: formatters.parseMentoringList(html), pagination: formatters.parsePagination(html) },
+        {
+          items: formatters.parseMentoringList(html),
+          pagination: formatters.parsePagination(html),
+        },
         options.pretty,
       ),
     )
@@ -58,7 +69,10 @@ async function listAction(options: ListOptions): Promise<void> {
 async function getAction(id: string, options: GetOptions): Promise<void> {
   try {
     const http = await getHttpOrExit()
-    const html = await http.get('/mypage/mentoLec/view.do', { menuNo: MENU_NO.MENTORING, qustnrSn: id })
+    const html = await http.get('/mypage/mentoLec/view.do', {
+      menuNo: MENU_NO.MENTORING,
+      qustnrSn: id,
+    })
     console.log(formatOutput(formatters.parseMentoringDetail(html, Number.parseInt(id, 10)), options.pretty))
   } catch (error) {
     handleError(error)
@@ -134,7 +148,10 @@ async function historyAction(options: HistoryOptions): Promise<void> {
     })
     console.log(
       formatOutput(
-        { items: formatters.parseApplicationHistory(html), pagination: formatters.parsePagination(html) },
+        {
+          items: formatters.parseApplicationHistory(html),
+          pagination: formatters.parsePagination(html),
+        },
         options.pretty,
       ),
     )

package/src/commands/notice.ts

@@ -1,10 +1,9 @@
 import { Command } from 'commander'
 
-import { MENU_NO } from '@/constants'
-import * as formatters from '@/formatters'
-import { handleError } from '@/shared/utils/error-handler'
-import { formatOutput } from '@/shared/utils/output'
-
+import { MENU_NO } from '../constants'
+import * as formatters from '../formatters'
+import { handleError } from '../shared/utils/error-handler'
+import { formatOutput } from '../shared/utils/output'
 import { getHttpOrExit } from './helpers'
 
 type ListOptions = { page?: string; pretty?: boolean }

package/src/commands/room.ts

@@ -1,10 +1,9 @@
 import { Command } from 'commander'
 
-import * as formatters from '@/formatters'
-import { handleError } from '@/shared/utils/error-handler'
-import { formatOutput } from '@/shared/utils/output'
-import { buildRoomReservationPayload, resolveRoomId } from '@/shared/utils/swmaestro'
-
+import * as formatters from '../formatters'
+import { handleError } from '../shared/utils/error-handler'
+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 }

package/src/commands/team.ts

@@ -1,10 +1,9 @@
 import { Command } from 'commander'
 
-import { MENU_NO } from '@/constants'
-import * as formatters from '@/formatters'
-import { handleError } from '@/shared/utils/error-handler'
-import { formatOutput } from '@/shared/utils/output'
-
+import { MENU_NO } from '../constants'
+import * as formatters from '../formatters'
+import { handleError } from '../shared/utils/error-handler'
+import { formatOutput } from '../shared/utils/output'
 import { getHttpOrExit } from './helpers'
 
 type ShowOptions = { pretty?: boolean }

package/src/credential-manager.test.ts

@@ -1,9 +1,9 @@
 import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdtemp, stat } from 'node:fs/promises'
+import { mkdtemp, readFile, rm, stat } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
-import { CredentialManager } from '@/credential-manager'
+import { CredentialManager } from './credential-manager'
 
 let createdDirs: string[] = []
 
@@ -31,6 +31,7 @@ describe('CredentialManager', () => {
       sessionCookie: 'session-value',
       csrfToken: 'csrf-value',
       username: 'neo@example.com',
+      password: 'secret-password',
       loggedInAt: '2026-04-09T00:00:00.000Z',
     })
 
@@ -38,11 +39,18 @@ describe('CredentialManager', () => {
       sessionCookie: 'session-value',
       csrfToken: 'csrf-value',
       username: 'neo@example.com',
+      password: 'secret-password',
       loggedInAt: '2026-04-09T00:00:00.000Z',
     })
 
+    const rawContent = await readFile(join(dir, 'credentials.json'), 'utf8')
+    expect(rawContent).not.toContain('secret-password')
+
     const fileStat = await stat(join(dir, 'credentials.json'))
     expect(fileStat.mode & 0o777).toBe(0o600)
+
+    const keyFileStat = await stat(join(dir, 'credentials.key'))
+    expect(keyFileStat.mode & 0o777).toBe(0o600)
   })
 
   test('removes credentials file', async () => {
@@ -57,6 +65,38 @@ describe('CredentialManager', () => {
 
     await expect(manager.getCredentials()).resolves.toBeNull()
   })
+
+  test('preserves session credentials when the encryption key is missing', async () => {
+    const dir = await makeTempDir()
+    const manager = new CredentialManager(dir)
+
+    await manager.setCredentials({
+      sessionCookie: 'session-value',
+      csrfToken: 'csrf-value',
+      username: 'neo@example.com',
+      password: 'secret-password',
+      loggedInAt: '2026-04-09T00:00:00.000Z',
+    })
+
+    await new CredentialManager(dir).remove()
+    await manager.save({
+      credentials: {
+        sessionCookie: 'session-value',
+        csrfToken: 'csrf-value',
+        username: 'neo@example.com',
+        password: 'secret-password',
+        loggedInAt: '2026-04-09T00:00:00.000Z',
+      },
+    })
+    await rm(join(dir, 'credentials.key'))
+
+    await expect(manager.getCredentials()).resolves.toEqual({
+      sessionCookie: 'session-value',
+      csrfToken: 'csrf-value',
+      username: 'neo@example.com',
+      loggedInAt: '2026-04-09T00:00:00.000Z',
+    })
+  })
 })
 
 async function makeTempDir(): Promise<string> {

package/src/credential-manager.ts

@@ -1,9 +1,20 @@
+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 type { Credentials } from '@/types'
+import type { Credentials } from './types'
+
+interface EncryptedSecret {
+  ciphertext: string
+  iv: string
+  tag: string
+}
+
+interface StoredCredentials extends Omit<Credentials, 'password'> {
+  encryptedPassword?: EncryptedSecret
+}
 
 export interface CredentialConfig {
   credentials: Credentials | null
@@ -12,10 +23,12 @@ export interface CredentialConfig {
 export class CredentialManager {
   private configDir: string
   private credentialsPath: string
+  private encryptionKeyPath: string
 
   constructor(configDir?: string) {
     this.configDir = configDir ?? join(homedir(), '.config', 'opensoma')
     this.credentialsPath = join(this.configDir, 'credentials.json')
+    this.encryptionKeyPath = join(this.configDir, 'credentials.key')
   }
 
   async load(): Promise<CredentialConfig> {
@@ -25,7 +38,10 @@ export class CredentialManager {
 
     try {
       const content = await readFile(this.credentialsPath, 'utf8')
-      return JSON.parse(content) as CredentialConfig
+      const parsed = JSON.parse(content) as { credentials: StoredCredentials | null }
+      return {
+        credentials: parsed.credentials ? await this.hydrateCredentials(parsed.credentials) : null,
+      }
     } catch {
       return { credentials: null }
     }
@@ -33,7 +49,16 @@ export class CredentialManager {
 
   async save(config: CredentialConfig): Promise<void> {
     await mkdir(this.configDir, { recursive: true })
-    await writeFile(this.credentialsPath, JSON.stringify(config, null, 2))
+    await writeFile(
+      this.credentialsPath,
+      JSON.stringify(
+        {
+          credentials: config.credentials ? await this.serializeCredentials(config.credentials) : null,
+        },
+        null,
+        2,
+      ),
+    )
     await chmod(this.credentialsPath, 0o600)
   }
 
@@ -48,5 +73,81 @@ export class CredentialManager {
 
   async remove(): Promise<void> {
     await rm(this.credentialsPath, { force: true })
+    await rm(this.encryptionKeyPath, { force: true })
+  }
+
+  private async hydrateCredentials(credentials: StoredCredentials): Promise<Credentials> {
+    if (!credentials.encryptedPassword) {
+      return credentials
+    }
+
+    const { encryptedPassword, ...rest } = credentials
+    const password = await this.decryptSecret(encryptedPassword)
+    return password ? { ...rest, password } : rest
+  }
+
+  private async serializeCredentials(credentials: Credentials): Promise<StoredCredentials> {
+    if (!credentials.password) {
+      return credentials
+    }
+
+    const { password, ...rest } = credentials
+    return {
+      ...rest,
+      encryptedPassword: await this.encryptSecret(password),
+    }
+  }
+
+  private async encryptSecret(secret: string): Promise<EncryptedSecret> {
+    const key = await this.getOrCreateEncryptionKey()
+    const iv = randomBytes(12)
+    const cipher = createCipheriv('aes-256-gcm', key, iv)
+    const ciphertext = Buffer.concat([cipher.update(secret, 'utf8'), cipher.final()])
+
+    return {
+      ciphertext: ciphertext.toString('base64'),
+      iv: iv.toString('base64'),
+      tag: cipher.getAuthTag().toString('base64'),
+    }
+  }
+
+  private async decryptSecret(secret: EncryptedSecret): Promise<string> {
+    const key = await this.getExistingEncryptionKey()
+    if (!key) {
+      return ''
+    }
+
+    try {
+      const decipher = createDecipheriv('aes-256-gcm', key, Buffer.from(secret.iv, 'base64'))
+      decipher.setAuthTag(Buffer.from(secret.tag, 'base64'))
+      const decrypted = Buffer.concat([decipher.update(Buffer.from(secret.ciphertext, 'base64')), decipher.final()])
+      return decrypted.toString('utf8')
+    } catch {
+      return ''
+    }
+  }
+
+  private async getOrCreateEncryptionKey(): Promise<Buffer> {
+    if (existsSync(this.encryptionKeyPath)) {
+      return Buffer.from(await readFile(this.encryptionKeyPath, 'utf8'), 'base64')
+    }
+
+    await mkdir(this.configDir, { recursive: true })
+    const key = randomBytes(32)
+    await writeFile(this.encryptionKeyPath, key.toString('base64'))
+    await chmod(this.encryptionKeyPath, 0o600)
+    return key
+  }
+
+  private async getExistingEncryptionKey(): Promise<Buffer | null> {
+    if (!existsSync(this.encryptionKeyPath)) {
+      return null
+    }
+
+    try {
+      return Buffer.from(await readFile(this.encryptionKeyPath, 'utf8'), 'base64')
+    } catch {
+      return null
+    }
   }
 }

package/src/errors.ts

@@ -0,0 +1,10 @@
+/**
+ * Error thrown when authentication is required but not valid.
+ * Provides a clear message indicating the need to authenticate.
+ */
+export class AuthenticationError extends Error {
+  constructor(message = 'Authentication required. Please login with: opensoma auth login or opensoma auth extract') {
+    super(message)
+    this.name = 'AuthenticationError'
+  }
+}

package/src/formatters.test.ts

@@ -14,7 +14,7 @@ import {
   parseRoomList,
   parseRoomSlots,
   parseTeamInfo,
-} from '@/formatters'
+} from './formatters'
 
 describe('formatters', () => {
   test('parseMentoringList parses real list rows', () => {

package/src/formatters.ts

@@ -23,7 +23,7 @@ import {
   RoomCardSchema,
   type TeamInfo,
   TeamInfoSchema,
-} from '@/types'
+} from './types'
 
 type LabelMap = Record<string, string>
 
@@ -53,17 +53,26 @@ export function parseMentoringDetail(html: string, id = 0): MentoringDetail {
   const labels = { ...extractLabelMap(root), ...extractGroupMap(root) }
   const rawTitle = labels['모집 명'] || labels['제목'] || cleanText(root.querySelector('h1, h2, .title'))
   const dateText = labels['강의날짜'] || labels['진행날짜'] || ''
-  const contentNode = root.querySelector('.cont') ?? root.querySelector('.board-view-content') ?? root.querySelector('.view-content') ?? root.querySelector('.content-body') ?? root.querySelector('#contents')
+  const contentNode =
+    root.querySelector('.cont') ??
+    root.querySelector('.board-view-content') ??
+    root.querySelector('.view-content') ??
+    root.querySelector('.content-body') ??
+    root.querySelector('#contents')
 
   return MentoringDetailSchema.parse({
     id: id || extractNumber(root.querySelector('[name="qustnrSn"]')?.getAttribute('value') ?? ''),
     title: stripMentoringStatus(stripMentoringPrefix(rawTitle)),
-    type: extractMentoringType(labels['유형'] || root.querySelector('[name="reportCd"]')?.getAttribute('value') || rawTitle),
+    type: extractMentoringType(
+      labels['유형'] || root.querySelector('[name="reportCd"]')?.getAttribute('value') || rawTitle,
+    ),
     registrationPeriod: extractDateRange(labels['접수 기간'] || labels['접수기간'] || ''),
     sessionDate: extractFirstDate(dateText),
     sessionTime: extractTimeRange(dateText),
     attendees: {
-      current: extractNumber(labels['신청인원'] || labels['현재인원'] || cleanText(root.querySelector('.total-normal')) || ''),
+      current: extractNumber(
+        labels['신청인원'] || labels['현재인원'] || cleanText(root.querySelector('.total-normal')) || '',
+      ),
       max: extractNumber(labels['모집인원'] || labels['수강인원'] || ''),
     },
     approved: /OK/i.test(labels['개설 승인'] || labels['개설승인'] || ''),
@@ -161,7 +170,12 @@ export function parseNoticeDetail(html: string, id = 0): NoticeDetail {
   const spans = top?.querySelectorAll('.etc span') ?? []
   const author = extractPrefixedValue(spans, '작성자') || labels['작성자'] || ''
   const createdAt = extractPrefixedValue(spans, '등록일') || labels['등록일'] || ''
-  const contentNode = root.querySelector('.bbs-view .cont') ?? root.querySelector('.board-view-content') ?? root.querySelector('.view-content') ?? root.querySelector('.content-body') ?? root.querySelector('#contents')
+  const contentNode =
+    root.querySelector('.bbs-view .cont') ??
+    root.querySelector('.board-view-content') ??
+    root.querySelector('.view-content') ??
+    root.querySelector('.content-body') ??
+    root.querySelector('#contents')
 
   return NoticeDetailSchema.parse({
     id: id || extractNumber(root.querySelector('[name="nttId"]')?.getAttribute('value') ?? ''),
@@ -314,28 +328,42 @@ function extractGroupMap(root: HTMLElement): LabelMap {
 function parseDashboardLinks(
   root: HTMLElement,
   predicate: (href: string) => boolean,
-): Array<{ title: string; url: string; status: string }> {
+): Array<{
+  title: string
+  url: string
+  status: string
+  date?: string
+  time?: string
+  venue?: string
+}> {
   return root
     .querySelectorAll('ul.bbs-dash_w a')
     .filter((link) => predicate(link.getAttribute('href') ?? ''))
     .map((link) => {
-    const text = cleanText(link)
-    return {
-      title: stripTrailingStatus(text),
-      url: link.getAttribute('href') ?? '',
-      status: extractTrailingStatus(text),
-    }
-  })
+      const text = cleanText(link)
+      const { cleanTitle, date, time, venue } = extractDateTimeFromTitle(text)
+      return {
+        title: stripTrailingStatus(cleanTitle),
+        url: link.getAttribute('href') ?? '',
+        status: extractTrailingStatus(text),
+        date,
+        time,
+        venue,
+      }
+    })
 }
 
 function parseTimeSlotsFromRoot(root: HTMLElement): RoomCard['timeSlots'] {
   const grid = root.querySelector('.time-grid')
-  const spans = grid ? grid.querySelectorAll('span') : root.querySelectorAll('.time-grid span, [class*="time-slot"], .slot')
+  const spans = grid
+    ? grid.querySelectorAll('span')
+    : root.querySelectorAll('.time-grid span, [class*="time-slot"], .slot')
 
   return spans
     .map((slot) => ({
       time: cleanText(slot),
-      available: !(slot.getAttribute('class') ?? '').includes('not-reserve') &&
+      available:
+        !(slot.getAttribute('class') ?? '').includes('not-reserve') &&
         !(slot.getAttribute('class') ?? '').includes('booked') &&
         !(slot.getAttribute('class') ?? '').includes('disabled'),
     }))
@@ -349,12 +377,16 @@ function findDashboardValue(items: HTMLElement[], label: string): string {
 
 function extractDashEtcValue(container: HTMLElement | null | undefined, label: string): string {
   const match = (container?.querySelectorAll('span') ?? []).find((item) => cleanText(item).startsWith(label))
-  return cleanText(match).replace(new RegExp(`^${escapeRegex(label)}\\s*:`), '').trim()
+  return cleanText(match)
+    .replace(new RegExp(`^${escapeRegex(label)}\\s*:`), '')
+    .trim()
 }
 
 function findListText(card: HTMLElement, label: string): string {
   const item = card.querySelectorAll('.txt > li').find((entry) => cleanText(entry).startsWith(label))
-  return cleanText(item).replace(new RegExp(`^${escapeRegex(label)}\\s*:`), '').trim()
+  return cleanText(item)
+    .replace(new RegExp(`^${escapeRegex(label)}\\s*:`), '')
+    .trim()
 }
 
 function extractLocationHref(onclick: string | undefined): string {
@@ -440,6 +472,45 @@ function extractTrailingStatus(text: string): string {
   return match?.[1] ?? ''
 }
 
+function extractDateTimeFromTitle(text: string): {
+  cleanTitle: string
+  date?: string
+  time?: string
+  venue?: string
+} {
+  // Match date patterns: 2025-04-15 or 2025.04.15
+  const dateMatch = text.match(/(\d{4}[.-]\d{2}[.-]\d{2})/)
+  // Match time patterns: 14:00~16:00 or 14:00
+  const timeMatch = text.match(/(\d{2}:\d{2}(?:~\d{2}:\d{2})?)/)
+  // Match venue patterns: 스페이스 A1, A1, 강의실, etc.
+  const venueMatch = text.match(/(스페이스\s*[A-Z]\d+|강의실\s*\d+|회의실\s*[A-Z]?\d+|A\d|B\d|C\d)/i)
+
+  let cleanTitle = text
+  let date: string | undefined
+  let time: string | undefined
+  let venue: string | undefined
+
+  if (dateMatch) {
+    date = dateMatch[1].replace(/\./g, '-')
+    cleanTitle = cleanTitle.replace(dateMatch[0], '')
+  }
+
+  if (timeMatch) {
+    time = timeMatch[1]
+    cleanTitle = cleanTitle.replace(timeMatch[0], '')
+  }
+
+  if (venueMatch) {
+    venue = venueMatch[1]
+    cleanTitle = cleanTitle.replace(venueMatch[0], '')
+  }
+
+  // Clean up remaining whitespace and punctuation
+  cleanTitle = cleanTitle.replace(/^[\s\-~]+|[\s\-~]+$/g, '').trim()
+
+  return { cleanTitle, date, time, venue }
+}
+
 function stripTrailingStatus(text: string): string {
   return text.replace(/\s*(예약완료|예약중|대기|접수중|마감|승인완료|신청완료)$/, '').trim()
 }
@@ -467,7 +538,9 @@ function escapeRegex(text: string): string {
 
 function extractPrefixedValue(nodes: HTMLElement[], label: string): string {
   const match = nodes.find((node) => cleanText(node).includes(label))
-  return cleanText(match).replace(new RegExp(`^${escapeRegex(label)}\\s*:`), '').trim()
+  return cleanText(match)
+    .replace(new RegExp(`^${escapeRegex(label)}\\s*:`), '')
+    .trim()
 }
 
 function normalizeDate(value: string): string {