opensoma 0.1.0

package/src/cli.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+
+import pkg from '../package.json' with { type: 'json' }
+import {
+  authCommand,
+  dashboardCommand,
+  eventCommand,
+  memberCommand,
+  mentoringCommand,
+  noticeCommand,
+  roomCommand,
+  teamCommand,
+} from './commands/index'
+
+function isAuthCommand(command: Command): boolean {
+  let current: Command | null = command
+  while (current) {
+    if (current.name() === 'auth') {
+      return true
+    }
+    current = current.parent
+  }
+  return false
+}
+
+const program = new Command()
+
+program.name('opensoma').description('SWMaestro MyPage CLI for AI agents').version(pkg.version)
+
+program.hook('preAction', async (_thisCommand, actionCommand) => {
+  if (isAuthCommand(actionCommand)) {
+    return
+  }
+
+  const { CredentialManager } = await import('./credential-manager')
+  const manager = new CredentialManager()
+  const creds = await manager.getCredentials()
+  if (!creds) {
+    console.error(JSON.stringify({ error: 'Not logged in. Run: opensoma auth login' }))
+    process.exit(1)
+  }
+})
+
+program.addCommand(authCommand)
+program.addCommand(mentoringCommand)
+program.addCommand(roomCommand)
+program.addCommand(dashboardCommand)
+program.addCommand(noticeCommand)
+program.addCommand(teamCommand)
+program.addCommand(memberCommand)
+program.addCommand(eventCommand)
+
+program.parse(process.argv)
+
+export { program }

package/src/client.test.ts

