opensoma 0.8.0 → 0.9.0

package/src/client.test.ts

@@ -654,10 +654,10 @@ describe('SomaClient', () => {
     const today = new Date().toISOString().slice(0, 10)
     const todayDotted = today.replaceAll('-', '.')
     const { http, calls } = createFakeHttp({
-      identity: { userId: 'trainee@example.com', userNm: '김연수' },
+      identity: { userId: 'trainee@example.com', userNm: 'Trainee One', userNo: 'trainee-1', userGb: UserGb.Trainee },
       getBody: (path, data) => {
         if (path === '/mypage/myMain/dashboard.do') {
-          return '<ul class="dash-top"><li class="dash-card"><div class="dash-etc"><span>소속 :<br> OpenSoma</span><span>직책 :<br> </span></div><div class="dash-state"><div class="top"><span class="bg-blue label"><span>17기 연수생</span></span><div class="welcome"><strong>김연수</strong>님 안녕하세요.</div></div></div></li></ul><ul class="bbs-dash_w"><li>멘토링 · 멘토특강<li><a href="/sw/mypage/mentoLec/view.do?qustnrSn=999">네이티브 항목 접수중</a></li></li></ul>'
+          return '<ul class="dash-top"><li class="dash-card"><div class="dash-etc"><span>소속 :<br> OpenSoma</span><span>직책 :<br> </span></div><div class="dash-state"><div class="top"><span class="bg-blue label"><span>17기 연수생</span></span><div class="welcome"><strong>Trainee One</strong>님 안녕하세요.</div></div></div></li></ul><ul class="bbs-dash_w"><li>멘토링 · 멘토특강<li><a href="/sw/mypage/mentoLec/view.do?qustnrSn=999">네이티브 항목 접수중</a></li></li></ul>'
         }
         if (path === '/mypage/userAnswer/history.do') {
           const page = Number(data?.pageIndex ?? '1')
@@ -710,6 +710,58 @@ describe('SomaClient', () => {
     expect(calls.some((c) => c.path === '/mypage/mentoLec/list.do')).toBe(false)
   })
 
+  it('uses checkLogin userGb instead of dashboard role to choose the trainee dashboard source', async () => {
+    const { http, calls } = createFakeHttp({
+      identity: { userId: 'trainee@example.com', userNm: 'Trainee One', userNo: 'trainee-1', userGb: UserGb.Trainee },
+      getBody: (path) => {
+        if (path === '/mypage/myMain/dashboard.do') {
+          return '<ul class="dash-top"><li class="dash-card"><div class="dash-etc"><span>소속 :<br> Org</span><span>직책 :<br> </span></div><div class="dash-state"><div class="top"><span class="bg-orange label"><span>멘토</span></span><div class="welcome"><strong>Trainee One</strong>님 안녕하세요.</div></div></div></li></ul>'
+        }
+        if (path === '/mypage/userAnswer/history.do') {
+          return '<table><tbody><tr><td>1</td><td>멘토특강</td><td><a href="/sw/mypage/mentoLec/view.do?qustnrSn=39">미래 특강</a></td><td>Mentor One</td><td>2099.01.01(목) 10:00:00 ~ 12:00:00</td><td>2026-04-20 22:41</td><td>[접수완료]</td><td>[OK]</td><td>-</td><td>-</td></tr></tbody></table><ul class="bbs-total"><li>Total : 1</li><li>1/1 Page</li></ul>'
+        }
+        if (path === '/mypage/myTeam/team.do') {
+          return '<ul class="bbs-team"></ul><p class="ico-team">현재 참여중인 방은 <strong class="color-blue">0</strong>/100팀 입니다</p>'
+        }
+        return ''
+      },
+    })
+    const client = new SomaClient({ http })
+
+    const dashboard = await client.dashboard.get()
+
+    expect(dashboard.role).toBe('멘토')
+    expect(dashboard.mentoringSessions.map((item) => item.url)).toEqual(['/sw/mypage/mentoLec/view.do?qustnrSn=39'])
+    expect(calls.some((c) => c.path === '/mypage/userAnswer/history.do')).toBe(true)
+    expect(calls.some((c) => c.path === '/mypage/mentoLec/list.do')).toBe(false)
+  })
+
+  it('excludes deleted application history rows from trainee dashboard mentoring sessions', async () => {
+    const { http } = createFakeHttp({
+      identity: { userId: 'trainee@example.com', userNm: 'Trainee One', userNo: 'trainee-1', userGb: UserGb.Trainee },
+      getBody: (path) => {
+        if (path === '/mypage/myMain/dashboard.do') {
+          return '<ul class="dash-top"><li class="dash-card"><div class="dash-etc"><span>소속 :<br> Org</span><span>직책 :<br> </span></div><div class="dash-state"><div class="top"><span class="bg-blue label"><span>17기 연수생</span></span><div class="welcome"><strong>Trainee One</strong>님 안녕하세요.</div></div></div></li></ul>'
+        }
+        if (path === '/mypage/userAnswer/history.do') {
+          return `<table><tbody>
+            <tr><td>2</td><td>멘토특강</td><td>Deleted Lecture</td><td>Mentor One</td><td>2099.01.01(목) 19:00:00 ~ 22:00:00</td><td>2026-04-20 22:41</td><td>[접수완료]</td><td>[OK]</td><td>삭제</td><td>-</td></tr>
+            <tr><td>1</td><td>멘토특강</td><td><a href="/sw/mypage/mentoLec/view.do?qustnrSn=39">Active Lecture</a></td><td>Mentor Two</td><td>2099.01.02(금) 10:00:00 ~ 12:00:00</td><td>2026-04-20 22:41</td><td>[접수완료]</td><td>[OK]</td><td>-</td><td>-</td></tr>
+          </tbody></table><ul class="bbs-total"><li>Total : 2</li><li>1/1 Page</li></ul>`
+        }
+        if (path === '/mypage/myTeam/team.do') {
+          return '<ul class="bbs-team"></ul><p class="ico-team">현재 참여중인 방은 <strong class="color-blue">0</strong>/100팀 입니다</p>'
+        }
+        return ''
+      },
+    })
+    const client = new SomaClient({ http })
+
+    const dashboard = await client.dashboard.get()
+
+    expect(dashboard.mentoringSessions.map((item) => item.title)).toEqual(['Active Lecture'])
+  })
+
   it('enriches dashboard with every team the mentor belongs to', async () => {
     const teamCard = (name: string, ownerId: string, teamId: string) =>
       `<li><div class="top"><strong class="t"><a href="javascript:void(0);" onclick="teamPageGo('${name}','${ownerId}','${teamId}');">${name}</a></strong></div><p>팀원 3명</p><button type="button">참여중</button></li>`
@@ -748,7 +800,7 @@ describe('SomaClient', () => {
 
   it('enriches trainee dashboard with every team the trainee belongs to', async () => {
     const { http, calls } = createFakeHttp({
-      identity: { userId: 'trainee@example.com', userNm: 'Trainee One' },
+      identity: { userId: 'trainee@example.com', userNm: 'Trainee One', userNo: 'trainee-1', userGb: UserGb.Trainee },
       getBody: (path) => {
         if (path === '/mypage/myMain/dashboard.do') {
           return '<ul class="dash-top"><li class="dash-card"><div class="dash-etc"><span>소속 :<br> Org</span><span>직책 :<br> </span></div><div class="dash-state"><div class="top"><span class="bg-blue label"><span>17기 연수생</span></span><div class="welcome"><strong>Trainee One</strong>님 안녕하세요.</div></div></div></li></ul>'
@@ -1057,7 +1109,6 @@ describe('SomaClient', () => {
     } catch (error) {
       expect(error).toBeInstanceOf(AuthenticationError)
       expect((error as Error).message).toContain('opensoma auth login')
-      expect((error as Error).message).toContain('opensoma auth extract')
     }
   })
 

package/src/client.ts

@@ -4,7 +4,7 @@ import { MENU_NO } from './constants'
 import { CredentialManager } from './credential-manager'
 import { AuthenticationError } from './errors'
 import * as formatters from './formatters'
-import { SomaHttp, type UserIdentity } from './http'
+import { SomaHttp, UserGb, type UserIdentity } from './http'
 import { buildMentoringListParams, type MentoringSearchQuery } from './shared/utils/mentoring-params'
 import {
   buildApplicationPayload,
@@ -357,11 +357,11 @@ export class SomaClient {
 
     this.dashboard = {
       get: async () => {
-        await this.requireAuth()
+        const identity = await this.requireAuth()
         const dashboard = formatters.parseDashboard(
           await this.http.get('/mypage/myMain/dashboard.do', { menuNo: MENU_NO.DASHBOARD }),
         )
-        const trainee = isTraineeRole(dashboard.role)
+        const trainee = identity.userGb === UserGb.Trainee
         const teamSearchField = trainee ? ('member' as const) : ('mentor' as const)
         if (trainee) {
           const [firstPage, teams] = await Promise.all([
@@ -598,7 +598,7 @@ export class SomaClient {
     }
   }
 
-  private async requireAuth(): Promise<void> {
+  private async requireAuth(): Promise<UserIdentity> {
     let identity = await this.http.checkLogin()
     if (!identity && this.loginCredentials) {
       await this.relogin()
@@ -608,6 +608,8 @@ export class SomaClient {
     if (!identity) {
       throw new AuthenticationError()
     }
+
+    return identity
   }
 
   private async relogin(): Promise<void> {
@@ -730,14 +732,11 @@ export class SomaClient {
   }
 }
 
-function isTraineeRole(role: string): boolean {
-  return role.includes('연수생')
-}
-
 function applicationHistoryToDashboardItem(
   item: ApplicationHistoryItem,
 ): Dashboard['mentoringSessions'][number] | null {
   if (item.applicationStatus.includes('취소')) return null
+  if (item.applicationDetail.includes('삭제')) return null
 
   const type = applicationCategoryToMentoringType(item.category)
   if (!type) return null

package/src/commands/auth.test.ts

@@ -1,65 +1,11 @@
 import { describe, expect, it } from 'bun:test'
 
-import { inspectStoredAuthStatus, resolveExtractedCredentials } from './auth'
-
-const noBrowserExtraction = async () => null
-
-describe('resolveExtractedCredentials', () => {
-  it('returns the first candidate that validates successfully', async () => {
-    const calls: string[] = []
-
-    const credentials = await resolveExtractedCredentials(
-      [
-        { browser: 'Chrome', lastAccessUtc: 30, profile: 'Default', sessionCookie: 'stale-session' },
-        { browser: 'Chrome', lastAccessUtc: 20, profile: 'Profile 1', sessionCookie: 'valid-session' },
-      ],
-      (sessionCookie) => ({
-        checkLogin: async () => {
-          calls.push(`check:${sessionCookie}`)
-          return sessionCookie === 'valid-session' ? { userId: 'neo', userNm: 'Neo' } : null
-        },
-        extractCsrfToken: async () => {
-          calls.push(`csrf:${sessionCookie}`)
-          return `${sessionCookie}-csrf`
-        },
-      }),
-    )
-
-    expect(credentials).toEqual({
-      sessionCookie: 'valid-session',
-      csrfToken: 'valid-session-csrf',
-    })
-    expect(calls).toEqual(['check:stale-session', 'check:valid-session', 'csrf:valid-session'])
-  })
-
-  it('returns null when every candidate is invalid or throws', async () => {
-    const credentials = await resolveExtractedCredentials(
-      [
-        { browser: 'Chrome', lastAccessUtc: 30, profile: 'Default', sessionCookie: 'stale-session' },
-        { browser: 'Edge', lastAccessUtc: 20, profile: 'Profile 1', sessionCookie: 'broken-session' },
-      ],
-      (sessionCookie) => ({
-        checkLogin: async () => {
-          if (sessionCookie === 'broken-session') {
-            throw new Error('network error')
-          }
-
-          return null
-        },
-        extractCsrfToken: async () => {
-          throw new Error('should not be called')
-        },
-      }),
-    )
-
-    expect(credentials).toBeNull()
-  })
-})
+import { inspectStoredAuthStatus } from './auth'
 
 describe('inspectStoredAuthStatus', () => {
-  it('clears session state but preserves saved id/password when both recovery methods fail', async () => {
+  it('clears session state but preserves saved id/password when re-login fails', async () => {
     let cleared = false
-    let postClearCredentials = {
+    const postClearCredentials = {
       sessionCookie: '',
       csrfToken: '',
       username: 'mentor@example.com',
@@ -93,7 +39,6 @@ describe('inspectStoredAuthStatus', () => {
         getSessionCookie: () => null,
         getCsrfToken: () => null,
       }),
-      noBrowserExtraction,
     )
 
     expect(status).toEqual({
@@ -101,7 +46,7 @@ describe('inspectStoredAuthStatus', () => {
       credentials: null,
       clearedStaleSession: true,
       preservedRecoveryCredentials: true,
-      hint: 'Session expired. Run: opensoma auth login or opensoma auth extract',
+      hint: 'Session expired. Run: opensoma auth login',
     })
     expect(cleared).toBe(true)
   })
@@ -128,8 +73,6 @@ describe('inspectStoredAuthStatus', () => {
       () => ({
         checkLogin: async () => null,
       }),
-      undefined,
-      noBrowserExtraction,
     )
 
     expect(status).toEqual({
@@ -137,7 +80,7 @@ describe('inspectStoredAuthStatus', () => {
       credentials: null,
       clearedStaleSession: true,
       preservedRecoveryCredentials: false,
-      hint: 'Session expired. Run: opensoma auth login or opensoma auth extract',
+      hint: 'Session expired. Run: opensoma auth login',
     })
   })
 
@@ -171,46 +114,11 @@ describe('inspectStoredAuthStatus', () => {
       valid: false,
       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',
+      hint: 'Could not verify session. Try again or run: opensoma auth login',
     })
     expect(cleared).toBe(false)
   })
 
-  it('recovers via browser extraction when no stored password is available', async () => {
-    let savedCredentials: Record<string, unknown> | null = null
-
-    const status = await inspectStoredAuthStatus(
-      {
-        getCredentials: async () => ({
-          sessionCookie: 'stale-session',
-          csrfToken: 'stale-csrf',
-        }),
-        setCredentials: async (credentials: Record<string, unknown>) => {
-          savedCredentials = credentials
-        },
-        clearSessionState: async () => {
-          throw new Error('should not clear session state when browser extraction succeeds')
-        },
-      },
-      () => ({
-        checkLogin: async () => null,
-      }),
-      undefined,
-      async () => ({ sessionCookie: 'browser-session', csrfToken: 'browser-csrf' }),
-    )
-
-    expect(status).toMatchObject({
-      authenticated: true,
-      valid: true,
-      username: null,
-    })
-    expect(savedCredentials).toMatchObject({
-      sessionCookie: 'browser-session',
-      csrfToken: 'browser-csrf',
-    })
-    expect(savedCredentials).toHaveProperty('loggedInAt')
-  })
-
   it('refreshes the session automatically when stored username and password are available', async () => {
     let savedCredentials: Record<string, string> | null = null
 

package/src/commands/auth.ts

@@ -7,7 +7,6 @@ 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'
 
 function ask(rl: ReadlineInterface, message: string): Promise<string> {
   return new Promise((resolve) => {
@@ -101,62 +100,12 @@ async function promptCredentials(
 
 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, 'clearSessionState' | 'getCredentials' | '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[],
-  createValidator: (sessionCookie: string) => ExtractedSessionValidator = (sessionCookie) =>
-    new SomaHttp({ sessionCookie }),
-  debug?: (message: string) => void,
-): Promise<{ csrfToken: string; sessionCookie: string } | null> {
-  debug?.(`Validating ${candidates.length} candidate(s) against server...`)
-
-  for (const candidate of candidates) {
-    const http = createValidator(candidate.sessionCookie)
-    debug?.(`  ${candidate.browser} / ${candidate.profile}: checkLogin...`)
-
-    try {
-      const valid = Boolean(await http.checkLogin())
-      if (!valid) {
-        debug?.(`  ${candidate.browser} / ${candidate.profile}: session invalid`)
-        continue
-      }
-
-      debug?.(`  ${candidate.browser} / ${candidate.profile}: valid! Extracting CSRF token...`)
-      const csrfToken = await http.extractCsrfToken()
-      debug?.(`  CSRF token obtained (${csrfToken.length} chars)`)
-
-      return {
-        sessionCookie: candidate.sessionCookie,
-        csrfToken,
-      }
-    } catch (error) {
-      debug?.(
-        `  ${candidate.browser} / ${candidate.profile}: error: ${error instanceof Error ? error.message : String(error)}`,
-      )
-    }
-  }
-
-  return null
-}
+const EXPIRED_SESSION_HINT = 'Session expired. Run: opensoma auth login'
+const UNVERIFIED_SESSION_HINT = 'Could not verify session. Try again or run: opensoma auth login'
 
 async function loginAction(options: LoginOptions): Promise<void> {
   try {
@@ -230,7 +179,6 @@ export async function inspectStoredAuthStatus(
   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) {
@@ -271,21 +219,6 @@ export async function inspectStoredAuthStatus(
       }
     }
 
-    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.clearSessionState()
     const post = await manager.getCredentials()
     return {
@@ -313,45 +246,6 @@ async function statusAction(options: StatusOptions): Promise<void> {
   }
 }
 
-async function extractAction(options: ExtractOptions): Promise<void> {
-  const log = options.debug ? (message: string) => process.stderr.write(`[extract] ${message}\n`) : undefined
-
-  try {
-    const { TokenExtractor } = (await import('../token-extractor')) as {
-      TokenExtractor: new (options?: { debug?: boolean }) => {
-        extractCandidates: () => Promise<ExtractedSessionCandidate[]>
-      }
-    }
-    const extractor = new TokenExtractor({ debug: options.debug })
-    const candidates = await extractor.extractCandidates()
-    if (candidates.length === 0) {
-      throw new Error(
-        'No SWMaestro session found in any browser. Login to swmaestro.ai or opensoma.dev in a supported Chromium browser (Chrome, Edge, Brave, Arc, Vivaldi) first.',
-      )
-    }
-
-    log?.(
-      `Extracted ${candidates.length} candidate(s): ${candidates.map((c) => `${c.browser}/${c.profile}`).join(', ')}`,
-    )
-
-    const credentials = await resolveExtractedCredentials(candidates, undefined, log)
-    if (!credentials) {
-      throw new Error(
-        'Found SWMaestro session cookies in supported browsers, but none are valid. Refresh your swmaestro.ai or opensoma.dev login in a supported Chromium browser and try again.',
-      )
-    }
-
-    await new CredentialManager().setCredentials({
-      sessionCookie: credentials.sessionCookie,
-      csrfToken: credentials.csrfToken,
-      loggedInAt: new Date().toISOString(),
-    })
-    console.log(formatOutput({ ok: true, extracted: true, valid: true }, options.pretty))
-  } catch (error) {
-    handleError(error)
-  }
-}
-
 export const authCommand = new Command('auth')
   .description('Manage authentication')
   .addCommand(
@@ -374,10 +268,3 @@ export const authCommand = new Command('auth')
       .option('--pretty', 'Pretty print JSON output')
       .action(statusAction),
   )
-  .addCommand(
-    new Command('extract')
-      .description('Extract browser credentials')
-      .option('--debug', 'Show debug output')
-      .option('--pretty', 'Pretty print JSON output')
-      .action(extractAction),
-  )

package/src/commands/helpers.test.ts

@@ -2,8 +2,6 @@ import { describe, expect, it } from 'bun:test'
 
 import { createAuthenticatedHttp } from './helpers'
 
-const noBrowserExtraction = async () => null
-
 describe('createAuthenticatedHttp', () => {
   it('throws a login hint when no credentials are stored', async () => {
     const manager = {
@@ -11,12 +9,10 @@ describe('createAuthenticatedHttp', () => {
       clearSessionState: async () => {},
     }
 
-    await expect(createAuthenticatedHttp(manager)).rejects.toThrow(
-      'Not logged in. Run: opensoma auth login or opensoma auth extract',
-    )
+    await expect(createAuthenticatedHttp(manager)).rejects.toThrow('Not logged in. Run: opensoma auth login')
   })
 
-  it('clears only session state (not username/password) when both recovery methods fail', async () => {
+  it('clears only session state (not username/password) when re-login fails', async () => {
     let cleared = false
     const manager = {
       getCredentials: async () => ({
@@ -33,15 +29,13 @@ describe('createAuthenticatedHttp', () => {
       },
     }
 
-    await expect(
-      createAuthenticatedHttp(manager, () => ({ checkLogin: async () => null }), undefined, noBrowserExtraction),
-    ).rejects.toThrow(
-      'Session expired. Run: opensoma auth login or opensoma auth extract (saved id/password were preserved)',
+    await expect(createAuthenticatedHttp(manager, () => ({ checkLogin: async () => null }))).rejects.toThrow(
+      'Session expired. Run: opensoma auth login (saved id/password were preserved)',
     )
     expect(cleared).toBe(true)
   })
 
-  it('preserves stored id/password on disk when session expires and recovery fails', async () => {
+  it('preserves stored id/password on disk when session expires and re-login fails', async () => {
     const { CredentialManager } = await import('../credential-manager')
     const { mkdtemp, rm } = await import('node:fs/promises')
     const { tmpdir } = await import('node:os')
@@ -70,7 +64,6 @@ describe('createAuthenticatedHttp', () => {
             getSessionCookie: () => null,
             getCsrfToken: () => null,
           }),
-          noBrowserExtraction,
         ),
       ).rejects.toThrow('Session expired')
 
@@ -160,108 +153,4 @@ describe('createAuthenticatedHttp', () => {
       tozPhone: '010-1234-5678',
     })
   })
-
-  it('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
-      },
-      clearSessionState: async () => {
-        throw new Error('should not clear session state when browser extraction succeeds')
-      },
-    }
-    const recoveredHttp = {
-      checkLogin: async () => ({ userId: 'mentor@example.com', userNm: 'Mentor One' }),
-    }
-
-    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')
-  })
-
-  it('falls back to browser extraction when password re-login fails', async () => {
-    let savedCredentials: Record<string, unknown> | null = null
-    const manager = {
-      getCredentials: async () => ({
-        sessionCookie: 'stale-session',
-        csrfToken: 'stale-csrf',
-        username: 'mentor@example.com',
-        password: 'wrong-password',
-      }),
-      setCredentials: async (credentials: Record<string, unknown>) => {
-        savedCredentials = credentials
-      },
-      clearSessionState: async () => {
-        throw new Error('should not clear session state when browser extraction succeeds')
-      },
-    }
-    const recoveredHttp = {
-      checkLogin: async () => ({ userId: 'mentor@example.com', userNm: 'Mentor One' }),
-    }
-
-    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',
-    })
-  })
-
-  it('skips browser extraction when no credentials exist', async () => {
-    let browserExtractionCalled = false
-    const manager = {
-      getCredentials: async () => null,
-      setCredentials: async () => {
-        throw new Error('should not save')
-      },
-      clearSessionState: 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)
-  })
 })