opensoma 0.1.0

package/src/token-extractor.test.ts

@@ -0,0 +1,119 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { createCipheriv, pbkdf2Sync } from 'node:crypto'
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { mkdtemp } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { Database } from 'bun:sqlite'
+
+import { BROWSERS, TokenExtractor } from './token-extractor'
+
+const CHROMIUM_IV = Buffer.alloc(16, 0x20)
+const CHROMIUM_SALT = 'saltysalt'
+
+let createdDirs: string[] = []
+
+afterEach(() => {
+  for (const dir of createdDirs) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+  createdDirs = []
+})
+
+describe('TokenExtractor', () => {
+  test('finds cookie databases for all browsers on macOS', async () => {
+    const home = await makeTempDir()
+
+    for (const browser of BROWSERS) {
+      createCookieFile(join(home, 'Library', 'Application Support', browser.macPath, 'Default', 'Cookies'))
+    }
+
+    const extractor = new TokenExtractor('darwin', home)
+    const paths = extractor.findCookieDatabases()
+
+    expect(paths).toHaveLength(BROWSERS.length)
+    for (const browser of BROWSERS) {
+      expect(paths).toContainEqual(
+        join(home, 'Library', 'Application Support', browser.macPath, 'Default', 'Cookies'),
+      )
+    }
+  })
+
+  test('finds cookie databases for all browsers on Linux', async () => {
+    const home = await makeTempDir()
+
+    for (const browser of BROWSERS) {
+      createCookieFile(join(home, '.config', browser.linuxPath, 'Default', 'Cookies'))
+    }
+
+    const extractor = new TokenExtractor('linux', home)
+    const paths = extractor.findCookieDatabases()
+
+    expect(paths).toHaveLength(BROWSERS.length)
+  })
+
+  test('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 () => {
+    const home = await makeTempDir()
+    const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
+    createCookieDbWithPlaintext(dbPath, 'my-session-id')
+
+    const extractor = new TokenExtractor('linux', home)
+    expect(await extractor.extract()).toEqual({ sessionCookie: 'my-session-id' })
+  })
+
+  test('decrypts encrypted cookie on Linux', async () => {
+    const home = await makeTempDir()
+    const dbPath = join(home, '.config', 'google-chrome', 'Default', 'Cookies')
+    const encrypted = encryptLinuxCookie('decrypted-session')
+    createCookieDbWithEncrypted(dbPath, encrypted)
+
+    const extractor = new TokenExtractor('linux', home)
+    expect(await extractor.extract()).toEqual({ sessionCookie: 'decrypted-session' })
+  })
+})
+
+async function makeTempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), 'opensoma-token-extractor-'))
+  createdDirs.push(dir)
+  return dir
+}
+
+function createCookieFile(filePath: string): void {
+  mkdirSync(dirname(filePath), { recursive: true })
+  writeFileSync(filePath, '')
+}
+
+function createCookieDbWithPlaintext(filePath: string, value: string): 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', ?, '')", [
+    value,
+  ])
+  db.close()
+}
+
+function createCookieDbWithEncrypted(filePath: string, encrypted: Buffer): 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', '', ?)", [
+    encrypted,
+  ])
+  db.close()
+}
+
+function encryptLinuxCookie(value: string): Buffer {
+  const key = pbkdf2Sync('peanuts', CHROMIUM_SALT, 1, 16, 'sha1')
+  const cipher = createCipheriv('aes-128-cbc', key, CHROMIUM_IV)
+  return Buffer.concat([Buffer.from('v10'), cipher.update(value, 'utf8'), cipher.final()])
+}

package/src/token-extractor.ts

