opensoma 0.5.1 → 0.6.0

package/src/commands/auth.test.ts

@@ -57,21 +57,72 @@ describe('resolveExtractedCredentials', () => {
 })
 
 describe('inspectStoredAuthStatus', () => {
-  it('clears stale credentials when both recovery methods fail', async () => {
-    let removed = false
+  it('clears session state but preserves saved id/password when both recovery methods fail', async () => {
+    let cleared = false
+    let postClearCredentials = {
+      sessionCookie: '',
+      csrfToken: '',
+      username: 'mentor@example.com',
+      password: 'secret-password',
+    }
 
     const status = await inspectStoredAuthStatus(
       {
-        getCredentials: async () => ({
-          sessionCookie: 'stale-session',
-          csrfToken: 'csrf-token',
-          username: 'neo@example.com',
-        }),
+        getCredentials: async () => {
+          if (cleared) return postClearCredentials
+          return {
+            sessionCookie: 'stale-session',
+            csrfToken: 'csrf-token',
+            username: 'mentor@example.com',
+            password: 'secret-password',
+          }
+        },
+        setCredentials: async () => {
+          throw new Error('inspectStoredAuthStatus must not write credentials directly on the failure path')
+        },
+        clearSessionState: async () => {
+          cleared = true
+        },
+      },
+      () => ({
+        checkLogin: async () => null,
+      }),
+      () => ({
+        login: async () => {},
+        checkLogin: async () => null,
+        getSessionCookie: () => null,
+        getCsrfToken: () => null,
+      }),
+      noBrowserExtraction,
+    )
+
+    expect(status).toEqual({
+      authenticated: false,
+      credentials: null,
+      clearedStaleSession: true,
+      preservedRecoveryCredentials: true,
+      hint: 'Session expired. Run: opensoma auth login or opensoma auth extract',
+    })
+    expect(cleared).toBe(true)
+  })
+
+  it('reports preservedRecoveryCredentials=false when no recovery material was stored', async () => {
+    let cleared = false
+
+    const status = await inspectStoredAuthStatus(
+      {
+        getCredentials: async () => {
+          if (cleared) return null
+          return {
+            sessionCookie: 'stale-session',
+            csrfToken: 'csrf-token',
+          }
+        },
         setCredentials: async () => {
-          throw new Error('should not save unrecoverable credentials')
+          throw new Error('should not write credentials')
         },
-        remove: async () => {
-          removed = true
+        clearSessionState: async () => {
+          cleared = true
         },
       },
       () => ({
@@ -84,28 +135,28 @@ describe('inspectStoredAuthStatus', () => {
     expect(status).toEqual({
       authenticated: false,
       credentials: null,
-      clearedStaleCredentials: true,
+      clearedStaleSession: true,
+      preservedRecoveryCredentials: false,
       hint: 'Session expired. Run: opensoma auth login or opensoma auth extract',
     })
-    expect(removed).toBe(true)
   })
 
   it('preserves credentials when session verification fails unexpectedly', async () => {
-    let removed = false
+    let cleared = false
 
     const status = await inspectStoredAuthStatus(
       {
         getCredentials: async () => ({
           sessionCookie: 'maybe-valid-session',
           csrfToken: 'csrf-token',
-          username: 'neo@example.com',
+          username: 'mentor@example.com',
           loggedInAt: '2026-04-13T00:00:00.000Z',
         }),
         setCredentials: async () => {
           throw new Error('should not rewrite credentials when verification fails')
         },
-        remove: async () => {
-          removed = true
+        clearSessionState: async () => {
+          cleared = true
         },
       },
       () => ({
@@ -118,11 +169,11 @@ describe('inspectStoredAuthStatus', () => {
     expect(status).toEqual({
       authenticated: true,
       valid: false,
-      username: 'neo@example.com',
+      username: 'mentor@example.com',
       loggedInAt: '2026-04-13T00:00:00.000Z',
       hint: 'Could not verify session. Try again or run: opensoma auth login or opensoma auth extract',
     })
-    expect(removed).toBe(false)
+    expect(cleared).toBe(false)
   })
 
   it('recovers via browser extraction when no stored password is available', async () => {
@@ -137,8 +188,8 @@ describe('inspectStoredAuthStatus', () => {
         setCredentials: async (credentials: Record<string, unknown>) => {
           savedCredentials = credentials
         },
-        remove: async () => {
-          throw new Error('should not remove when browser extraction succeeds')
+        clearSessionState: async () => {
+          throw new Error('should not clear session state when browser extraction succeeds')
         },
       },
       () => ({
@@ -168,15 +219,15 @@ describe('inspectStoredAuthStatus', () => {
         getCredentials: async () => ({
           sessionCookie: 'stale-session',
           csrfToken: 'stale-csrf',
-          username: 'neo@example.com',
+          username: 'mentor@example.com',
           password: 'secret',
           loggedInAt: '2026-04-13T00:00:00.000Z',
         }),
         setCredentials: async (credentials: Record<string, string>) => {
           savedCredentials = credentials
         },
-        remove: async () => {
-          throw new Error('should not remove recoverable credentials')
+        clearSessionState: async () => {
+          throw new Error('should not clear session state when re-login succeeds')
         },
       },
       () => ({
@@ -184,7 +235,7 @@ describe('inspectStoredAuthStatus', () => {
       }),
       () => ({
         login: async () => {},
-        checkLogin: async () => ({ userId: 'neo@example.com', userNm: 'Neo' }),
+        checkLogin: async () => ({ userId: 'mentor@example.com', userNm: 'Mentor One' }),
         getSessionCookie: () => 'fresh-session',
         getCsrfToken: () => 'fresh-csrf',
       }),
@@ -193,13 +244,13 @@ describe('inspectStoredAuthStatus', () => {
     expect(status).toEqual({
       authenticated: true,
       valid: true,
-      username: 'neo@example.com',
+      username: 'mentor@example.com',
       loggedInAt: expect.any(String),
     })
     expect(savedCredentials).toMatchObject({
       sessionCookie: 'fresh-session',
       csrfToken: 'fresh-csrf',
-      username: 'neo@example.com',
+      username: 'mentor@example.com',
       password: 'secret',
     })
   })

package/src/commands/auth.ts

@@ -103,7 +103,7 @@ type LoginOptions = { username?: string; password?: string; pretty?: boolean }
 type StatusOptions = { pretty?: boolean }
 type ExtractOptions = { debug?: boolean; pretty?: boolean }
 type ExtractedSessionValidator = Pick<SomaHttp, 'checkLogin' | 'extractCsrfToken'>
-type CredentialStore = Pick<CredentialManager, 'getCredentials' | 'remove' | 'setCredentials'>
+type CredentialStore = Pick<CredentialManager, 'clearSessionState' | 'getCredentials' | 'setCredentials'>
 type StatusValidator = Pick<SomaHttp, 'checkLogin'>
 type ReloginHttp = Pick<SomaHttp, 'checkLogin' | 'getCsrfToken' | 'getSessionCookie' | 'login'>
 type BrowserExtractor = () => Promise<{ csrfToken: string; sessionCookie: string } | null>
@@ -286,11 +286,13 @@ export async function inspectStoredAuthStatus(
       // Browser extraction failed — fall through to credential removal
     }
 
-    await manager.remove()
+    await manager.clearSessionState()
+    const post = await manager.getCredentials()
     return {
       authenticated: false,
       credentials: null,
-      clearedStaleCredentials: true,
+      clearedStaleSession: true,
+      preservedRecoveryCredentials: Boolean(post?.username || post?.password),
       hint: EXPIRED_SESSION_HINT,
     }
   }

package/src/commands/dashboard.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'bun:test'
+
+import type { SomaHttp } from '../http'
+import type { Dashboard } from '../types'
+import { showDashboard } from './dashboard'
+
+describe('showDashboard', () => {
+  it('prints the SDK dashboard response', async () => {
+    const dashboard: Dashboard = {
+      name: '김연수',
+      role: '17기 연수생',
+      organization: 'OpenSoma',
+      position: '',
+      mentoringSessions: [
+        {
+          title: '팀 프로젝트 방향성 피드백',
+          url: '/sw/mypage/mentoLec/view.do?qustnrSn=44',
+          status: '접수완료',
+          date: '2026-04-28',
+          time: '22:00',
+          timeEnd: '24:00',
+          type: '자유 멘토링',
+        },
+      ],
+      roomReservations: [],
+    }
+    const fakeHttp = {} as SomaHttp
+    const calls: string[] = []
+    const outputs: string[] = []
+
+    await showDashboard(
+      { pretty: true },
+      {
+        getHttp: async () => {
+          calls.push('getHttp')
+          return fakeHttp
+        },
+        createClient: (http) => {
+          expect(http).toBe(fakeHttp)
+          calls.push('createClient')
+          return {
+            dashboard: {
+              get: async () => {
+                calls.push('dashboard.get')
+                return dashboard
+              },
+            },
+          }
+        },
+        write: (output) => outputs.push(output),
+      },
+    )
+
+    expect(calls).toEqual(['getHttp', 'createClient', 'dashboard.get'])
+    expect(outputs).toEqual([JSON.stringify(dashboard, null, 2)])
+  })
+})

package/src/commands/dashboard.ts

@@ -1,31 +1,34 @@
 import { Command } from 'commander'
 
-import { MENU_NO } from '../constants'
-import * as formatters from '../formatters'
+import { SomaClient } from '../client'
+import type { SomaHttp } from '../http'
 import { handleError } from '../shared/utils/error-handler'
-import { buildMentoringListParams } from '../shared/utils/mentoring-params'
 import { formatOutput } from '../shared/utils/output'
 import { getHttpOrExit } from './helpers'
 
-type ShowOptions = { pretty?: boolean }
+export type ShowOptions = { pretty?: boolean }
+
+type DashboardClient = Pick<SomaClient, 'dashboard'>
+
+interface ShowDashboardDeps {
+  getHttp?: () => Promise<SomaHttp>
+  createClient?: (http: SomaHttp) => DashboardClient
+  write?: (output: string) => void
+}
+
+export async function showDashboard(options: ShowOptions, deps: ShowDashboardDeps = {}): Promise<void> {
+  const getHttp = deps.getHttp ?? getHttpOrExit
+  const createClient = deps.createClient ?? ((http) => new SomaClient({ http }))
+  const write = deps.write ?? ((output) => console.log(output))
+
+  const http = await getHttp()
+  const dashboard = await createClient(http).dashboard.get()
+  write(formatOutput(dashboard, options.pretty))
+}
 
 async function showAction(options: ShowOptions): Promise<void> {
   try {
-    const http = await getHttpOrExit()
-    const user = (await http.checkLogin()) ?? undefined
-    const search = { field: 'author' as const, value: '@me', me: true }
-    const [dashboardHtml, mentoringHtml] = await Promise.all([
-      http.get('/mypage/myMain/dashboard.do', { menuNo: MENU_NO.DASHBOARD }),
-      http.get('/mypage/mentoLec/list.do', buildMentoringListParams({ search, user })),
-    ])
-    const dashboard = formatters.parseDashboard(dashboardHtml)
-    const myMentoring = formatters.parseMentoringList(mentoringHtml)
-    dashboard.mentoringSessions = myMentoring.map((item) => ({
-      title: item.title,
-      url: `/mypage/mentoLec/view.do?qustnrSn=${item.id}`,
-      status: item.status,
-    }))
-    console.log(formatOutput(dashboard, options.pretty))
+    await showDashboard(options)
   } catch (error) {
     handleError(error)
   }

package/src/commands/helpers.test.ts

@@ -8,7 +8,7 @@ describe('createAuthenticatedHttp', () => {
   it('throws a login hint when no credentials are stored', async () => {
     const manager = {
       getCredentials: async () => null,
-      remove: async () => {},
+      clearSessionState: async () => {},
     }
 
     await expect(createAuthenticatedHttp(manager)).rejects.toThrow(
@@ -16,32 +16,79 @@ describe('createAuthenticatedHttp', () => {
     )
   })
 
-  it('clears stale credentials when both recovery methods fail', async () => {
-    let removed = false
+  it('clears only session state (not username/password) when both recovery methods fail', async () => {
+    let cleared = false
     const manager = {
       getCredentials: async () => ({
         sessionCookie: 'stale-session',
         csrfToken: 'csrf-token',
+        username: 'mentor@example.com',
+        password: 'secret-password',
       }),
       setCredentials: async () => {
-        throw new Error('should not save unrecoverable credentials')
+        throw new Error('createAuthenticatedHttp must not write credentials directly')
       },
-      remove: async () => {
-        removed = true
+      clearSessionState: async () => {
+        cleared = 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',
+      'Session expired. Run: opensoma auth login or opensoma auth extract (saved id/password were preserved)',
     )
-    expect(removed).toBe(true)
+    expect(cleared).toBe(true)
+  })
+
+  it('preserves stored id/password on disk when session expires and recovery fails', async () => {
+    const { CredentialManager } = await import('../credential-manager')
+    const { mkdtemp, rm } = await import('node:fs/promises')
+    const { tmpdir } = await import('node:os')
+    const { join } = await import('node:path')
+
+    const dir = await mkdtemp(join(tmpdir(), 'opensoma-helpers-'))
+    try {
+      const manager = new CredentialManager(dir)
+      await manager.setCredentials({
+        sessionCookie: 'stale-session',
+        csrfToken: 'stale-csrf',
+        username: 'mentor@example.com',
+        password: 'secret-password',
+        loggedInAt: '2026-04-09T00:00:00.000Z',
+      })
+
+      await expect(
+        createAuthenticatedHttp(
+          manager,
+          () => ({ checkLogin: async () => null }),
+          () => ({
+            login: async () => {
+              throw new Error('upstream rejected re-login')
+            },
+            checkLogin: async () => null,
+            getSessionCookie: () => null,
+            getCsrfToken: () => null,
+          }),
+          noBrowserExtraction,
+        ),
+      ).rejects.toThrow('Session expired')
+
+      const after = await manager.getCredentials()
+      expect(after).toEqual({
+        sessionCookie: '',
+        csrfToken: '',
+        username: 'mentor@example.com',
+        password: 'secret-password',
+      })
+    } finally {
+      await rm(dir, { force: true, recursive: true })
+    }
   })
 
   it('returns the authenticated http client when the session is valid', async () => {
     const http = {
-      checkLogin: async () => ({ userId: 'neo@example.com', userNm: '전수열' }),
+      checkLogin: async () => ({ userId: 'mentor@example.com', userNm: 'Mentor One' }),
       get: async () => '',
     }
     const manager = {
@@ -52,8 +99,8 @@ describe('createAuthenticatedHttp', () => {
       setCredentials: async () => {
         throw new Error('should not rewrite valid credentials')
       },
-      remove: async () => {
-        throw new Error('should not remove valid credentials')
+      clearSessionState: async () => {
+        throw new Error('should not clear session state for valid credentials')
       },
     }
 
@@ -66,18 +113,18 @@ describe('createAuthenticatedHttp', () => {
       getCredentials: async () => ({
         sessionCookie: 'stale-session',
         csrfToken: 'stale-csrf',
-        username: 'neo@example.com',
+        username: 'mentor@example.com',
         password: 'secret',
       }),
       setCredentials: async (credentials: Record<string, string>) => {
         savedCredentials = credentials
       },
-      remove: async () => {
-        throw new Error('should not remove recoverable credentials')
+      clearSessionState: async () => {
+        throw new Error('should not clear session state when re-login succeeds')
       },
     }
     const recoveredHttp = {
-      checkLogin: async () => ({ userId: 'neo@example.com', userNm: 'Neo' }),
+      checkLogin: async () => ({ userId: 'mentor@example.com', userNm: 'Mentor One' }),
       get: async () => '',
     }
 
@@ -95,7 +142,7 @@ describe('createAuthenticatedHttp', () => {
         },
         () => ({
           login: async () => {},
-          checkLogin: async () => ({ userId: 'neo@example.com', userNm: 'Neo' }),
+          checkLogin: async () => ({ userId: 'mentor@example.com', userNm: 'Mentor One' }),
           getSessionCookie: () => 'fresh-session',
           getCsrfToken: () => 'fresh-csrf',
         }),
@@ -105,7 +152,7 @@ describe('createAuthenticatedHttp', () => {
     expect(savedCredentials).toMatchObject({
       sessionCookie: 'fresh-session',
       csrfToken: 'fresh-csrf',
-      username: 'neo@example.com',
+      username: 'mentor@example.com',
       password: 'secret',
     })
   })
@@ -120,12 +167,12 @@ describe('createAuthenticatedHttp', () => {
       setCredentials: async (credentials: Record<string, unknown>) => {
         savedCredentials = credentials
       },
-      remove: async () => {
-        throw new Error('should not remove when browser extraction succeeds')
+      clearSessionState: async () => {
+        throw new Error('should not clear session state when browser extraction succeeds')
       },
     }
     const recoveredHttp = {
-      checkLogin: async () => ({ userId: 'neo@example.com', userNm: 'Neo' }),
+      checkLogin: async () => ({ userId: 'mentor@example.com', userNm: 'Mentor One' }),
     }
 
     const result = await createAuthenticatedHttp(
@@ -152,18 +199,18 @@ describe('createAuthenticatedHttp', () => {
       getCredentials: async () => ({
         sessionCookie: 'stale-session',
         csrfToken: 'stale-csrf',
-        username: 'neo@example.com',
+        username: 'mentor@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')
+      clearSessionState: async () => {
+        throw new Error('should not clear session state when browser extraction succeeds')
       },
     }
     const recoveredHttp = {
-      checkLogin: async () => ({ userId: 'neo@example.com', userNm: 'Neo' }),
+      checkLogin: async () => ({ userId: 'mentor@example.com', userNm: 'Mentor One' }),
     }
 
     const result = await createAuthenticatedHttp(
@@ -197,7 +244,7 @@ describe('createAuthenticatedHttp', () => {
       setCredentials: async () => {
         throw new Error('should not save')
       },
-      remove: async () => {},
+      clearSessionState: async () => {},
     }
 
     await expect(

package/src/commands/helpers.ts

@@ -4,14 +4,14 @@ import { recoverSession } from '../session-recovery'
 import * as stderr from '../shared/utils/stderr'
 import type { Credentials } from '../types'
 
-type CredentialStore = Pick<CredentialManager, 'getCredentials' | 'remove' | 'setCredentials'>
+type CredentialStore = Pick<CredentialManager, 'clearSessionState' | 'getCredentials' | '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'
+  'Session expired. Run: opensoma auth login or opensoma auth extract (saved id/password were preserved)'
 
 function defaultCreateHttp(credentials: Credentials): SomaHttp {
   return new SomaHttp({ sessionCookie: credentials.sessionCookie, csrfToken: credentials.csrfToken })
@@ -73,7 +73,7 @@ export async function createAuthenticatedHttp<T extends AuthenticatedHttp>(
       // Browser extraction also failed
     }
 
-    await manager.remove()
+    await manager.clearSessionState()
     throw new Error(STALE_SESSION_MESSAGE)
   }
 

package/src/commands/index.ts

@@ -1,3 +1,4 @@
+export { agentBrowserCommand } from './agent-browser'
 export { authCommand } from './auth'
 export { mentoringCommand } from './mentoring'
 export { roomCommand } from './room'
@@ -5,5 +6,5 @@ export { dashboardCommand } from './dashboard'
 export { noticeCommand } from './notice'
 export { teamCommand } from './team'
 export { memberCommand } from './member'
-export { eventCommand } from './event'
+export { scheduleCommand } from './schedule'
 export { reportCommand } from './report'