opensoma 0.4.0 → 0.5.1

package/src/shared/utils/mentoring-params.test.ts

@@ -1,44 +1,44 @@
-import { describe, expect, test } from 'bun:test'
+import { describe, expect, it } from 'bun:test'
 
 import { MENU_NO, REPORT_CD } from '../../constants'
 import { buildMentoringListParams, parseSearchQuery } from './mentoring-params'
 
 describe('parseSearchQuery', () => {
-  test('plain text defaults to title', () => {
+  it('defaults plain text to a title search', () => {
     expect(parseSearchQuery('OpenCode')).toEqual({ field: 'title', value: 'OpenCode' })
   })
 
-  test('title: prefix', () => {
+  it('parses the "title:" prefix as a title search', () => {
     expect(parseSearchQuery('title:OpenCode')).toEqual({ field: 'title', value: 'OpenCode' })
   })
 
-  test('author: prefix', () => {
+  it('parses the "author:" prefix as an author search', () => {
     expect(parseSearchQuery('author:전수열')).toEqual({ field: 'author', value: '전수열' })
   })
 
-  test('author:@me sets me flag', () => {
+  it('sets the "me" flag when parsing "author:@me"', () => {
     expect(parseSearchQuery('author:@me')).toEqual({ field: 'author', value: '@me', me: true })
   })
 
-  test('content: prefix', () => {
+  it('parses the "content:" prefix as a content search', () => {
     expect(parseSearchQuery('content:하네스')).toEqual({ field: 'content', value: '하네스' })
   })
 
-  test('unknown prefix treated as plain title search', () => {
+  it('treats an unknown prefix as a plain title search', () => {
     expect(parseSearchQuery('foo:bar')).toEqual({ field: 'title', value: 'foo:bar' })
   })
 
-  test('value with colons preserves everything after first colon', () => {
+  it('preserves everything after the first colon when the value contains colons', () => {
     expect(parseSearchQuery('title:foo:bar')).toEqual({ field: 'title', value: 'foo:bar' })
   })
 })
 
 describe('buildMentoringListParams', () => {
-  test('no options returns only menuNo', () => {
+  it('returns only menuNo when no options are passed', () => {
     expect(buildMentoringListParams()).toEqual({ menuNo: MENU_NO.MENTORING })
   })
 
-  test('status maps open to A, closed to C', () => {
+  it('maps status open to "A" and closed to "C"', () => {
     expect(buildMentoringListParams({ status: 'open' })).toEqual({
       menuNo: MENU_NO.MENTORING,
       searchStatMentolec: 'A',
@@ -49,7 +49,7 @@ describe('buildMentoringListParams', () => {
     })
   })
 
-  test('type maps public and lecture to report codes', () => {
+  it('maps type public and lecture to their report codes', () => {
     expect(buildMentoringListParams({ type: 'public' })).toEqual({
       menuNo: MENU_NO.MENTORING,
       searchGubunMentolec: REPORT_CD.PUBLIC_MENTORING,
@@ -60,7 +60,7 @@ describe('buildMentoringListParams', () => {
     })
   })
 
-  test('title search sets searchCnd=1', () => {
+  it('sets searchCnd=1 for a title search', () => {
     expect(buildMentoringListParams({ search: { field: 'title', value: 'OpenCode' } })).toEqual({
       menuNo: MENU_NO.MENTORING,
       searchCnd: '1',
@@ -68,7 +68,7 @@ describe('buildMentoringListParams', () => {
     })
   })
 
-  test('author search sets searchCnd=2', () => {
+  it('sets searchCnd=2 for an author search', () => {
     expect(buildMentoringListParams({ search: { field: 'author', value: '전수열' } })).toEqual({
       menuNo: MENU_NO.MENTORING,
       searchCnd: '2',
@@ -76,7 +76,7 @@ describe('buildMentoringListParams', () => {
     })
   })
 
-  test('author:@me with user sets searchId and userNm', () => {
+  it('sets searchId and searchWrd from the current user when "author:@me" is used', () => {
     expect(
       buildMentoringListParams({
         search: { field: 'author', value: '@me', me: true },
@@ -90,7 +90,7 @@ describe('buildMentoringListParams', () => {
     })
   })
 
-  test('search composes with status and type', () => {
+  it('composes search with status and type filters', () => {
     expect(
       buildMentoringListParams({
         status: 'open',
@@ -108,7 +108,7 @@ describe('buildMentoringListParams', () => {
     })
   })
 
-  test('page sets pageIndex', () => {
+  it('sets pageIndex from the page option', () => {
     expect(buildMentoringListParams({ page: 3 })).toEqual({
       menuNo: MENU_NO.MENTORING,
       pageIndex: '3',

package/src/shared/utils/swmaestro.test.ts

@@ -1,9 +1,9 @@
-import { describe, expect, test } from 'bun:test'
+import { describe, expect, it } from 'bun:test'
 
-import { resolveVenue } from './swmaestro'
+import { buildRoomReservationPayload, resolveVenue } from './swmaestro'
 
 describe('resolveVenue', () => {
-  test('adds 토즈- prefix to bare toz location names', () => {
+  it('prepends "토즈-" to bare TOZ location names', () => {
     expect(resolveVenue('광화문점')).toBe('토즈-광화문점')
     expect(resolveVenue('양재점')).toBe('토즈-양재점')
     expect(resolveVenue('강남컨퍼런스센터점')).toBe('토즈-강남컨퍼런스센터점')
@@ -14,17 +14,17 @@ describe('resolveVenue', () => {
     expect(resolveVenue('홍대점')).toBe('토즈-홍대점')
   })
 
-  test('passes through already-prefixed toz locations', () => {
+  it('passes through TOZ locations that already have the prefix', () => {
     expect(resolveVenue('토즈-광화문점')).toBe('토즈-광화문점')
     expect(resolveVenue('토즈-강남역토즈타워점')).toBe('토즈-강남역토즈타워점')
   })
 
-  test('resolves 신촌비즈니스센터점 to 연수센터-7', () => {
+  it('resolves "신촌비즈니스센터점" to "연수센터-7"', () => {
     expect(resolveVenue('신촌비즈니스센터점')).toBe('연수센터-7')
     expect(resolveVenue('토즈-신촌비즈니스센터점')).toBe('연수센터-7')
   })
 
-  test('passes through non-toz venues unchanged', () => {
+  it('passes through non-TOZ venues unchanged', () => {
     expect(resolveVenue('온라인(Webex)')).toBe('온라인(Webex)')
     expect(resolveVenue('스페이스 A1')).toBe('스페이스 A1')
     expect(resolveVenue('스페이스 M1')).toBe('스페이스 M1')
@@ -33,12 +33,91 @@ describe('resolveVenue', () => {
     expect(resolveVenue('(엑스퍼트) 외부_카페')).toBe('(엑스퍼트) 외부_카페')
   })
 
-  test('trims whitespace from input', () => {
+  it('trims surrounding whitespace from the input', () => {
     expect(resolveVenue('  강남역토즈타워점  ')).toBe('토즈-강남역토즈타워점')
     expect(resolveVenue(' 스페이스 A1 ')).toBe('스페이스 A1')
   })
 
-  test('passes through unknown venues unchanged', () => {
+  it('passes through unknown venues unchanged', () => {
     expect(resolveVenue('기타 장소')).toBe('기타 장소')
   })
 })
+
+describe('buildRoomReservationPayload', () => {
+  it('sets rentEndde to the last selected slot so the server reserves only the chosen slots', () => {
+    const payload = buildRoomReservationPayload({
+      roomId: 17,
+      date: '2026-04-20',
+      slots: ['13:00', '13:30'],
+      title: '회의',
+    })
+
+    expect(payload.rentBgnde).toBe('2026-04-20 13:00:00')
+    expect(payload.rentEndde).toBe('2026-04-20 13:30:00')
+    expect(payload['time[0]']).toBe('13:00')
+    expect(payload['time[1]']).toBe('13:30')
+    expect(payload['time[2]']).toBeUndefined()
+    expect(payload['chkData_1']).toBe('2026-04-20|13:00|17')
+    expect(payload['chkData_2']).toBe('2026-04-20|13:30|17')
+    expect(payload['chkData_3']).toBeUndefined()
+  })
+
+  it('handles a single-slot reservation', () => {
+    const payload = buildRoomReservationPayload({
+      roomId: 17,
+      date: '2026-04-20',
+      slots: ['13:00'],
+      title: '회의',
+    })
+
+    expect(payload.rentBgnde).toBe('2026-04-20 13:00:00')
+    expect(payload.rentEndde).toBe('2026-04-20 13:00:00')
+    expect(payload['time[0]']).toBe('13:00')
+    expect(payload['time[1]']).toBeUndefined()
+  })
+
+  it('handles a reservation ending at the last available slot', () => {
+    const payload = buildRoomReservationPayload({
+      roomId: 17,
+      date: '2026-04-20',
+      slots: ['23:00', '23:30'],
+      title: '회의',
+    })
+
+    expect(payload.rentBgnde).toBe('2026-04-20 23:00:00')
+    expect(payload.rentEndde).toBe('2026-04-20 23:30:00')
+  })
+
+  it('rejects non-consecutive slots', () => {
+    expect(() =>
+      buildRoomReservationPayload({
+        roomId: 17,
+        date: '2026-04-20',
+        slots: ['13:00', '14:00'],
+        title: '회의',
+      }),
+    ).toThrow('Time slots must be consecutive')
+  })
+
+  it('rejects invalid time slots', () => {
+    expect(() =>
+      buildRoomReservationPayload({
+        roomId: 17,
+        date: '2026-04-20',
+        slots: ['25:00'],
+        title: '회의',
+      }),
+    ).toThrow('Invalid time slot')
+  })
+
+  it('rejects empty slot lists', () => {
+    expect(() =>
+      buildRoomReservationPayload({
+        roomId: 17,
+        date: '2026-04-20',
+        slots: [],
+        title: '회의',
+      }),
+    ).toThrow('At least one time slot is required')
+  })
+})

package/src/shared/utils/swmaestro.ts

@@ -142,17 +142,12 @@ export function buildRoomReservationPayload(params: {
 
   const firstSlot = params.slots[0]
   const lastSlot = params.slots[params.slots.length - 1]
-  const endSlot = TIME_SLOTS[TIME_SLOTS.indexOf(lastSlot) + 1]
-
-  if (!endSlot) {
-    throw new Error('Reservation end time is out of range')
-  }
 
   const payload: Record<string, string> = {
     menuNo: MENU_NO.ROOM,
     itemId: String(params.roomId),
     rentBgnde: `${params.date} ${firstSlot}:00`,
-    rentEndde: `${params.date} ${endSlot}:00`,
+    rentEndde: `${params.date} ${lastSlot}:00`,
     title: params.title,
     rentDt: params.date,
     rentNum: String(params.attendees ?? 1),

package/src/shared/utils/toz.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  assertDurationInRange,
+  buildBranchIdsParam,
+  buildStartTimeParam,
+  formatDuration,
+  formatPhone,
+  formatStartTime,
+  parseDurationKey,
+  parseEmail,
+  parsePhone,
+} from './toz'
+
+describe('formatDuration', () => {
+  it('formats hours+minutes as HHMM', () => {
+    expect(formatDuration(120)).toBe('0200')
+    expect(formatDuration(150)).toBe('0230')
+    expect(formatDuration(180)).toBe('0300')
+    expect(formatDuration(90)).toBe('0130')
+  })
+
+  it('throws on invalid input', () => {
+    expect(() => formatDuration(0)).toThrow()
+    expect(() => formatDuration(-30)).toThrow()
+    expect(() => formatDuration(1.5)).toThrow()
+  })
+})
+
+describe('parseDurationKey', () => {
+  it('parses HHMM keys to minutes', () => {
+    expect(parseDurationKey('0200')).toBe(120)
+    expect(parseDurationKey('0230')).toBe(150)
+    expect(parseDurationKey('1300')).toBe(780)
+  })
+
+  it('throws on invalid key', () => {
+    expect(() => parseDurationKey('0')).toThrow()
+    expect(() => parseDurationKey('abcd')).toThrow()
+    expect(() => parseDurationKey('20000')).toThrow()
+  })
+})
+
+describe('formatStartTime / buildStartTimeParam', () => {
+  it('splits HH:MM', () => {
+    expect(formatStartTime('10:00')).toEqual({ hour: '10', minute: '00' })
+    expect(formatStartTime('9:30')).toEqual({ hour: '09', minute: '30' })
+  })
+
+  it('joins to 4-digit param', () => {
+    expect(buildStartTimeParam('10:00')).toBe('1000')
+    expect(buildStartTimeParam('9:05')).toBe('0905')
+  })
+
+  it('rejects time without colon separator', () => {
+    expect(() => formatStartTime('1000')).toThrow()
+  })
+
+  it('accepts out-of-range hours because the format matches', () => {
+    expect(formatStartTime('25:00')).toEqual({ hour: '25', minute: '00' })
+  })
+})
+
+describe('buildBranchIdsParam', () => {
+  it('joins with trailing comma', () => {
+    expect(buildBranchIdsParam([27])).toBe('27,')
+    expect(buildBranchIdsParam([27, 145])).toBe('27,145,')
+    expect(buildBranchIdsParam([27, 145, 19, 20, 15, 139, 134, 30, 149])).toBe('27,145,19,20,15,139,134,30,149,')
+  })
+
+  it('rejects empty list', () => {
+    expect(() => buildBranchIdsParam([])).toThrow()
+  })
+})
+
+describe('parsePhone', () => {
+  it('parses standard 010-XXXX-YYYY', () => {
+    expect(parsePhone('010-1234-5678')).toEqual({ phone1: '010', phone2: '1234', phone3: '5678' })
+  })
+
+  it('parses 010 with no dashes', () => {
+    expect(parsePhone('01012345678')).toEqual({ phone1: '010', phone2: '1234', phone3: '5678' })
+  })
+
+  it('parses old 011-XXX-YYYY', () => {
+    expect(parsePhone('011-123-4567')).toEqual({ phone1: '011', phone2: '123', phone3: '4567' })
+  })
+
+  it('rejects unsupported prefix', () => {
+    expect(() => parsePhone('012-1234-5678')).toThrow()
+  })
+
+  it('rejects invalid length', () => {
+    expect(() => parsePhone('010-12-34')).toThrow()
+  })
+})
+
+describe('formatPhone', () => {
+  it('joins to dashed format', () => {
+    expect(formatPhone({ phone1: '010', phone2: '1234', phone3: '5678' })).toBe('010-1234-5678')
+  })
+})
+
+describe('parseEmail', () => {
+  it('uses select option for known domain', () => {
+    expect(parseEmail('user@gmail.com')).toEqual({ email1: 'user', email2: 'gmail.com', email3: '' })
+    expect(parseEmail('me@naver.com')).toEqual({ email1: 'me', email2: 'naver.com', email3: '' })
+  })
+
+  it('uses 직접입력 for custom domain', () => {
+    expect(parseEmail('user@customdomain.io')).toEqual({
+      email1: 'user',
+      email2: '직접입력',
+      email3: 'customdomain.io',
+    })
+  })
+
+  it('rejects malformed email', () => {
+    expect(() => parseEmail('userdomain.com')).toThrow()
+    expect(() => parseEmail('@domain.com')).toThrow()
+    expect(() => parseEmail('user@')).toThrow()
+  })
+})
+
+describe('assertDurationInRange', () => {
+  it('accepts boundary and interior values', () => {
+    expect(assertDurationInRange(120)).toBeUndefined()
+    expect(assertDurationInRange(150)).toBeUndefined()
+    expect(assertDurationInRange(180)).toBeUndefined()
+  })
+
+  it('rejects values just outside the boundary', () => {
+    expect(() => assertDurationInRange(119)).toThrow()
+    expect(() => assertDurationInRange(181)).toThrow()
+    expect(() => assertDurationInRange(60)).toThrow()
+    expect(() => assertDurationInRange(210)).toThrow()
+  })
+})

package/src/shared/utils/toz.ts

@@ -0,0 +1,100 @@
+import {
+  TOZ_EMAIL_DOMAIN_CUSTOM,
+  TOZ_EMAIL_DOMAINS,
+  TOZ_MAX_DURATION_MINUTES,
+  TOZ_MIN_DURATION_MINUTES,
+  TOZ_PHONE_PREFIXES,
+} from '../../constants'
+
+export interface ParsedPhone {
+  phone1: string
+  phone2: string
+  phone3: string
+}
+
+export interface ParsedEmail {
+  email1: string
+  email2: string
+  email3: string
+}
+
+export function formatDuration(minutes: number): string {
+  if (!Number.isInteger(minutes) || minutes <= 0) {
+    throw new Error(`Invalid duration minutes: ${minutes}`)
+  }
+  const hh = Math.floor(minutes / 60)
+  const mm = minutes % 60
+  return `${String(hh).padStart(2, '0')}${String(mm).padStart(2, '0')}`
+}
+
+export function parseDurationKey(key: string): number {
+  if (!/^\d{4}$/.test(key)) {
+    throw new Error(`Invalid duration key: ${key}`)
+  }
+  const hh = Number.parseInt(key.slice(0, 2), 10)
+  const mm = Number.parseInt(key.slice(2, 4), 10)
+  return hh * 60 + mm
+}
+
+export function formatStartTime(time: string): { hour: string; minute: string } {
+  const match = /^(\d{1,2}):(\d{2})$/.exec(time)
+  if (!match) {
+    throw new Error(`Invalid time: ${time} (expected HH:MM)`)
+  }
+  return { hour: match[1].padStart(2, '0'), minute: match[2] }
+}
+
+export function buildStartTimeParam(time: string): string {
+  const { hour, minute } = formatStartTime(time)
+  return `${hour}${minute}`
+}
+
+export function buildBranchIdsParam(branchIds: readonly number[]): string {
+  if (branchIds.length === 0) {
+    throw new Error('At least one branchId is required')
+  }
+  return `${branchIds.join(',')},`
+}
+
+export function parsePhone(phone: string): ParsedPhone {
+  const digits = phone.replace(/[^0-9]/g, '')
+  const prefix = TOZ_PHONE_PREFIXES.find((p) => digits.startsWith(p))
+  if (!prefix) {
+    throw new Error(`Unsupported phone prefix in: ${phone}`)
+  }
+  const rest = digits.slice(prefix.length)
+  if (rest.length !== 7 && rest.length !== 8) {
+    throw new Error(`Invalid phone number: ${phone}`)
+  }
+  const split = rest.length - 4
+  return {
+    phone1: prefix,
+    phone2: rest.slice(0, split),
+    phone3: rest.slice(split),
+  }
+}
+
+export function formatPhone(parsed: ParsedPhone): string {
+  return `${parsed.phone1}-${parsed.phone2}-${parsed.phone3}`
+}
+
+export function parseEmail(email: string): ParsedEmail {
+  const at = email.indexOf('@')
+  if (at <= 0 || at === email.length - 1) {
+    throw new Error(`Invalid email: ${email}`)
+  }
+  const local = email.slice(0, at)
+  const domain = email.slice(at + 1)
+  const known = (TOZ_EMAIL_DOMAINS as readonly string[]).includes(domain)
+  return known
+    ? { email1: local, email2: domain, email3: '' }
+    : { email1: local, email2: TOZ_EMAIL_DOMAIN_CUSTOM, email3: domain }
+}
+
+export function assertDurationInRange(minutes: number): void {
+  if (minutes < TOZ_MIN_DURATION_MINUTES || minutes > TOZ_MAX_DURATION_MINUTES) {
+    throw new Error(
+      `SW마에스트로 partnership requires duration between ${TOZ_MIN_DURATION_MINUTES / 60}h and ${TOZ_MAX_DURATION_MINUTES / 60}h (got ${minutes} minutes)`,
+    )
+  }
+}

package/src/token-extractor.test.ts

@@ -1,5 +1,5 @@
 import { Database } from 'bun:sqlite'
-import { afterEach, describe, expect, test } from 'bun:test'
+import { afterEach, describe, expect, it } from 'bun:test'
 import { execSync } from 'node:child_process'
 import { createCipheriv, pbkdf2Sync } from 'node:crypto'
 import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
@@ -22,7 +22,7 @@ afterEach(() => {
 })
 
 describe('TokenExtractor', () => {
-  test('finds cookie databases for all browsers on macOS', async () => {
+  it('finds cookie databases for every supported browser on macOS', async () => {
     const home = await makeTempDir()
 
     for (const browser of BROWSERS) {
@@ -38,7 +38,7 @@ describe('TokenExtractor', () => {
     }
   })
 
-  test('finds cookie databases for all browsers on Linux', async () => {
+  it('finds cookie databases for every supported browser on Linux', async () => {
     const home = await makeTempDir()
 
     for (const browser of BROWSERS) {
@@ -51,12 +51,12 @@ describe('TokenExtractor', () => {
     expect(paths).toHaveLength(BROWSERS.length)
   })
 
-  test('returns null when no cookie databases exist', async () => {
+  it('returns null when no cookie databases exist', async () => {
     const extractor = new TokenExtractor('linux', await makeTempDir())
     expect(await extractor.extract()).toBeNull()
   })
 
-  test('extracts plaintext cookie value', async () => {
+  it('extracts a plaintext cookie value', async () => {
     const home = await makeTempDir()
     const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
     createCookieDbWithPlaintext(dbPath, 'my-session-id')
@@ -65,7 +65,7 @@ describe('TokenExtractor', () => {
     expect(await extractor.extract()).toEqual({ sessionCookie: 'my-session-id' })
   })
 
-  test('finds cookie databases across numbered browser profiles', async () => {
+  it('finds cookie databases across numbered browser profiles', async () => {
     const home = await makeTempDir()
     createCookieFile(join(home, '.config', 'google-chrome', 'Default', 'Cookies'))
     createCookieFile(join(home, '.config', 'google-chrome', 'Profile 1', 'Cookies'))
@@ -80,7 +80,7 @@ describe('TokenExtractor', () => {
     ])
   })
 
-  test('extractCandidates keeps the newest unique cookie across profiles', async () => {
+  it('keeps the newest unique cookie across profiles when collecting candidates', async () => {
     const home = await makeTempDir()
     createCookieDbWithPlaintext(join(home, '.config', 'google-chrome', 'Default', 'Cookies'), 'stale-session', 10)
     createCookieDbWithPlaintext(join(home, '.config', 'google-chrome', 'Profile 1', 'Cookies'), 'valid-session', 20)
@@ -104,7 +104,26 @@ describe('TokenExtractor', () => {
     ])
   })
 
-  test('decrypts encrypted cookie on Linux', async () => {
+  it('extracts a plaintext cookie from the opensoma.dev host', async () => {
+    const home = await makeTempDir()
+    const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
+    createCookieDbWithPlaintext(dbPath, 'opensoma-dev-session', 0, 'opensoma.dev')
+
+    const extractor = new TokenExtractor('linux', home)
+    expect(await extractor.extract()).toEqual({ sessionCookie: 'opensoma-dev-session' })
+  })
+
+  it('decrypts an encrypted cookie from the opensoma.dev host on Linux', async () => {
+    const home = await makeTempDir()
+    const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
+    const encrypted = encryptLinuxCookie('opensoma-dev-encrypted')
+    createCookieDbWithEncrypted(dbPath, encrypted, 'opensoma.dev')
+
+    const extractor = new TokenExtractor('linux', home)
+    expect(await extractor.extract()).toEqual({ sessionCookie: 'opensoma-dev-encrypted' })
+  })
+
+  it('decrypts an encrypted cookie on Linux', async () => {
     const home = await makeTempDir()
     const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
     const encrypted = encryptLinuxCookie('decrypted-session')
@@ -114,7 +133,7 @@ describe('TokenExtractor', () => {
     expect(await extractor.extract()).toEqual({ sessionCookie: 'decrypted-session' })
   })
 
-  test('extracts plaintext cookie under Node.js (compiled ESM)', async () => {
+  it('extracts a plaintext cookie when running under Node.js (compiled ESM)', async () => {
     execSync('bun run build', { cwd: join(import.meta.dir, '..'), stdio: 'pipe' })
     const home = await makeTempDir()
     const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
@@ -125,7 +144,7 @@ describe('TokenExtractor', () => {
     expect(JSON.parse(result.trim())).toEqual({ sessionCookie: 'node-test-session' })
   })
 
-  test('extracts encrypted cookie under Node.js (compiled ESM)', async () => {
+  it('extracts an encrypted cookie when running under Node.js (compiled ESM)', async () => {
     execSync('bun run build', { cwd: join(import.meta.dir, '..'), stdio: 'pipe' })
     const home = await makeTempDir()
     const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
@@ -148,26 +167,32 @@ function createCookieFile(filePath: string): void {
   writeFileSync(filePath, '')
 }
 
-function createCookieDbWithPlaintext(filePath: string, value: string, lastAccessUtc = 0): void {
+function createCookieDbWithPlaintext(
+  filePath: string,
+  value: string,
+  lastAccessUtc = 0,
+  hostKey = 'swmaestro.ai',
+): void {
   mkdirSync(dirname(filePath), { recursive: true })
   const db = new Database(filePath)
   db.run(
     'CREATE TABLE cookies (host_key TEXT, name TEXT, value TEXT, encrypted_value BLOB, creation_utc INTEGER, expires_utc INTEGER, is_httponly INTEGER, has_expires INTEGER, is_persistent INTEGER, priority INTEGER, samesite INTEGER, source_scheme INTEGER, is_secure INTEGER, path TEXT, last_access_utc INTEGER, last_update_utc INTEGER, source_port INTEGER, source_type INTEGER)',
   )
   db.run(
-    "INSERT INTO cookies (host_key, name, value, encrypted_value, last_access_utc) VALUES ('swmaestro.ai', 'JSESSIONID', ?, '', ?)",
-    [value, lastAccessUtc],
+    "INSERT INTO cookies (host_key, name, value, encrypted_value, last_access_utc) VALUES (?, 'JSESSIONID', ?, '', ?)",
+    [hostKey, value, lastAccessUtc],
   )
   db.close()
 }
 
-function createCookieDbWithEncrypted(filePath: string, encrypted: Buffer): void {
+function createCookieDbWithEncrypted(filePath: string, encrypted: Buffer, hostKey = 'swmaestro.ai'): void {
   mkdirSync(dirname(filePath), { recursive: true })
   const db = new Database(filePath)
   db.run(
     'CREATE TABLE cookies (host_key TEXT, name TEXT, value TEXT, encrypted_value BLOB, creation_utc INTEGER, expires_utc INTEGER, is_httponly INTEGER, has_expires INTEGER, is_persistent INTEGER, priority INTEGER, samesite INTEGER, source_scheme INTEGER, is_secure INTEGER, path TEXT, last_access_utc INTEGER, last_update_utc INTEGER, source_port INTEGER, source_type INTEGER)',
   )
-  db.run("INSERT INTO cookies (host_key, name, value, encrypted_value) VALUES ('swmaestro.ai', 'JSESSIONID', '', ?)", [
+  db.run("INSERT INTO cookies (host_key, name, value, encrypted_value) VALUES (?, 'JSESSIONID', '', ?)", [
+    hostKey,
     encrypted,
   ])
   db.close()