@@ -0,0 +1,205 @@
+import { execSync } from 'node:child_process'
+import { createDecipheriv, pbkdf2Sync } from 'node:crypto'
+import { copyFileSync, existsSync, mkdtempSync, rmSync } from 'node:fs'
+import { homedir, tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const COOKIE_QUERY =
+  "SELECT encrypted_value, value FROM cookies WHERE host_key LIKE '%swmaestro.ai' AND name = 'JSESSIONID' ORDER BY last_access_utc DESC LIMIT 1"
+const CHROMIUM_SALT = 'saltysalt'
+const CHROMIUM_IV = Buffer.alloc(16, 0x20)
+
+type BrowserConfig = {
+  name: string
+  macPath: string
+  linuxPath: string
+  keychainService: string
+  keychainAccount: string
+}
+
+type CookieRow = {
+  encrypted_value: Uint8Array | Buffer | null
+  value: string | null
+}
+
+export const BROWSERS: BrowserConfig[] = [
+  {
+    name: 'Chrome',
+    macPath: 'Google Chrome',
+    linuxPath: 'google-chrome',
+    keychainService: 'Chrome Safe Storage',
+    keychainAccount: 'Chrome',
+  },
+  {
+    name: 'Edge',
+    macPath: 'Microsoft Edge',
+    linuxPath: 'microsoft-edge',
+    keychainService: 'Microsoft Edge Safe Storage',
+    keychainAccount: 'Microsoft Edge',
+  },
+  {
+    name: 'Brave',
+    macPath: 'BraveSoftware/Brave-Browser',
+    linuxPath: 'BraveSoftware/Brave-Browser',
+    keychainService: 'Brave Safe Storage',
+    keychainAccount: 'Brave',
+  },
+  {
+    name: 'Arc',
+    macPath: join('Arc', 'User Data'),
+    linuxPath: join('Arc', 'User Data'),
+    keychainService: 'Arc Safe Storage',
+    keychainAccount: 'Arc',
+  },
+  {
+    name: 'Vivaldi',
+    macPath: 'Vivaldi',
+    linuxPath: 'Vivaldi',
+    keychainService: 'Vivaldi Safe Storage',
+    keychainAccount: 'Vivaldi',
+  },
+  {
+    name: 'Chromium',
+    macPath: 'Chromium',
+    linuxPath: 'Chromium',
+    keychainService: 'Chromium Safe Storage',
+    keychainAccount: 'Chromium',
+  },
+]
+
+function queryCookieDb(dbPath: string): CookieRow | undefined {
+  if (typeof globalThis.Bun !== 'undefined') {
+    const { Database } = require('bun:sqlite')
+    const db = new Database(dbPath, { readonly: true })
+    try {
+      const row = db.query(COOKIE_QUERY).get() as CookieRow | undefined
+      return row ?? undefined
+    } finally {
+      db.close()
+    }
+  }
+
+  const Database = require('better-sqlite3')
+  const db = new Database(dbPath, { readonly: true })
+  try {
+    return db.prepare(COOKIE_QUERY).get() as CookieRow | undefined
+  } finally {
+    db.close()
+  }
+}
+
+export class TokenExtractor {
+  constructor(
+    private readonly platform: NodeJS.Platform = process.platform,
+    private readonly homeDirectory: string = homedir(),
+  ) {}
+
+  async extract(): Promise<{ sessionCookie: string } | null> {
+    for (const databasePath of this.findCookieDatabases()) {
+      const browser = this.getBrowserByPath(databasePath)
+      if (!browser) {
+        continue
+      }
+
+      const tempDirectory = mkdtempSync(join(tmpdir(), 'opensoma-cookie-db-'))
+      const tempDatabasePath = join(tempDirectory, 'Cookies')
+
+      try {
+        copyFileSync(databasePath, tempDatabasePath)
+
+        const row = queryCookieDb(tempDatabasePath)
+        if (!row) {
+          continue
+        }
+
+        const plaintextValue = typeof row.value === 'string' ? row.value.trim() : ''
+        if (plaintextValue) {
+          return { sessionCookie: plaintextValue }
+        }
+
+        if (!row.encrypted_value || row.encrypted_value.length === 0) {
+          continue
+        }
+
+        const decryptedValue = await this.decryptCookie(Buffer.from(row.encrypted_value), browser.name)
+        if (decryptedValue) {
+          return { sessionCookie: decryptedValue }
+        }
+      } catch {
+        continue
+      } finally {
+        rmSync(tempDirectory, { recursive: true, force: true })
+      }
+    }
+
+    return null
+  }
+
+  findCookieDatabases(): string[] {
+    const browserPaths =
+      this.platform === 'darwin'
+        ? BROWSERS.map((browser) =>
+            join(this.homeDirectory, 'Library', 'Application Support', browser.macPath, 'Default', 'Cookies'),
+          )
+        : this.platform === 'linux'
+          ? BROWSERS.map((browser) => join(this.homeDirectory, '.config', browser.linuxPath, 'Default', 'Cookies'))
+          : []
+
+    return browserPaths.filter((databasePath) => existsSync(databasePath))
+  }
+
+  private async decryptCookie(encryptedValue: Buffer, browserName: string): Promise<string> {
+    if (encryptedValue.length === 0) {
+      return ''
+    }
+
+    if (this.platform === 'linux') {
+      return this.decryptChromiumValue(encryptedValue, pbkdf2Sync('peanuts', CHROMIUM_SALT, 1, 16, 'sha1'))
+    }
+
+    if (this.platform === 'darwin') {
+      const key = await this.getMacOSEncryptionKey(browserName)
+      return this.decryptChromiumValue(encryptedValue, key)
+    }
+
+    return ''
+  }
+
+  private async getMacOSEncryptionKey(browserName: string): Promise<Buffer> {
+    const browser = BROWSERS.find((entry) => entry.name === browserName)
+    if (!browser) {
+      throw new Error(`Unsupported browser: ${browserName}`)
+    }
+
+    const password = execSync(
+      `security find-generic-password -s ${JSON.stringify(browser.keychainService)} -a ${JSON.stringify(browser.keychainAccount)} -w`,
+      { encoding: 'utf8' },
+    ).trimEnd()
+
+    return pbkdf2Sync(password, CHROMIUM_SALT, 1003, 16, 'sha1')
+  }
+
+  private decryptChromiumValue(encryptedValue: Buffer, key: Buffer): string {
+    const encryptedPayload =
+      encryptedValue.subarray(0, 3).toString('utf8') === 'v10' ? encryptedValue.subarray(3) : encryptedValue
+    const decipher = createDecipheriv('aes-128-cbc', key, CHROMIUM_IV)
+    decipher.setAutoPadding(true)
+    const decrypted = Buffer.concat([decipher.update(encryptedPayload), decipher.final()])
+
+    // Chromium v130+ prepends a 32-byte integrity hash before the actual cookie value
+    if (decrypted.length > 32) {
+      const hasNonPrintablePrefix = decrypted.subarray(0, 32).some((b) => b < 0x20 || b > 0x7e)
+      if (hasNonPrintablePrefix) {
+        return decrypted.subarray(32).toString('utf8')
+      }
+    }
+
+    return decrypted.toString('utf8')
+  }
+
+  private getBrowserByPath(databasePath: string): BrowserConfig | undefined {
+    return BROWSERS.find(
+      (browser) => databasePath.includes(`${browser.macPath}/`) || databasePath.includes(`${browser.linuxPath}/`),
+    )
+  }
+}

package/src/types.test.ts

@@ -0,0 +1,172 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  ApplicationHistoryItemSchema,
+  CredentialsSchema,
+  DashboardSchema,
+  EventListItemSchema,
+  MemberInfoSchema,
+  MentoringDetailSchema,
+  MentoringListItemSchema,
+  NoticeDetailSchema,
+  NoticeListItemSchema,
+  PaginationSchema,
+  RoomCardSchema,
+  TeamInfoSchema,
+} from '@/types'
+
+describe('schemas', () => {
+  test('accept valid values', () => {
+    expect(
+      MentoringListItemSchema.parse({
+        id: 9572,
+        title: 'AI 멘토링',
+        type: '자유 멘토링',
+        registrationPeriod: { start: '2026-04-01', end: '2026-04-10' },
+        sessionDate: '2026-04-11',
+        sessionTime: { start: '14:00', end: '15:30' },
+        attendees: { current: 3, max: 4 },
+        approved: true,
+        status: '접수중',
+        author: '전수열',
+        createdAt: '2026-04-01',
+      }),
+    ).toBeDefined()
+
+    expect(
+      MentoringDetailSchema.parse({
+        id: 9572,
+        title: 'AI 멘토링',
+        type: '멘토 특강',
+        registrationPeriod: { start: '2026-04-01', end: '2026-04-10' },
+        sessionDate: '2026-04-11',
+        sessionTime: { start: '14:00', end: '15:30' },
+        attendees: { current: 6, max: 20 },
+        approved: false,
+        status: '마감',
+        author: '전수열',
+        createdAt: '2026-04-01',
+        content: '<p>내용</p>',
+        venue: '온라인(Webex)',
+      }),
+    ).toBeDefined()
+
+    expect(
+      RoomCardSchema.parse({
+        itemId: 17,
+        name: '스페이스 A1',
+        capacity: 4,
+        availablePeriod: { start: '2026-04-01', end: '2026-12-31' },
+        description: '소회의실 : 4인',
+        timeSlots: [{ time: '09:00', available: true }],
+      }),
+    ).toBeDefined()
+
+    expect(
+      DashboardSchema.parse({
+        name: '전수열',
+        role: '멘토',
+        organization: 'Indent',
+        position: '',
+        team: { name: '오픈소마', members: '전수열, 김개발', mentor: '전수열' },
+        mentoringSessions: [{ title: 'AI 멘토링', url: '/mentoring/1', status: '접수중' }],
+        roomReservations: [{ title: 'A1 회의', url: '/room/1', status: '예약완료' }],
+      }),
+    ).toBeDefined()
+
+    expect(
+      NoticeListItemSchema.parse({
+        id: 1,
+        title: '공지',
+        author: '관리자',
+        createdAt: '2026-04-01',
+      }),
+    ).toBeDefined()
+
+    expect(
+      NoticeDetailSchema.parse({
+        id: 1,
+        title: '공지',
+        author: '관리자',
+        createdAt: '2026-04-01',
+        content: '<p>내용</p>',
+      }),
+    ).toBeDefined()
+
+    expect(
+      TeamInfoSchema.parse({
+        teams: [
+          { name: '오픈소마', memberCount: 3, joinStatus: '참여중' },
+          { name: '김앤강', memberCount: 5, joinStatus: '참여하기' },
+        ],
+        currentTeams: 1,
+        maxTeams: 100,
+      }),
+    ).toBeDefined()
+
+    expect(
+      MemberInfoSchema.parse({
+        email: 'neo@example.com',
+        name: '전수열',
+        gender: '남자',
+        birthDate: '1995-01-14',
+        phone: '01012345678',
+        organization: 'Indent',
+        position: '',
+      }),
+    ).toBeDefined()
+
+    expect(
+      EventListItemSchema.parse({
+        id: 11,
+        category: '행사',
+        title: '데모데이',
+        registrationPeriod: { start: '2026-04-01', end: '2026-04-05' },
+        eventPeriod: { start: '2026-04-10', end: '2026-04-10' },
+        status: '접수중',
+        createdAt: '2026-03-30',
+      }),
+    ).toBeDefined()
+
+    expect(
+      ApplicationHistoryItemSchema.parse({
+        id: 99,
+        category: '멘토 특강',
+        title: 'AI 멘토링',
+        author: '전수열',
+        sessionDate: '2026-04-11',
+        appliedAt: '2026-04-02 09:00',
+        applicationStatus: '신청완료',
+        approvalStatus: 'OK',
+        applicationDetail: '승인대기',
+        note: '-',
+      }),
+    ).toBeDefined()
+
+    expect(PaginationSchema.parse({ total: 23, currentPage: 2, totalPages: 3 })).toBeDefined()
+
+    expect(
+      CredentialsSchema.parse({
+        sessionCookie: 'session-token',
+        csrfToken: 'csrf-token',
+        username: 'neo@example.com',
+        loggedInAt: '2026-04-09T00:00:00.000Z',
+      }),
+    ).toBeDefined()
+  })
+
+  test('reject invalid values', () => {
+    expect(() => MentoringListItemSchema.parse({})).toThrow()
+    expect(() => MentoringDetailSchema.parse({ content: 123 })).toThrow()
+    expect(() => RoomCardSchema.parse({ itemId: '17' })).toThrow()
+    expect(() => DashboardSchema.parse({ name: '전수열' })).toThrow()
+    expect(() => NoticeListItemSchema.parse({ id: 1, title: '공지' })).toThrow()
+    expect(() => NoticeDetailSchema.parse({ id: 1, title: '공지', author: '관리자', createdAt: '2026-04-01' })).toThrow()
+    expect(() => TeamInfoSchema.parse({ teams: [{ name: '김개발' }], currentTeams: 1, maxTeams: 100 })).toThrow()
+    expect(() => MemberInfoSchema.parse({ email: 1, name: '전수열' })).toThrow()
+    expect(() => EventListItemSchema.parse({ id: 1, title: '행사', status: '접수중' })).toThrow()
+    expect(() => ApplicationHistoryItemSchema.parse({ id: 1, status: '신청완료' })).toThrow()
+    expect(() => PaginationSchema.parse({ total: '23', currentPage: 2, totalPages: 3 })).toThrow()
+    expect(() => CredentialsSchema.parse({ sessionCookie: 'cookie' })).toThrow()
+  })
+})

