opensoma 0.2.0 → 0.3.0

package/src/commands/auth.ts

@@ -2,14 +2,86 @@ import { Command } from 'commander'
 
 import { CredentialManager } from '../credential-manager'
 import { SomaHttp } from '../http'
+import { recoverSession } from '../session-recovery'
 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()
+}
+
+async function promptPassword(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)
+  }
+
+  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')
+          }
+        } else if (code >= 32 && code <= 126) {
+          // Printable characters
+          password += char
+          process.stdout.write('*')
+        }
+      }
+    }
+  } finally {
+    if (originalStdin?.setRawMode) {
+      originalStdin.setRawMode(false)
+    }
+  }
+
+  return password
+}
+
 type LoginOptions = { username?: string; password?: string; pretty?: boolean }
 type StatusOptions = { pretty?: boolean }
 type ExtractOptions = { pretty?: boolean }
 type ExtractedSessionValidator = Pick<SomaHttp, 'checkLogin' | 'extractCsrfToken'>
+type CredentialStore = Pick<CredentialManager, 'getCredentials' | 'remove' | 'setCredentials'>
+type StatusValidator = Pick<SomaHttp, 'checkLogin'>
+type ReloginHttp = Pick<SomaHttp, 'checkLogin' | 'getCsrfToken' | 'getSessionCookie' | 'login'>
+type BrowserExtractor = () => Promise<{ csrfToken: string; sessionCookie: string } | null>
+
+async function defaultExtractBrowserCredentials(): Promise<{ csrfToken: string; sessionCookie: string } | null> {
+  const { TokenExtractor } = (await import('../token-extractor')) as {
+    TokenExtractor: new () => { extractCandidates: () => Promise<ExtractedSessionCandidate[]> }
+  }
+  const candidates = await new TokenExtractor().extractCandidates()
+  if (candidates.length === 0) return null
+  return resolveExtractedCredentials(candidates)
+}
+
+const EXPIRED_SESSION_HINT = 'Session expired. Run: opensoma auth login or opensoma auth extract'
+const UNVERIFIED_SESSION_HINT =
+  'Could not verify session. Try again or run: opensoma auth login or opensoma auth extract'
 
 export async function resolveExtractedCredentials(
   candidates: ExtractedSessionCandidate[],
@@ -37,10 +109,18 @@ export async function resolveExtractedCredentials(
 
 async function loginAction(options: LoginOptions): Promise<void> {
   try {
-    const username = options.username ?? process.env.OPENSOMA_USERNAME
-    const password = options.password ?? process.env.OPENSOMA_PASSWORD
+    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: ')
+    }
+
     if (!username || !password) {
-      throw new Error('Provide --username and --password or set OPENSOMA_USERNAME and OPENSOMA_PASSWORD')
+      throw new Error('Username and password are required')
     }
 
     const http = new SomaHttp()
@@ -65,6 +145,7 @@ async function loginAction(options: LoginOptions): Promise<void> {
       sessionCookie,
       csrfToken,
       username,
+      password,
       loggedInAt: new Date().toISOString(),
     })
 
@@ -76,42 +157,107 @@ async function loginAction(options: LoginOptions): Promise<void> {
 
 async function logoutAction(options: StatusOptions): Promise<void> {
   try {
-    await new CredentialManager().remove()
-    console.log(formatOutput({ ok: true, loggedIn: false }, options.pretty))
+    const manager = new CredentialManager()
+    const credentials = await manager.getCredentials()
+    let upstreamLoggedOut = false
+
+    if (credentials) {
+      const http = new SomaHttp({ sessionCookie: credentials.sessionCookie, csrfToken: credentials.csrfToken })
+
+      try {
+        await http.logout()
+        upstreamLoggedOut = true
+      } catch {}
+    }
+
+    await manager.remove()
+    console.log(formatOutput({ ok: true, loggedIn: false, upstreamLoggedOut }, options.pretty))
   } catch (error) {
     handleError(error)
   }
 }
 
-async function statusAction(options: StatusOptions): Promise<void> {
+export async function inspectStoredAuthStatus(
+  manager: CredentialStore = new CredentialManager(),
+  createValidator: (credentials: { sessionCookie: string; csrfToken: string }) => StatusValidator = (credentials) =>
+    new SomaHttp({ sessionCookie: credentials.sessionCookie, csrfToken: credentials.csrfToken }),
+  createReloginHttp: () => ReloginHttp = () => new SomaHttp(),
+  recoverViaBrowser: BrowserExtractor = defaultExtractBrowserCredentials,
+): Promise<Record<string, boolean | null | string>> {
+  const creds = await manager.getCredentials()
+  if (!creds) {
+    return { authenticated: false, credentials: null }
+  }
+
+  let identity = null
   try {
-    const manager = new CredentialManager()
-    const creds = await manager.getCredentials()
-    if (!creds) {
-      console.log(formatOutput({ authenticated: false, credentials: null }, options.pretty))
-      return
+    identity = await createValidator(creds).checkLogin()
+  } catch {
+    return {
+      authenticated: true,
+      valid: false,
+      username: creds.username ?? null,
+      loggedInAt: creds.loggedInAt ?? null,
+      hint: UNVERIFIED_SESSION_HINT,
     }
+  }
 
-    let valid = false
+  if (!identity) {
     try {
-      const http = new SomaHttp({ sessionCookie: creds.sessionCookie, csrfToken: creds.csrfToken })
-      valid = Boolean(await http.checkLogin())
+      const refreshedCredentials = await recoverSession(creds, manager, createReloginHttp)
+      if (refreshedCredentials) {
+        return {
+          authenticated: true,
+          valid: true,
+          username: refreshedCredentials.username ?? null,
+          loggedInAt: refreshedCredentials.loggedInAt ?? null,
+        }
+      }
     } catch {
-      valid = false
+      return {
+        authenticated: true,
+        valid: false,
+        username: creds.username ?? null,
+        loggedInAt: creds.loggedInAt ?? null,
+        hint: UNVERIFIED_SESSION_HINT,
+      }
     }
 
-    console.log(
-      formatOutput(
-        {
-          authenticated: true,
-          valid,
-          username: creds.username ?? null,
-          loggedInAt: creds.loggedInAt ?? null,
-          ...(valid ? {} : { hint: 'Session expired. Run: opensoma auth login or opensoma auth extract' }),
-        },
-        options.pretty,
-      ),
-    )
+    try {
+      const extracted = await recoverViaBrowser()
+      if (extracted) {
+        const loggedInAt = new Date().toISOString()
+        await manager.setCredentials({
+          sessionCookie: extracted.sessionCookie,
+          csrfToken: extracted.csrfToken,
+          loggedInAt,
+        })
+        return { authenticated: true, valid: true, username: null, loggedInAt }
+      }
+    } catch {
+      // Browser extraction failed — fall through to credential removal
+    }
+
+    await manager.remove()
+    return {
+      authenticated: false,
+      credentials: null,
+      clearedStaleCredentials: true,
+      hint: EXPIRED_SESSION_HINT,
+    }
+  }
+
+  return {
+    authenticated: true,
+    valid: true,
+    username: creds.username ?? null,
+    loggedInAt: creds.loggedInAt ?? null,
+  }
+}
+
+async function statusAction(options: StatusOptions): Promise<void> {
+  try {
+    console.log(formatOutput(await inspectStoredAuthStatus(), options.pretty))
   } catch (error) {
     handleError(error)
   }
@@ -160,7 +306,7 @@ export const authCommand = new Command('auth')
   )
   .addCommand(
     new Command('logout')
-      .description('Remove saved credentials')
+      .description('Log out upstream session and remove saved credentials')
       .option('--pretty', 'Pretty print JSON output')
       .action(logoutAction),
   )

package/src/commands/helpers.test.ts

@@ -0,0 +1,216 @@
+import { describe, expect, test } from 'bun:test'
+
+import { createAuthenticatedHttp } from './helpers'
+
+const noBrowserExtraction = async () => null
+
+describe('createAuthenticatedHttp', () => {
+  test('throws a login hint when no credentials are stored', async () => {
+    const manager = {
+      getCredentials: async () => null,
+      remove: async () => {},
+    }
+
+    await expect(createAuthenticatedHttp(manager)).rejects.toThrow(
+      'Not logged in. Run: opensoma auth login or opensoma auth extract',
+    )
+  })
+
+  test('clears stale credentials when both recovery methods fail', async () => {
+    let removed = false
+    const manager = {
+      getCredentials: async () => ({
+        sessionCookie: 'stale-session',
+        csrfToken: 'csrf-token',
+      }),
+      setCredentials: async () => {
+        throw new Error('should not save unrecoverable credentials')
+      },
+      remove: async () => {
+        removed = true
+      },
+    }
+
+    await expect(
+      createAuthenticatedHttp(manager, () => ({ checkLogin: async () => null }), undefined, noBrowserExtraction),
+    ).rejects.toThrow(
+      'Session expired. Saved credentials were cleared. Run: opensoma auth login or opensoma auth extract',
+    )
+    expect(removed).toBe(true)
+  })
+
+  test('returns the authenticated http client when the session is valid', async () => {
+    const http = {
+      checkLogin: async () => ({ userId: 'neo@example.com', userNm: '전수열' }),
+      get: async () => '',
+    }
+    const manager = {
+      getCredentials: async () => ({
+        sessionCookie: 'valid-session',
+        csrfToken: 'csrf-token',
+      }),
+      setCredentials: async () => {
+        throw new Error('should not rewrite valid credentials')
+      },
+      remove: async () => {
+        throw new Error('should not remove valid credentials')
+      },
+    }
+
+    await expect(createAuthenticatedHttp(manager, () => http)).resolves.toBe(http)
+  })
+
+  test('re-authenticates automatically when stored username/password are available', async () => {
+    let savedCredentials: Record<string, string> | null = null
+    const manager = {
+      getCredentials: async () => ({
+        sessionCookie: 'stale-session',
+        csrfToken: 'stale-csrf',
+        username: 'neo@example.com',
+        password: 'secret',
+      }),
+      setCredentials: async (credentials: Record<string, string>) => {
+        savedCredentials = credentials
+      },
+      remove: async () => {
+        throw new Error('should not remove recoverable credentials')
+      },
+    }
+    const recoveredHttp = {
+      checkLogin: async () => ({ userId: 'neo@example.com', userNm: 'Neo' }),
+      get: async () => '',
+    }
+
+    await expect(
+      createAuthenticatedHttp(
+        manager,
+        (credentials) => {
+          if (credentials.sessionCookie === 'fresh-session') {
+            return recoveredHttp
+          }
+
+          return {
+            checkLogin: async () => null,
+          }
+        },
+        () => ({
+          login: async () => {},
+          checkLogin: async () => ({ userId: 'neo@example.com', userNm: 'Neo' }),
+          getSessionCookie: () => 'fresh-session',
+          getCsrfToken: () => 'fresh-csrf',
+        }),
+      ),
+    ).resolves.toBe(recoveredHttp)
+
+    expect(savedCredentials).toMatchObject({
+      sessionCookie: 'fresh-session',
+      csrfToken: 'fresh-csrf',
+      username: 'neo@example.com',
+      password: 'secret',
+    })
+  })
+
+  test('recovers via browser extraction when no stored password is available', async () => {
+    let savedCredentials: Record<string, unknown> | null = null
+    const manager = {
+      getCredentials: async () => ({
+        sessionCookie: 'stale-session',
+        csrfToken: 'stale-csrf',
+      }),
+      setCredentials: async (credentials: Record<string, unknown>) => {
+        savedCredentials = credentials
+      },
+      remove: async () => {
+        throw new Error('should not remove when browser extraction succeeds')
+      },
+    }
+    const recoveredHttp = {
+      checkLogin: async () => ({ userId: 'neo@example.com', userNm: 'Neo' }),
+    }
+
+    const result = await createAuthenticatedHttp(
+      manager,
+      (credentials) => {
+        if (credentials.sessionCookie === 'browser-session') return recoveredHttp
+        return { checkLogin: async () => null }
+      },
+      undefined,
+      async () => ({ sessionCookie: 'browser-session', csrfToken: 'browser-csrf' }),
+    )
+
+    expect(result).toBe(recoveredHttp)
+    expect(savedCredentials).toMatchObject({
+      sessionCookie: 'browser-session',
+      csrfToken: 'browser-csrf',
+    })
+    expect(savedCredentials).toHaveProperty('loggedInAt')
+  })
+
+  test('falls back to browser extraction when password re-login throws', async () => {
+    let savedCredentials: Record<string, unknown> | null = null
+    const manager = {
+      getCredentials: async () => ({
+        sessionCookie: 'stale-session',
+        csrfToken: 'stale-csrf',
+        username: 'neo@example.com',
+        password: 'wrong-password',
+      }),
+      setCredentials: async (credentials: Record<string, unknown>) => {
+        savedCredentials = credentials
+      },
+      remove: async () => {
+        throw new Error('should not remove when browser extraction succeeds')
+      },
+    }
+    const recoveredHttp = {
+      checkLogin: async () => ({ userId: 'neo@example.com', userNm: 'Neo' }),
+    }
+
+    const result = await createAuthenticatedHttp(
+      manager,
+      (credentials) => {
+        if (credentials.sessionCookie === 'browser-session') return recoveredHttp
+        return { checkLogin: async () => null }
+      },
+      () => ({
+        login: async () => {
+          throw new Error('wrong password')
+        },
+        checkLogin: async () => null,
+        getSessionCookie: () => null,
+        getCsrfToken: () => null,
+      }),
+      async () => ({ sessionCookie: 'browser-session', csrfToken: 'browser-csrf' }),
+    )
+
+    expect(result).toBe(recoveredHttp)
+    expect(savedCredentials).toMatchObject({
+      sessionCookie: 'browser-session',
+      csrfToken: 'browser-csrf',
+    })
+  })
+
+  test('does not attempt browser extraction when no credentials exist', async () => {
+    let browserExtractionCalled = false
+    const manager = {
+      getCredentials: async () => null,
+      setCredentials: async () => {
+        throw new Error('should not save')
+      },
+      remove: async () => {},
+    }
+
+    await expect(
+      createAuthenticatedHttp(
+        manager,
+        () => ({ checkLogin: async () => null }),
+        undefined,
+        async () => {
+          browserExtractionCalled = true
+          return { sessionCookie: 's', csrfToken: 'c' }
+        },
+      ),
+    ).rejects.toThrow('Not logged in')
+    expect(browserExtractionCalled).toBe(false)
+  })
+})

package/src/commands/helpers.ts

@@ -1,29 +1,94 @@
 import { CredentialManager } from '../credential-manager'
 import { SomaHttp } from '../http'
+import { recoverSession } from '../session-recovery'
+import * as stderr from '../shared/utils/stderr'
+import type { Credentials } from '../types'
 
-export async function getHttpOrExit(): Promise<SomaHttp> {
-  const manager = new CredentialManager()
+type CredentialStore = Pick<CredentialManager, 'getCredentials' | 'remove' | 'setCredentials'>
+type AuthenticatedHttp = Pick<SomaHttp, 'checkLogin'>
+type ReloginHttp = Pick<SomaHttp, 'checkLogin' | 'getCsrfToken' | 'getSessionCookie' | 'login'>
+type BrowserExtractor = () => Promise<{ csrfToken: string; sessionCookie: string } | null>
+
+const NOT_LOGGED_IN_MESSAGE = 'Not logged in. Run: opensoma auth login or opensoma auth extract'
+const STALE_SESSION_MESSAGE =
+  'Session expired. Saved credentials were cleared. Run: opensoma auth login or opensoma auth extract'
+
+function defaultCreateHttp(credentials: Credentials): SomaHttp {
+  return new SomaHttp({ sessionCookie: credentials.sessionCookie, csrfToken: credentials.csrfToken })
+}
+
+async function defaultExtractBrowserCredentials(): Promise<{ csrfToken: string; sessionCookie: string } | null> {
+  const { TokenExtractor } = await import('../token-extractor')
+  const { resolveExtractedCredentials } = await import('./auth')
+  const candidates = await new TokenExtractor().extractCandidates()
+  if (candidates.length === 0) return null
+  return resolveExtractedCredentials(candidates)
+}
+
+export function createAuthenticatedHttp(): Promise<SomaHttp>
+export function createAuthenticatedHttp<T extends AuthenticatedHttp>(
+  manager: CredentialStore,
+  createHttp: (credentials: Credentials) => T,
+  createReloginHttp?: () => ReloginHttp,
+  recoverViaBrowser?: BrowserExtractor,
+): Promise<T>
+export async function createAuthenticatedHttp<T extends AuthenticatedHttp>(
+  manager: CredentialStore = new CredentialManager(),
+  createHttp?: (credentials: Credentials) => T,
+  createReloginHttp: () => ReloginHttp = () => new SomaHttp(),
+  recoverViaBrowser: BrowserExtractor = defaultExtractBrowserCredentials,
+): Promise<SomaHttp | T> {
   const creds = await manager.getCredentials()
   if (!creds) {
-    console.error(
-      JSON.stringify({
-        error: 'Not logged in. Run: opensoma auth login or opensoma auth extract',
-      }),
-    )
-    process.exit(1)
+    throw new Error(NOT_LOGGED_IN_MESSAGE)
   }
 
-  const http = new SomaHttp({ sessionCookie: creds.sessionCookie, csrfToken: creds.csrfToken })
+  const http = createHttp ? createHttp(creds) : defaultCreateHttp(creds)
 
   const identity = await http.checkLogin()
   if (!identity) {
+    try {
+      const refreshedCredentials = await recoverSession(creds, manager, createReloginHttp)
+      if (refreshedCredentials) {
+        return createHttp ? createHttp(refreshedCredentials) : defaultCreateHttp(refreshedCredentials)
+      }
+    } catch {
+      // Password recovery failed — try browser extraction next
+    }
+
+    try {
+      stderr.info('Session expired. Attempting browser token extraction...')
+      const extracted = await recoverViaBrowser()
+      if (extracted) {
+        const browserCredentials: Credentials = {
+          sessionCookie: extracted.sessionCookie,
+          csrfToken: extracted.csrfToken,
+          loggedInAt: new Date().toISOString(),
+        }
+        await manager.setCredentials(browserCredentials)
+        stderr.info('Browser token extraction successful.')
+        return createHttp ? createHttp(browserCredentials) : defaultCreateHttp(browserCredentials)
+      }
+    } catch {
+      // Browser extraction also failed
+    }
+
+    await manager.remove()
+    throw new Error(STALE_SESSION_MESSAGE)
+  }
+
+  return http
+}
+
+export async function getHttpOrExit(): Promise<SomaHttp> {
+  try {
+    return await createAuthenticatedHttp()
+  } catch (error) {
     console.error(
       JSON.stringify({
-        error: 'Session expired. Run: opensoma auth login or opensoma auth extract',
+        error: error instanceof Error ? error.message : STALE_SESSION_MESSAGE,
       }),
     )
     process.exit(1)
   }
-
-  return http
 }

package/src/commands/index.ts

@@ -6,3 +6,4 @@ export { noticeCommand } from './notice'
 export { teamCommand } from './team'
 export { memberCommand } from './member'
 export { eventCommand } from './event'
+export { reportCommand } from './report'

package/src/commands/mentoring.ts

@@ -10,6 +10,7 @@ import {
   buildCancelApplicationPayload,
   buildDeleteMentoringPayload,
   buildMentoringPayload,
+  buildUpdateMentoringPayload,
 } from '../shared/utils/swmaestro'
 import { getHttpOrExit } from './helpers'
 
@@ -34,6 +35,19 @@ type CreateOptions = {
   content?: string
   pretty?: boolean
 }
+type UpdateOptions = {
+  title: string
+  type: 'public' | 'lecture'
+  date: string
+  start: string
+  end: string
+  venue: string
+  maxAttendees?: string
+  regStart?: string
+  regEnd?: string
+  content?: string
+  pretty?: boolean
+}
 type CancelOptions = { applySn: string; qustnrSn: string; pretty?: boolean }
 type HistoryOptions = { page?: string; pretty?: boolean }
 
@@ -103,6 +117,30 @@ async function createAction(options: CreateOptions): Promise<void> {
   }
 }
 
+async function updateAction(id: string, options: UpdateOptions): Promise<void> {
+  try {
+    const http = await getHttpOrExit()
+    await http.post(
+      '/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,
+      }),
+    )
+    console.log(formatOutput({ ok: true }, options.pretty))
+  } catch (error) {
+    handleError(error)
+  }
+}
+
 async function deleteAction(id: string, options: GetOptions): Promise<void> {
   try {
     const http = await getHttpOrExit()
@@ -195,6 +233,23 @@ export const mentoringCommand = new Command('mentoring')
       .option('--pretty', 'Pretty print JSON output')
       .action(createAction),
   )
+  .addCommand(
+    new Command('update')
+      .description('Update a mentoring session')
+      .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('--max-attendees <count>', 'Maximum attendees')
+      .option('--reg-start <date>', 'Registration start date')
+      .option('--reg-end <date>', 'Registration end date')
+      .option('--content <html>', 'HTML content')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(updateAction),
+  )
   .addCommand(
     new Command('delete')
       .description('Delete a mentoring session')