@@ -0,0 +1,210 @@
+import { afterEach, describe, expect, mock, test } from 'bun:test'
+
+import { SomaClient } from '@/client'
+import { MENU_NO } from '@/constants'
+import { SomaHttp } from '@/http'
+
+afterEach(() => {
+  mock.restore()
+})
+
+describe('SomaClient', () => {
+  test('constructor initializes SomaHttp with provided session state', () => {
+    const client = new SomaClient({ sessionCookie: 'session-1', csrfToken: 'csrf-1' })
+    const http = Reflect.get(client, 'http') as SomaHttp
+
+    expect(http.getSessionCookie()).toBe('session-1')
+    expect(http.getCsrfToken()).toBe('csrf-1')
+  })
+
+  test('mentoring list calls GET and parses list plus pagination', async () => {
+    const client = new SomaClient()
+    const calls: Array<{ method: string; path: string; data: Record<string, string> | undefined }> = []
+    Reflect.set(client, 'http', {
+      get: async (path: string, data?: Record<string, string>) => {
+        calls.push({ method: 'get', path, data })
+        return '<table><tbody><tr><td>1</td><td><a href="/sw/mypage/mentoLec/view.do?qustnrSn=123">[자유 멘토링] 제목 [접수중]</a></td><td>2026-04-01 ~ 2026-04-02</td><td>2026-04-03(목) 10:00 ~ 11:00</td><td>1 /4</td><td>OK</td><td>[접수중]</td><td>작성자</td><td>2026-04-01</td></tr></tbody></table><ul class="bbs-total"><li>Total : 1</li><li>1/1 Page</li></ul>'
+      },
+    })
+
+    const result = await client.mentoring.list({ status: 'open', type: 'public', page: 2 })
+
+    expect(calls).toEqual([
+      {
+        method: 'get',
+        path: '/mypage/mentoLec/list.do',
+        data: { menuNo: MENU_NO.MENTORING, searchStatMentolec: 'A', searchGubunMentolec: 'MRC010', pageIndex: '2' },
+      },
+    ])
+    expect(result.items[0]?.title).toBe('제목')
+    expect(result.pagination).toEqual({ total: 1, currentPage: 1, totalPages: 1 })
+  })
+
+  test('mentoring get calls detail endpoint and parser', async () => {
+    const client = new SomaClient()
+    let captured: { path: string; data: Record<string, string> | undefined } | undefined
+    Reflect.set(client, 'http', {
+      get: async (path: string, data?: Record<string, string>) => {
+        captured = { path, data }
+        return '<input type="hidden" name="qustnrSn" value="99"><table><tr><th>모집 명</th><td>상세</td><th>상태</th><td>접수중</td></tr><tr><th>접수 기간</th><td>2026-04-01 ~ 2026-04-02</td><th>강의날짜</th><td>2026-04-03(목) 10:00 ~ 11:00</td></tr><tr><th>장소</th><td>온라인(Webex)</td><th>모집인원</th><td>4명</td></tr><tr><th>작성자</th><td>작성자</td><th>등록일</th><td>2026-04-01</td></tr></table><div data-content><p>본문</p></div>'
+      },
+    })
+
+    const result = await client.mentoring.get(99)
+
+    expect(captured).toEqual({ path: '/mypage/mentoLec/view.do', data: { menuNo: MENU_NO.MENTORING, qustnrSn: '99' } })
+    expect(result).toMatchObject({ id: 99, title: '상세', venue: '온라인(Webex)' })
+  })
+
+  test('mutating operations post expected payloads', async () => {
+    const client = new SomaClient()
+    const calls: Array<{ path: string; data: Record<string, string> }> = []
+    Reflect.set(client, 'http', {
+      post: async (path: string, data: Record<string, string>) => {
+        calls.push({ path, data })
+        return ''
+      },
+    })
+
+    await client.mentoring.create({
+      title: '새 멘토링',
+      type: 'lecture',
+      date: '2026-04-01',
+      startTime: '10:00',
+      endTime: '11:00',
+      venue: '온라인(Webex)',
+      maxAttendees: 10,
+    })
+    await client.mentoring.delete(7)
+    await client.mentoring.apply(8)
+    await client.mentoring.cancel({ applySn: 9, qustnrSn: 10 })
+    await client.room.reserve({ roomId: 17, date: '2026-04-01', slots: ['10:00', '10:30'], title: '회의' })
+    await client.event.apply(11)
+
+    expect(calls.map((call) => call.path)).toEqual([
+      '/mypage/mentoLec/insert.do',
+      '/mypage/mentoLec/delete.do',
+      '/application/application/application.do',
+      '/mypage/userAnswer/cancel.do',
+      '/mypage/itemRent/insert.do',
+      '/application/application/application.do',
+    ])
+    expect(calls[0]?.data).toMatchObject({ menuNo: MENU_NO.MENTORING, reportCd: 'MRC020', qustnrSj: '새 멘토링' })
+    expect(calls[1]?.data).toEqual({ menuNo: MENU_NO.MENTORING, qustnrSn: '7', pageQueryString: '' })
+    expect(calls[2]?.data).toEqual({ menuNo: MENU_NO.EVENT, qustnrSn: '8', applyGb: 'C', stepHeader: '0' })
+    expect(calls[3]?.data).toEqual({ menuNo: MENU_NO.APPLICATION_HISTORY, applySn: '9', qustnrSn: '10' })
+    expect(calls[4]?.data).toMatchObject({
+      menuNo: MENU_NO.ROOM,
+      itemId: '17',
+      title: '회의',
+      'time[0]': '10:00',
+      'time[1]': '10:30',
+    })
+    expect(calls[5]?.data).toEqual({ menuNo: MENU_NO.EVENT, qustnrSn: '11', applyGb: 'C', stepHeader: '0' })
+  })
+
+  test('room, dashboard, notice, team, member, event, and history routes use expected endpoints', async () => {
+    const client = new SomaClient()
+    const calls: Array<{ method: string; path: string; data: Record<string, string> | undefined }> = []
+    Reflect.set(client, 'http', {
+      checkLogin: async () => ({ userId: 'neo@example.com', userNm: '전수열' }),
+      get: async (path: string, data?: Record<string, string>) => {
+        calls.push({ method: 'get', path, data })
+        if (path === '/mypage/myMain/dashboard.do') {
+          return '<ul class="dash-top"><li class="dash-card"><div class="dash-etc"><span>소속 :<br> Indent</span><span>직책 :<br> </span></div><div class="dash-state"><div class="top"><span class="bg-orange label"><span>멘토</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=9582">게임 개발 AI 활용법 접수중</a></li></li></ul>'
+        }
+        if (path === '/mypage/mentoLec/list.do') {
+          return '<table><tbody><tr><td>1</td><td><a href="/sw/mypage/mentoLec/view.do?qustnrSn=100">[멘토 특강] 내 멘토링 [접수중]</a></td><td>2026-04-01 ~ 2026-04-02</td><td>2026-04-03(목) 10:00 ~ 11:00</td><td>1 /4</td><td>OK</td><td>[접수중]</td><td>전수열</td><td>2026-04-01</td></tr></tbody></table><ul class="bbs-total"><li>Total : 1</li><li>1/1 Page</li></ul>'
+        }
+        if (path === '/mypage/myNotice/list.do') {
+          return '<table><tbody><tr><td></td><td><a href="/sw/mypage/myNotice/view.do?nttId=1">공지</a></td><td>관리자</td><td>2026-04-01</td></tr></tbody></table><ul class="bbs-total"><li>Total : 1</li><li>1/1 Page</li></ul>'
+        }
+        if (path === '/mypage/myNotice/view.do') {
+          return '<input name="nttId" value="1"><table><tr><th>제목</th><td>공지</td><th>작성자</th><td>관리자</td></tr><tr><th>등록일</th><td>2026-04-01</td><th>번호</th><td>1</td></tr></table><div class="board-view-content"><p>상세</p></div>'
+        }
+        if (path === '/mypage/myTeam/team.do') {
+          return '<ul class="bbs-team"><li><div class="top"><strong class="t"><a href="javascript:void(0);">오픈소마</a></strong></div><p>팀원 3명</p><button type="button">참여중</button></li></ul><p class="ico-team">현재 참여중인 방은 <strong class="color-blue">1</strong>/100팀 입니다</p>'
+        }
+        if (path === '/mypage/myInfo/forUpdateMy.do') {
+          return '<dl><dt><span class="point">아이디</span></dt><dd>neo@example.com</dd></dl><dl><dt><span class="point">이름</span></dt><dd>전수열</dd></dl><dl><dt><span class="point">성별</span></dt><dd>남자</dd></dl><dl><dt><span class="point">생년월일</span></dt><dd>1995-01-14</dd></dl><dl><dt><span class="point">연락처</span></dt><dd>01012345678</dd></dl><dl><dt><span class="point">소속</span></dt><dd>Indent</dd></dl><dl><dt><span class="point">직책</span></dt><dd></dd></dl>'
+        }
+        if (path === '/mypage/applicants/list.do') {
+          return '<table><tbody><tr><td>1</td><td>행사</td><td>행사</td><td>2026-04-01 ~ 2026-04-02</td><td>2026-04-03 ~ 2026-04-03</td><td>[접수중]</td><td>2026-04-01</td></tr></tbody></table><ul class="bbs-total"><li>Total : 1</li><li>1/1 Page</li></ul>'
+        }
+        if (path === '/mypage/applicants/view.do') {
+          return '<input name="bbsId" value="1"><table><tr><th>제목</th><td>행사 상세</td></tr></table><div data-content><p>본문</p></div>'
+        }
+        return '<table><tbody><tr><td>1</td><td>멘토 특강</td><td><a href="/sw/mypage/mentoLec/view.do?qustnrSn=1">접수내역</a></td><td>전수열</td><td>2026.04.11</td><td>2026-04-01</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>'
+      },
+      post: async (path: string, data: Record<string, string>) => {
+        calls.push({ method: 'post', path, data })
+        if (path === '/mypage/officeMng/rentTime.do') {
+          return '<div class="time-grid"><span>09:00</span></div>'
+        }
+        return '<ul class="bbs-reserve"><li class="item"><a href="javascript:void(0);" onclick="location.href=\'/sw/mypage/officeMng/view.do?itemId=17\';"><div class="cont"><h4 class="tit">스페이스 A1</h4><ul class="txt bul-dot grey"><li>이용기간 : 2026-04-01 ~ 2026-12-31</li><li><p>설명 : 4인</p></li><li class="time-list"><div class="time-grid"><span>09:00</span></div></li></ul></div></a></li></ul>'
+      },
+    })
+
+    const roomList = await client.room.list({ date: '2026-04-01', room: 'A1' })
+    const roomSlots = await client.room.available(17, '2026-04-01')
+    const dashboard = await client.dashboard.get()
+    const noticeList = await client.notice.list({ page: 2 })
+    const noticeDetail = await client.notice.get(1)
+    const team = await client.team.show()
+    const member = await client.member.show()
+    const events = await client.event.list({ page: 3 })
+    const eventDetail = await client.event.get(1)
+    const history = await client.mentoring.history({ page: 4 })
+
+    expect(roomList[0]?.itemId).toBe(17)
+    expect(roomSlots).toEqual([{ time: '09:00', available: true }])
+    expect(dashboard.name).toBe('전수열')
+    expect(dashboard.mentoringSessions).toEqual([
+      { title: '내 멘토링', url: '/mypage/mentoLec/view.do?qustnrSn=100', status: '접수중' },
+    ])
+    expect(noticeList.items[0]?.title).toBe('공지')
+    expect(noticeDetail).toMatchObject({ id: 1, title: '공지' })
+    expect(team.teams[0]?.name).toBe('오픈소마')
+    expect(member.email).toBe('neo@example.com')
+    expect(events.items[0]?.title).toBe('행사')
+    expect(eventDetail).toMatchObject({ id: 1, title: '행사 상세' })
+    expect(history.items[0]).toEqual({
+      id: 1,
+      category: '멘토 특강',
+      title: '접수내역',
+      author: '전수열',
+      sessionDate: '2026-04-11',
+      appliedAt: '2026-04-01',
+      applicationStatus: '신청완료',
+      approvalStatus: 'OK',
+      applicationDetail: '승인대기',
+      note: '-',
+    })
+
+    const dashboardCallIndex = calls.findIndex((c) => c.path === '/mypage/myMain/dashboard.do')
+    expect(dashboardCallIndex).toBeGreaterThanOrEqual(0)
+    const mentoringListCall = calls.find((c) => c.path === '/mypage/mentoLec/list.do')
+    expect(mentoringListCall?.data).toEqual({
+      menuNo: MENU_NO.MENTORING,
+      searchCnd: '2',
+      searchId: 'neo@example.com',
+      searchWrd: '전수열',
+    })
+  })
+
+  test('login and isLoggedIn delegate to SomaHttp', async () => {
+    const client = new SomaClient({ username: 'neo@example.com', password: 'secret' })
+    const calls: string[] = []
+    Reflect.set(client, 'http', {
+      login: async (username: string, password: string) => {
+        calls.push(`${username}:${password}`)
+      },
+      checkLogin: async () => ({ userId: 'neo@example.com', userNm: '전수열' }),
+    })
+
+    await client.login()
+
+    expect(calls).toEqual(['neo@example.com:secret'])
+    await expect(client.isLoggedIn()).resolves.toBe(true)
+  })
+})