package/src/types.ts

@@ -0,0 +1,134 @@
+import { z } from 'zod/v4'
+
+const DateRangeSchema = z.object({ start: z.string(), end: z.string() })
+const TimeRangeSchema = z.object({ start: z.string(), end: z.string() })
+const RoomTimeSlotSchema = z.object({ time: z.string(), available: z.boolean() })
+const DashboardStatusItemSchema = z.object({
+  title: z.string(),
+  url: z.string(),
+  status: z.string(),
+})
+const TeamListItemSchema = z.object({
+  name: z.string(),
+  memberCount: z.number(),
+  joinStatus: z.string(),
+})
+
+export const MentoringListItemSchema = z.object({
+  id: z.number(),
+  title: z.string(),
+  type: z.enum(['자유 멘토링', '멘토 특강']),
+  registrationPeriod: DateRangeSchema,
+  sessionDate: z.string(),
+  sessionTime: TimeRangeSchema,
+  attendees: z.object({ current: z.number(), max: z.number() }),
+  approved: z.boolean(),
+  status: z.enum(['접수중', '마감']),
+  author: z.string(),
+  createdAt: z.string(),
+})
+export type MentoringListItem = z.infer<typeof MentoringListItemSchema>
+
+export const MentoringDetailSchema = MentoringListItemSchema.extend({
+  content: z.string(),
+  venue: z.string(),
+})
+export type MentoringDetail = z.infer<typeof MentoringDetailSchema>
+
+export const RoomCardSchema = z.object({
+  itemId: z.number(),
+  name: z.string(),
+  capacity: z.number(),
+  availablePeriod: DateRangeSchema,
+  description: z.string(),
+  timeSlots: z.array(RoomTimeSlotSchema),
+})
+export type RoomCard = z.infer<typeof RoomCardSchema>
+
+export const DashboardSchema = z.object({
+  name: z.string(),
+  role: z.string(),
+  organization: z.string(),
+  position: z.string(),
+  team: z
+    .object({
+      name: z.string(),
+      members: z.string(),
+      mentor: z.string(),
+    })
+    .optional(),
+  mentoringSessions: z.array(DashboardStatusItemSchema),
+  roomReservations: z.array(DashboardStatusItemSchema),
+})
+export type Dashboard = z.infer<typeof DashboardSchema>
+
+export const NoticeListItemSchema = z.object({
+  id: z.number(),
+  title: z.string(),
+  author: z.string(),
+  createdAt: z.string(),
+})
+export type NoticeListItem = z.infer<typeof NoticeListItemSchema>
+
+export const NoticeDetailSchema = NoticeListItemSchema.extend({
+  content: z.string(),
+})
+export type NoticeDetail = z.infer<typeof NoticeDetailSchema>
+
+export const TeamInfoSchema = z.object({
+  teams: z.array(TeamListItemSchema),
+  currentTeams: z.number(),
+  maxTeams: z.number(),
+})
+export type TeamInfo = z.infer<typeof TeamInfoSchema>
+
+export const MemberInfoSchema = z.object({
+  email: z.string(),
+  name: z.string(),
+  gender: z.string(),
+  birthDate: z.string(),
+  phone: z.string(),
+  organization: z.string(),
+  position: z.string(),
+})
+export type MemberInfo = z.infer<typeof MemberInfoSchema>
+
+export const EventListItemSchema = z.object({
+  id: z.number(),
+  category: z.string(),
+  title: z.string(),
+  registrationPeriod: DateRangeSchema,
+  eventPeriod: DateRangeSchema,
+  status: z.string(),
+  createdAt: z.string(),
+})
+export type EventListItem = z.infer<typeof EventListItemSchema>
+
+export const ApplicationHistoryItemSchema = z.object({
+  id: z.number(),
+  category: z.string(),
+  title: z.string(),
+  author: z.string(),
+  sessionDate: z.string(),
+  appliedAt: z.string(),
+  applicationStatus: z.string(),
+  approvalStatus: z.string(),
+  applicationDetail: z.string(),
+  note: z.string(),
+})
+export type ApplicationHistoryItem = z.infer<typeof ApplicationHistoryItemSchema>
+
+export const PaginationSchema = z.object({
+  total: z.number(),
+  currentPage: z.number(),
+  totalPages: z.number(),
+})
+export type Pagination = z.infer<typeof PaginationSchema>
+
+export const CredentialsSchema = z.object({
+  sessionCookie: z.string(),
+  csrfToken: z.string(),
+  username: z.string().optional(),
+  loggedInAt: z.string().optional(),
+})
+export type Credentials = z.infer<typeof CredentialsSchema>

package/tsconfig.json

@@ -0,0 +1,38 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022", "DOM"],
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": ".",
+    "baseUrl": ".",
+    "types": ["node", "bun"],
+    "paths": {
+      "@/*": ["src/*"]
+    },
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowJs": false,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "ignoreDeprecations": "6.0",
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}