opensoma 0.4.0 → 0.5.1

package/src/client.ts

@@ -46,6 +46,8 @@ export interface SomaClientOptions {
   username?: string
   password?: string
   verbose?: boolean
+  /** @internal */
+  http?: SomaHttp
 }
 
 export class SomaClient {
@@ -109,7 +111,7 @@ export class SomaClient {
       searchKeyword?: string
     }): Promise<{ items: ReportListItem[]; pagination: Pagination }>
     get(id: number): Promise<ReportDetail>
-    create(options: ReportCreateOptions, file: Buffer | string, fileName?: string): Promise<void>
+    create(options: ReportCreateOptions, files: Array<{ buffer: Buffer; name: string }>): Promise<void>
     update(
       id: number,
       options: Omit<ReportUpdateOptions, 'id'>,
@@ -141,11 +143,13 @@ export class SomaClient {
     this.options = options
     this.loginCredentials =
       options.username && options.password ? { username: options.username, password: options.password } : null
-    this.http = new SomaHttp({
-      sessionCookie: options.sessionCookie,
-      csrfToken: options.csrfToken,
-      verbose: options.verbose,
-    })
+    this.http =
+      options.http ??
+      new SomaHttp({
+        sessionCookie: options.sessionCookie,
+        csrfToken: options.csrfToken,
+        verbose: options.verbose,
+      })
 
     this.mentoring = {
       list: async (options) => {
@@ -344,7 +348,7 @@ export class SomaClient {
         })
         return formatters.parseReportDetail(html, id)
       },
-      create: async (options, file, fileName) => {
+      create: async (options, files) => {
         await this.requireAuth()
         const payload = buildReportPayload({
           menteeRegion: options.menteeRegion,
@@ -369,11 +373,11 @@ export class SomaClient {
         for (const [key, value] of Object.entries(payload)) {
           formData.append(key, value)
         }
-        const isBuffer = Buffer.isBuffer(file)
-        const fileBuffer = isBuffer ? file : await readFile(file)
-        const resolvedFileName = isBuffer ? (fileName ?? 'file') : (file.split('/').pop() ?? 'file')
-        const uint8Array = new Uint8Array(fileBuffer.buffer, fileBuffer.byteOffset, fileBuffer.byteLength)
-        formData.append('file_1_1', new Blob([uint8Array as unknown as ArrayBuffer]), resolvedFileName)
+        for (let i = 0; i < files.length; i++) {
+          const { buffer, name } = files[i]
+          const uint8Array = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+          formData.append(`file_1_${i + 1}`, new Blob([uint8Array as unknown as ArrayBuffer]), name)
+        }
         formData.append('fileFieldNm_1', 'file_1')
         formData.append('atchFileId', '')
         await this.http.postMultipart('/mypage/mentoringReport/insert.do', formData)

package/src/commands/auth.test.ts

@@ -1,11 +1,11 @@
-import { describe, expect, test } from 'bun:test'
+import { describe, expect, it } from 'bun:test'
 
 import { inspectStoredAuthStatus, resolveExtractedCredentials } from './auth'
 
 const noBrowserExtraction = async () => null
 
 describe('resolveExtractedCredentials', () => {
-  test('returns the first candidate that validates successfully', async () => {
+  it('returns the first candidate that validates successfully', async () => {
     const calls: string[] = []
 
     const credentials = await resolveExtractedCredentials(
@@ -32,7 +32,7 @@ describe('resolveExtractedCredentials', () => {
     expect(calls).toEqual(['check:stale-session', 'check:valid-session', 'csrf:valid-session'])
   })
 
-  test('returns null when every candidate is invalid or throws', async () => {
+  it('returns null when every candidate is invalid or throws', async () => {
     const credentials = await resolveExtractedCredentials(
       [
         { browser: 'Chrome', lastAccessUtc: 30, profile: 'Default', sessionCookie: 'stale-session' },
@@ -57,7 +57,7 @@ describe('resolveExtractedCredentials', () => {
 })
 
 describe('inspectStoredAuthStatus', () => {
-  test('clears stale credentials when both recovery methods fail', async () => {
+  it('clears stale credentials when both recovery methods fail', async () => {
     let removed = false
 
     const status = await inspectStoredAuthStatus(
@@ -90,7 +90,7 @@ describe('inspectStoredAuthStatus', () => {
     expect(removed).toBe(true)
   })
 
-  test('preserves credentials when session verification fails unexpectedly', async () => {
+  it('preserves credentials when session verification fails unexpectedly', async () => {
     let removed = false
 
     const status = await inspectStoredAuthStatus(
@@ -125,7 +125,7 @@ describe('inspectStoredAuthStatus', () => {
     expect(removed).toBe(false)
   })
 
-  test('recovers via browser extraction when no stored password is available', async () => {
+  it('recovers via browser extraction when no stored password is available', async () => {
     let savedCredentials: Record<string, unknown> | null = null
 
     const status = await inspectStoredAuthStatus(
@@ -160,7 +160,7 @@ describe('inspectStoredAuthStatus', () => {
     expect(savedCredentials).toHaveProperty('loggedInAt')
   })
 
-  test('refreshes the session automatically when encrypted login credentials are available', async () => {
+  it('refreshes the session automatically when stored username and password are available', async () => {
     let savedCredentials: Record<string, string> | null = null
 
     const status = await inspectStoredAuthStatus(

package/src/commands/auth.ts

@@ -1,3 +1,5 @@
+import { createInterface, type Interface as ReadlineInterface } from 'node:readline'
+
 import { Command } from 'commander'
 
 import { CredentialManager } from '../credential-manager'
@@ -7,63 +9,99 @@ 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()
+function ask(rl: ReadlineInterface, message: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      resolve(answer.trim())
+    })
+  })
 }
 
-async function promptPassword(message: string): Promise<string> {
+async function promptPasswordTTY(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)
+  const stdin = process.stdin as typeof process.stdin & { setRawMode?: (mode: boolean) => void }
+  if (stdin.setRawMode) {
+    stdin.setRawMode(true)
   }
+  stdin.resume()
 
   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')
+    return await new Promise<string>((resolve) => {
+      const onData = (chunk: Buffer | string): void => {
+        const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8')
+        for (const char of text) {
+          const code = char.charCodeAt(0)
+          if (code === 13 || code === 10) {
+            // Enter key
+            stdin.removeListener('data', onData)
+            process.stdout.write('\n')
+            resolve(password)
+            return
+          } else if (code === 3) {
+            // Ctrl+C
+            stdin.removeListener('data', onData)
+            process.exit(1)
+          } else if (code === 127 || code === 8) {
+            // Backspace / Delete
+            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('*')
           }
-        } else if (code >= 32 && code <= 126) {
-          // Printable characters
-          password += char
-          process.stdout.write('*')
         }
       }
-    }
+
+      stdin.on('data', onData)
+    })
   } finally {
-    if (originalStdin?.setRawMode) {
-      originalStdin.setRawMode(false)
+    if (stdin.setRawMode) {
+      stdin.setRawMode(false)
     }
+    stdin.pause()
   }
+}
+
+async function promptCredentials(
+  needUsername: boolean,
+  needPassword: boolean,
+): Promise<{ username?: string; password?: string }> {
+  const result: { username?: string; password?: string } = {}
 
-  return password
+  if (needUsername) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false })
+    try {
+      result.username = await ask(rl, 'Username: ')
+    } finally {
+      rl.close()
+    }
+  }
+
+  if (needPassword) {
+    if (process.stdin.isTTY) {
+      result.password = await promptPasswordTTY('Password: ')
+    } else {
+      const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false })
+      try {
+        result.password = await ask(rl, 'Password: ')
+      } finally {
+        rl.close()
+      }
+    }
+  }
+
+  return result
 }
 
 type LoginOptions = { username?: string; password?: string; pretty?: boolean }
 type StatusOptions = { pretty?: boolean }
-type ExtractOptions = { pretty?: boolean }
+type ExtractOptions = { debug?: boolean; pretty?: boolean }
 type ExtractedSessionValidator = Pick<SomaHttp, 'checkLogin' | 'extractCsrfToken'>
 type CredentialStore = Pick<CredentialManager, 'getCredentials' | 'remove' | 'setCredentials'>
 type StatusValidator = Pick<SomaHttp, 'checkLogin'>
@@ -87,21 +125,34 @@ 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: await http.extractCsrfToken(),
+        csrfToken,
       }
-    } catch {}
+    } catch (error) {
+      debug?.(
+        `  ${candidate.browser} / ${candidate.profile}: error: ${error instanceof Error ? error.message : String(error)}`,
+      )
+    }
   }
 
   return null
@@ -112,12 +163,9 @@ async function loginAction(options: LoginOptions): Promise<void> {
     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: ')
-    }
+    const prompted = await promptCredentials(!username, !password)
+    username ??= prompted.username
+    password ??= prompted.password
 
     if (!username || !password) {
       throw new Error('Username and password are required')
@@ -264,22 +312,30 @@ 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 () => { extractCandidates: () => Promise<ExtractedSessionCandidate[]> }
+      TokenExtractor: new (options?: { debug?: boolean }) => {
+        extractCandidates: () => Promise<ExtractedSessionCandidate[]>
+      }
     }
-    const extractor = new TokenExtractor()
+    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 in a supported Chromium browser (Chrome, Edge, Brave, Arc, Vivaldi) first.',
+        '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.',
       )
     }
 
-    const credentials = await resolveExtractedCredentials(candidates)
+    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 login in a supported Chromium browser and try again.',
+        '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.',
       )
     }
 
@@ -319,6 +375,7 @@ export const authCommand = new Command('auth')
   .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

@@ -1,11 +1,11 @@
-import { describe, expect, test } from 'bun:test'
+import { describe, expect, it } from 'bun:test'
 
 import { createAuthenticatedHttp } from './helpers'
 
 const noBrowserExtraction = async () => null
 
 describe('createAuthenticatedHttp', () => {
-  test('throws a login hint when no credentials are stored', async () => {
+  it('throws a login hint when no credentials are stored', async () => {
     const manager = {
       getCredentials: async () => null,
       remove: async () => {},
@@ -16,7 +16,7 @@ describe('createAuthenticatedHttp', () => {
     )
   })
 
-  test('clears stale credentials when both recovery methods fail', async () => {
+  it('clears stale credentials when both recovery methods fail', async () => {
     let removed = false
     const manager = {
       getCredentials: async () => ({
@@ -39,7 +39,7 @@ describe('createAuthenticatedHttp', () => {
     expect(removed).toBe(true)
   })
 
-  test('returns the authenticated http client when the session is valid', async () => {
+  it('returns the authenticated http client when the session is valid', async () => {
     const http = {
       checkLogin: async () => ({ userId: 'neo@example.com', userNm: '전수열' }),
       get: async () => '',
@@ -60,7 +60,7 @@ describe('createAuthenticatedHttp', () => {
     await expect(createAuthenticatedHttp(manager, () => http)).resolves.toBe(http)
   })
 
-  test('re-authenticates automatically when stored username/password are available', async () => {
+  it('re-authenticates automatically when stored username and password are available', async () => {
     let savedCredentials: Record<string, string> | null = null
     const manager = {
       getCredentials: async () => ({
@@ -110,7 +110,7 @@ describe('createAuthenticatedHttp', () => {
     })
   })
 
-  test('recovers via browser extraction when no stored password is available', async () => {
+  it('recovers via browser extraction when no stored password is available', async () => {
     let savedCredentials: Record<string, unknown> | null = null
     const manager = {
       getCredentials: async () => ({
@@ -146,7 +146,7 @@ describe('createAuthenticatedHttp', () => {
     expect(savedCredentials).toHaveProperty('loggedInAt')
   })
 
-  test('falls back to browser extraction when password re-login throws', async () => {
+  it('falls back to browser extraction when password re-login fails', async () => {
     let savedCredentials: Record<string, unknown> | null = null
     const manager = {
       getCredentials: async () => ({
@@ -190,7 +190,7 @@ describe('createAuthenticatedHttp', () => {
     })
   })
 
-  test('does not attempt browser extraction when no credentials exist', async () => {
+  it('skips browser extraction when no credentials exist', async () => {
     let browserExtractionCalled = false
     const manager = {
       getCredentials: async () => null,

package/src/commands/report.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'bun:test'
+import { describe, expect, it } from 'bun:test'
 import { mkdtemp, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
@@ -6,18 +6,18 @@ import { join } from 'node:path'
 import { resolveContent } from './report'
 
 describe('resolveContent', () => {
-  test('returns inline text from --content', async () => {
+  it('returns inline text passed via --content', async () => {
     const result = await resolveContent({ content: 'inline content' })
     expect(result).toBe('inline content')
   })
 
-  test('reads from stdin when --content is -', async () => {
+  it('reads from stdin when --content is "-"', async () => {
     const fakeStdin = async () => 'stdin content'
     const result = await resolveContent({ content: '-' }, fakeStdin)
     expect(result).toBe('stdin content')
   })
 
-  test('reads from file when --content-file is provided', async () => {
+  it('reads from a file when --content-file is provided', async () => {
     const dir = await mkdtemp(join(tmpdir(), 'report-test-'))
     const filePath = join(dir, 'content.txt')
     await writeFile(filePath, '파일에서 읽은 내용입니다.')
@@ -30,18 +30,18 @@ describe('resolveContent', () => {
     }
   })
 
-  test('prefers --content over --content-file when both provided', async () => {
+  it('prefers --content over --content-file when both are provided', async () => {
     const result = await resolveContent({ content: 'inline', contentFile: '/nonexistent' })
     expect(result).toBe('inline')
   })
 
-  test('--content - takes priority over --content-file', async () => {
+  it('prefers stdin (--content -) over --content-file', async () => {
     const fakeStdin = async () => 'from stdin'
     const result = await resolveContent({ content: '-', contentFile: '/nonexistent' }, fakeStdin)
     expect(result).toBe('from stdin')
   })
 
-  test('throws when neither --content nor --content-file is provided', async () => {
+  it('throws when neither --content nor --content-file is provided', async () => {
     await expect(resolveContent({})).rejects.toThrow(
       'Either --content <text> or --content-file <path> is required. Use --content - to read from stdin.',
     )

package/src/constants.ts

@@ -85,3 +85,53 @@ function createTimeSlots(): string[] {
 function formatTime(hour: number, minute: number): string {
   return `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`
 }
+
+export const TOZ_BASE_URL = 'http://partner.toz.co.kr/partner/reservation/fkii3/swmaestro'
+export const TOZ_PARTNER = 'fkii3'
+export const TOZ_COMPANY = 'swmaestro'
+export const TOZ_MEMBER_COMPANY_ID = '25408'
+
+// Static fallback list extracted from booking.htm. Use TozClient.branches() at runtime
+// to fetch the live list — the SW마에스트로 partnership branch set may change.
+export const TOZ_BRANCHES = [
+  { id: 27, name: '강남토즈타워점' },
+  { id: 145, name: '강남컨퍼런스센터' },
+  { id: 19, name: '양재점' },
+  { id: 20, name: '건대점' },
+  { id: 15, name: '선릉점' },
+  { id: 139, name: '마이스 역삼센터' },
+  { id: 134, name: '마이스 광화문센터' },
+  { id: 30, name: '신촌비즈센터' },
+  { id: 149, name: '홍대점' },
+] as const
+
+export const TOZ_PHONE_PREFIXES = ['010', '011', '016', '017', '018', '019'] as const
+
+export const TOZ_EMAIL_DOMAINS = [
+  'hanmail.net',
+  'gmail.com',
+  'nate.com',
+  'naver.com',
+  'daum.net',
+  'dreamwiz.com',
+  'yahoo.com',
+  'yahoo.co.kr',
+  'msn.com',
+  'paran.com',
+  'korea.com',
+  'freechal.com',
+  'lycos.co.kr',
+  'msn.co.kr',
+  'empal.com',
+  'hotmail.com',
+] as const
+
+export const TOZ_EMAIL_DOMAIN_CUSTOM = '직접입력'
+
+export const TOZ_NEW_MEETING_VALUE = '새모임'
+
+export const TOZ_MIN_DURATION_MINUTES = 120
+export const TOZ_MAX_DURATION_MINUTES = 180
+export const TOZ_SESSION_HOLD_SECONDS = 300
+
+export const TOZ_MAX_CHECK_TIMES = 6

package/src/credential-manager.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, test } from 'bun:test'
+import { afterEach, describe, expect, it } from 'bun:test'
 import { mkdtemp, readFile, rm, stat } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
@@ -15,7 +15,7 @@ afterEach(async () => {
 })
 
 describe('CredentialManager', () => {
-  test('loads empty config when file does not exist', async () => {
+  it('loads an empty config when the credentials file does not exist', async () => {
     const dir = await makeTempDir()
     const manager = new CredentialManager(dir)
 
@@ -23,7 +23,7 @@ describe('CredentialManager', () => {
     await expect(manager.getCredentials()).resolves.toBeNull()
   })
 
-  test('saves and loads credentials with secure permissions', async () => {
+  it('saves and loads credentials with secure file permissions', async () => {
     const dir = await makeTempDir()
     const manager = new CredentialManager(dir)
 
@@ -53,7 +53,7 @@ describe('CredentialManager', () => {
     expect(keyFileStat.mode & 0o777).toBe(0o600)
   })
 
-  test('removes credentials file', async () => {
+  it('removes the credentials file', async () => {
     const dir = await makeTempDir()
     const manager = new CredentialManager(dir)
 
@@ -66,7 +66,7 @@ describe('CredentialManager', () => {
     await expect(manager.getCredentials()).resolves.toBeNull()
   })
 
-  test('preserves session credentials when the encryption key is missing', async () => {
+  it('preserves session credentials but drops the password when the encryption key is missing', async () => {
     const dir = await makeTempDir()
     const manager = new CredentialManager(dir)