package/src/client.ts

@@ -0,0 +1,264 @@
+import { MENU_NO } from '@/constants'
+import { CredentialManager } from '@/credential-manager'
+import * as formatters from '@/formatters'
+import { type UserIdentity, SomaHttp } from '@/http'
+import { type MentoringSearchQuery, buildMentoringListParams } from '@/shared/utils/mentoring-params'
+import {
+  buildApplicationPayload,
+  buildCancelApplicationPayload,
+  buildDeleteMentoringPayload,
+  buildMentoringPayload,
+  buildRoomReservationPayload,
+  parseEventDetail,
+  resolveRoomId,
+} from '@/shared/utils/swmaestro'
+import type {
+  ApplicationHistoryItem,
+  Dashboard,
+  EventListItem,
+  MemberInfo,
+  MentoringDetail,
+  MentoringListItem,
+  NoticeDetail,
+  NoticeListItem,
+  Pagination,
+  RoomCard,
+  TeamInfo,
+} from '@/types'
+
+export interface SomaClientOptions {
+  sessionCookie?: string
+  csrfToken?: string
+  username?: string
+  password?: string
+}
+
+export class SomaClient {
+  private readonly http: SomaHttp
+  private readonly options: SomaClientOptions
+
+  readonly mentoring: {
+    list(options?: {
+      status?: string
+      type?: string
+      search?: MentoringSearchQuery
+      page?: number
+    }): Promise<{ items: MentoringListItem[]; pagination: Pagination }>
+    get(id: number): Promise<MentoringDetail>
+    create(params: {
+      title: string
+      type: 'public' | 'lecture'
+      date: string
+      startTime: string
+      endTime: string
+      venue: string
+      maxAttendees?: number
+      regStart?: string
+      regEnd?: string
+      content?: string
+    }): Promise<void>
+    delete(id: number): Promise<void>
+    apply(id: number): Promise<void>
+    cancel(params: { applySn: number; qustnrSn: number }): Promise<void>
+    history(options?: { page?: number }): Promise<{ items: ApplicationHistoryItem[]; pagination: Pagination }>
+  }
+
+  readonly room: {
+    list(options?: { date?: string; room?: string }): Promise<RoomCard[]>
+    available(roomId: number, date: string): Promise<RoomCard['timeSlots']>
+    reserve(params: {
+      roomId: number
+      date: string
+      slots: string[]
+      title: string
+      attendees?: number
+      notes?: string
+    }): Promise<void>
+  }
+
+  readonly dashboard: {
+    get(): Promise<Dashboard>
+  }
+
+  readonly notice: {
+    list(options?: { page?: number }): Promise<{ items: NoticeListItem[]; pagination: Pagination }>
+    get(id: number): Promise<NoticeDetail>
+  }
+
+  readonly team: {
+    show(): Promise<TeamInfo>
+  }
+
+  readonly member: {
+    show(): Promise<MemberInfo>
+  }
+
+  readonly event: {
+    list(options?: { page?: number }): Promise<{ items: EventListItem[]; pagination: Pagination }>
+    get(id: number): Promise<unknown>
+    apply(id: number): Promise<void>
+  }
+
+  constructor(options: SomaClientOptions = {}) {
+    this.options = options
+    this.http = new SomaHttp({ sessionCookie: options.sessionCookie, csrfToken: options.csrfToken })
+
+    this.mentoring = {
+      list: async (options) => {
+        const user = options?.search?.me ? await this.resolveUser() : undefined
+        const html = await this.http.get(
+          '/mypage/mentoLec/list.do',
+          buildMentoringListParams({
+            status: options?.status,
+            type: options?.type,
+            page: options?.page,
+            search: options?.search,
+            user,
+          }),
+        )
+        return { items: formatters.parseMentoringList(html), pagination: formatters.parsePagination(html) }
+      },
+      get: async (id) =>
+        formatters.parseMentoringDetail(
+          await this.http.get('/mypage/mentoLec/view.do', { menuNo: MENU_NO.MENTORING, qustnrSn: String(id) }),
+          id,
+        ),
+      create: async (params) => {
+        await this.http.post('/mypage/mentoLec/insert.do', buildMentoringPayload(params))
+      },
+      delete: async (id) => {
+        await this.http.post('/mypage/mentoLec/delete.do', buildDeleteMentoringPayload(id))
+      },
+      apply: async (id) => {
+        await this.http.post('/application/application/application.do', buildApplicationPayload(id))
+      },
+      cancel: async (params) => {
+        await this.http.post('/mypage/userAnswer/cancel.do', buildCancelApplicationPayload(params))
+      },
+      history: async (options) => {
+        const html = await this.http.get('/mypage/userAnswer/history.do', {
+          menuNo: MENU_NO.APPLICATION_HISTORY,
+          ...(options?.page ? { pageIndex: String(options.page) } : {}),
+        })
+        return { items: formatters.parseApplicationHistory(html), pagination: formatters.parsePagination(html) }
+      },
+    }
+
+    this.room = {
+      list: async (options) =>
+        formatters.parseRoomList(
+          await this.http.post('/mypage/officeMng/list.do', {
+            menuNo: MENU_NO.ROOM,
+            sdate: options?.date ?? new Date().toISOString().slice(0, 10),
+            searchItemId: options?.room ? String(resolveRoomId(options.room)) : '',
+          }),
+        ),
+      available: async (roomId, date) =>
+        formatters.parseRoomSlots(
+          await this.http.post('/mypage/officeMng/rentTime.do', {
+            viewType: 'CONTBODY',
+            itemId: String(roomId),
+            rentDt: date,
+          }),
+        ),
+      reserve: async (params) => {
+        await this.http.post('/mypage/itemRent/insert.do', buildRoomReservationPayload(params))
+      },
+    }
+
+    this.dashboard = {
+      get: async () => {
+        const [dashboard, { items: myMentoring }] = await Promise.all([
+          formatters.parseDashboard(await this.http.get('/mypage/myMain/dashboard.do', { menuNo: MENU_NO.DASHBOARD })),
+          this.mentoring.list({ search: { field: 'author', value: '@me', me: true } }),
+        ])
+        dashboard.mentoringSessions = myMentoring.map((item) => ({
+          title: item.title,
+          url: `/mypage/mentoLec/view.do?qustnrSn=${item.id}`,
+          status: item.status,
+        }))
+        return dashboard
+      },
+    }
+
+    this.notice = {
+      list: async (options) => {
+        const html = await this.http.get('/mypage/myNotice/list.do', {
+          menuNo: MENU_NO.NOTICE,
+          ...(options?.page ? { pageIndex: String(options.page) } : {}),
+        })
+        return { items: formatters.parseNoticeList(html), pagination: formatters.parsePagination(html) }
+      },
+      get: async (id) =>
+        formatters.parseNoticeDetail(
+          await this.http.get('/mypage/myNotice/view.do', { menuNo: MENU_NO.NOTICE, nttId: String(id) }),
+          id,
+        ),
+    }
+
+    this.team = {
+      show: async () =>
+        formatters.parseTeamInfo(await this.http.get('/mypage/myTeam/team.do', { menuNo: MENU_NO.TEAM })),
+    }
+
+    this.member = {
+      show: async () =>
+        formatters.parseMemberInfo(
+          await this.http.get('/mypage/myInfo/forUpdateMy.do', { menuNo: MENU_NO.MEMBER_INFO }),
+        ),
+    }
+
+    this.event = {
+      list: async (options) => {
+        const html = await this.http.get('/mypage/applicants/list.do', {
+          menuNo: MENU_NO.EVENT,
+          ...(options?.page ? { pageIndex: String(options.page) } : {}),
+        })
+        return { items: formatters.parseEventList(html), pagination: formatters.parsePagination(html) }
+      },
+      get: async (id) =>
+        parseEventDetail(
+          await this.http.get('/mypage/applicants/view.do', { menuNo: MENU_NO.EVENT, bbsId: String(id) }),
+        ),
+      apply: async (id) => {
+        await this.http.post('/application/application/application.do', buildApplicationPayload(id))
+      },
+    }
+  }
+
+  private async resolveUser(): Promise<UserIdentity | undefined> {
+    const identity = await this.http.checkLogin()
+    return identity ?? undefined
+  }
+
+  async login(username?: string, password?: string): Promise<void> {
+    const resolvedUsername = username ?? this.options.username
+    const resolvedPassword = password ?? this.options.password
+
+    if (!resolvedUsername || !resolvedPassword) {
+      throw new Error('Username and password are required')
+    }
+
+    await this.http.login(resolvedUsername, resolvedPassword)
+  }
+
+  async isLoggedIn(): Promise<boolean> {
+    return Boolean(await this.http.checkLogin())
+  }
+
+  async saveCredentials(manager = new CredentialManager()): Promise<void> {
+    const sessionCookie = this.http.getSessionCookie()
+    const csrfToken = this.http.getCsrfToken()
+
+    if (!sessionCookie || !csrfToken) {
+      throw new Error('Missing session cookie or CSRF token')
+    }
+
+    await manager.setCredentials({
+      sessionCookie,
+      csrfToken,
+      username: this.options.username,
+      loggedInAt: new Date().toISOString(),
+    })
+  }
+}

package/src/commands/auth.ts

@@ -0,0 +1,153 @@
+import { Command } from 'commander'
+
+import { CredentialManager } from '@/credential-manager'
+import { SomaHttp } from '@/http'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { warn } from '@/shared/utils/stderr'
+
+type LoginOptions = { username?: string; password?: string; pretty?: boolean }
+type StatusOptions = { pretty?: boolean }
+type ExtractOptions = { pretty?: boolean }
+
+async function loginAction(options: LoginOptions): Promise<void> {
+  try {
+    const username = options.username ?? process.env.OPENSOMA_USERNAME
+    const password = options.password ?? process.env.OPENSOMA_PASSWORD
+    if (!username || !password) {
+      throw new Error('Provide --username and --password or set OPENSOMA_USERNAME and OPENSOMA_PASSWORD')
+    }
+
+    const http = new SomaHttp()
+    await http.login(username, password)
+
+    const sessionCookie = http.getSessionCookie()
+    const csrfToken = http.getCsrfToken()
+    if (!sessionCookie || !csrfToken) {
+      throw new Error('Login succeeded but session information is missing')
+    }
+
+    await new CredentialManager().setCredentials({
+      sessionCookie,
+      csrfToken,
+      username,
+      loggedInAt: new Date().toISOString(),
+    })
+
+    console.log(formatOutput({ ok: true, username, loggedIn: true }, options.pretty))
+  } catch (error) {
+    handleError(error)
+  }
+}
+
+async function logoutAction(options: StatusOptions): Promise<void> {
+  try {
+    await new CredentialManager().remove()
+    console.log(formatOutput({ ok: true, loggedIn: false }, options.pretty))
+  } catch (error) {
+    handleError(error)
+  }
+}
+
+async function statusAction(options: StatusOptions): Promise<void> {
+  try {
+    const manager = new CredentialManager()
+    const creds = await manager.getCredentials()
+    if (!creds) {
+      console.log(formatOutput({ authenticated: false, credentials: null }, options.pretty))
+      return
+    }
+
+    let valid = false
+    try {
+      const http = new SomaHttp({ sessionCookie: creds.sessionCookie, csrfToken: creds.csrfToken })
+      valid = Boolean(await http.checkLogin())
+    } catch {
+      valid = false
+    }
+
+    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,
+      ),
+    )
+  } catch (error) {
+    handleError(error)
+  }
+}
+
+async function extractAction(options: ExtractOptions): Promise<void> {
+  try {
+    const modulePath = '@/token-extractor'
+    const imported = (await import(modulePath)) as {
+      TokenExtractor: new () => { extract: () => Promise<{ sessionCookie: string } | null> }
+    }
+    const extractor = new imported.TokenExtractor()
+    const result = await extractor.extract()
+    if (!result) {
+      throw new Error('No SWMaestro session found in any browser. Login to swmaestro.ai in a supported Chromium browser (Chrome, Edge, Brave, Arc, Vivaldi) first.')
+    }
+
+    const http = new SomaHttp({ sessionCookie: result.sessionCookie })
+
+    let valid = false
+    let csrfToken: string | undefined
+    try {
+      valid = Boolean(await http.checkLogin())
+      if (valid) {
+        csrfToken = await http.extractCsrfToken()
+      }
+    } catch {
+      valid = false
+    }
+
+    if (!valid) {
+      warn('Warning: Could not validate session. Cookies may be expired.')
+    }
+
+    await new CredentialManager().setCredentials({
+      sessionCookie: result.sessionCookie,
+      csrfToken: csrfToken ?? '',
+      loggedInAt: new Date().toISOString(),
+    })
+    console.log(formatOutput({ ok: true, extracted: true, valid }, options.pretty))
+  } catch (error) {
+    handleError(error)
+  }
+}
+
+export const authCommand = new Command('auth')
+  .description('Manage authentication')
+  .addCommand(
+    new Command('login')
+      .description('Login with username and password')
+      .option('--username <username>', 'SWMaestro username')
+      .option('--password <password>', 'SWMaestro password')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(loginAction),
+  )
+  .addCommand(
+    new Command('logout')
+      .description('Remove saved credentials')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(logoutAction),
+  )
+  .addCommand(
+    new Command('status')
+      .description('Show authentication status')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(statusAction),
+  )
+  .addCommand(
+    new Command('extract')
+      .description('Extract browser credentials')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(extractAction),
+  )