@keeper-security/keeper-sdk-javascript 0.1.0

package/src/teams/listTeams.ts

@@ -0,0 +1,373 @@
+import type { Auth } from '@keeper-security/keeperapi'
+import { isNumber, TOKEN_SEPARATOR_PATTERN } from '../utils'
+import {
+    EnterpriseDataInclude,
+    EnterpriseDataManager,
+    type DecryptedRoleNames,
+    type EnterpriseDisplayNames,
+    type EnterpriseNode,
+    type EnterpriseRole,
+    type EnterpriseTeamRecord,
+    type EnterpriseTeamUserLink,
+    type EnterpriseUser,
+    type GetEnterpriseDataResponse,
+} from './enterpriseData'
+
+export enum TeamColumn {
+    Restricts = 'restricts',
+    Node = 'node',
+    UserCount = 'user_count',
+    Users = 'users',
+    RoleCount = 'role_count',
+    Roles = 'roles',
+}
+
+export type TeamColumnInput = TeamColumn | `${TeamColumn}`
+
+export const SUPPORTED_TEAM_COLUMNS: readonly TeamColumn[] = Object.values(TeamColumn)
+
+export const DEFAULT_TEAM_COLUMNS: readonly TeamColumn[] = [
+    TeamColumn.Restricts,
+    TeamColumn.Node,
+    TeamColumn.UserCount,
+    TeamColumn.RoleCount,
+]
+
+const NODE_PATH_SEPARATOR = '\\'
+const MIN_ASCII_COL_WIDTH = 2
+const ALL_COLUMNS_WILDCARD = '*'
+
+const HEADER_BY_COLUMN: Record<TeamColumn, string> = {
+    [TeamColumn.Restricts]: 'Restricts',
+    [TeamColumn.Node]: 'Node',
+    [TeamColumn.UserCount]: 'User Count',
+    [TeamColumn.Users]: 'Users',
+    [TeamColumn.RoleCount]: 'Role Count',
+    [TeamColumn.Roles]: 'Roles',
+}
+
+export type ListTeamsOptions = {
+    pattern?: string | null
+    columns?: TeamColumnInput[] | typeof ALL_COLUMNS_WILDCARD | string | null
+}
+
+export type ListTeamRow = {
+    team_uid: string
+    name: string
+    restricts?: string
+    node?: string
+    user_count?: number
+    users?: string[]
+    role_count?: number
+    roles?: string[]
+}
+
+export type FormattedTeamsTable = {
+    headers: string[]
+    rows: string[][]
+}
+
+export type FormatTeamsTableOptions = {
+    columns?: ListTeamsOptions['columns']
+}
+
+type DecorateContext = {
+    nodePaths: Map<number, string>
+    teamUsers: Map<string, Set<number>>
+    roleTeams: Map<string, Set<number>>
+    usernameById: Map<number, string>
+    roleNameById: Map<number, string>
+}
+
+export function formatTeamRestricts(team: EnterpriseTeamRecord): string {
+    const r = team.restrict_view === true ? 'R ' : '  '
+    const w = team.restrict_edit === true ? 'W ' : '  '
+    const restrictShare = team.restrict_share === true || team.restrict_sharing === true
+    const s = restrictShare ? 'S' : ' '
+    return r + w + s
+}
+
+export async function listTeams(auth: Auth, options: ListTeamsOptions = {}): Promise<ListTeamRow[]> {
+    const columns = resolveColumns(options.columns)
+    const includes = includesForColumns(columns)
+    const wantsDisplayNames = columns.includes(TeamColumn.Node) || columns.includes(TeamColumn.Roles)
+
+    const enterpriseData = new EnterpriseDataManager(auth)
+    const emptyDisplayNames: EnterpriseDisplayNames = { nodes: new Map(), roles: new Map() }
+    const [response, displayNames] = await Promise.all([
+        enterpriseData.getData(includes),
+        wantsDisplayNames ? enterpriseData.getDisplayNames() : Promise.resolve(emptyDisplayNames),
+    ])
+
+    const teams = response.teams || []
+    const nodes = response.nodes || []
+    applyDecryptedNodeNames(nodes, displayNames.nodes)
+
+    const context: DecorateContext = {
+        nodePaths: buildNodePathLookup(nodes),
+        teamUsers: buildTeamUserMap(response.team_users || []),
+        roleTeams: buildRoleTeamMap(response),
+        usernameById: buildUserUsernameMap(response.users || []),
+        roleNameById: buildRoleNameMap(response.roles || [], displayNames.roles),
+    }
+
+    const pattern = options.pattern?.trim() || null
+    const rows: ListTeamRow[] = []
+    for (const team of teams) {
+        const row: ListTeamRow = {
+            team_uid: team.team_uid,
+            name: teamDisplayName(team),
+        }
+        decorateRow(row, team, columns, context)
+        if (pattern && !rowMatchesPattern(row, pattern)) continue
+        rows.push(row)
+    }
+
+    rows.sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: 'base' }))
+    return rows
+}
+
+export function formatTeamsTable(
+    rows: ListTeamRow[],
+    options: FormatTeamsTableOptions = {}
+): FormattedTeamsTable {
+    const columns = resolveColumns(options.columns)
+    const headers: string[] = ['#', 'Team UID', 'Name', ...columns.map((column) => HEADER_BY_COLUMN[column])]
+
+    const outRows: string[][] = rows.map((row, rowIndex) => {
+        const cells: string[] = [String(rowIndex + 1), row.team_uid, row.name]
+        for (const column of columns) cells.push(formatCell(row, column))
+        return cells
+    })
+
+    return { headers, rows: outRows }
+}
+
+export function renderTeamsAsciiTable(
+    table: FormattedTeamsTable,
+    options: { minColWidth?: number } = {}
+): string {
+    const { minColWidth = MIN_ASCII_COL_WIDTH } = options
+    const { headers, rows } = table
+    const columnCount = headers.length
+
+    const expandedRows: string[][][] = rows.map((row) =>
+        row.map((cell) => (cell.includes('\n') ? cell.split('\n') : [cell]))
+    )
+
+    const columnWidths = new Array<number>(columnCount).fill(0)
+    for (let columnIndex = 0; columnIndex < columnCount; columnIndex += 1) {
+        columnWidths[columnIndex] = Math.max(headers[columnIndex].length, minColWidth)
+    }
+    for (const row of expandedRows) {
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex += 1) {
+            for (const line of row[columnIndex]) {
+                columnWidths[columnIndex] = Math.max(columnWidths[columnIndex], line.length, minColWidth)
+            }
+        }
+    }
+
+    const padCell = (cell: string, columnIndex: number): string =>
+        cell + ' '.repeat(columnWidths[columnIndex] - cell.length)
+    const formatPhysicalRow = (cells: string[]): string =>
+        cells.map((cell, columnIndex) => padCell(cell, columnIndex)).join('  ')
+
+    const ruleRow = formatPhysicalRow(columnWidths.map((width) => '-'.repeat(width)))
+    const lines: string[] = [formatPhysicalRow(headers), ruleRow]
+
+    for (const row of expandedRows) {
+        const physicalLineCount = Math.max(...row.map((cell) => cell.length))
+        for (let lineIndex = 0; lineIndex < physicalLineCount; lineIndex += 1) {
+            const physicalCells: string[] = row.map((cell) => cell[lineIndex] ?? '')
+            lines.push(formatPhysicalRow(physicalCells))
+        }
+    }
+    return lines.join('\n')
+}
+
+function includesForColumns(columns: readonly TeamColumn[]): EnterpriseDataInclude[] {
+    const set = new Set<EnterpriseDataInclude>([EnterpriseDataInclude.Teams])
+    for (const column of columns) {
+        switch (column) {
+            case TeamColumn.Node:
+                set.add(EnterpriseDataInclude.Nodes)
+                break
+            case TeamColumn.UserCount:
+            case TeamColumn.Users:
+                set.add(EnterpriseDataInclude.TeamUsers)
+                if (column === TeamColumn.Users) set.add(EnterpriseDataInclude.Users)
+                break
+            case TeamColumn.RoleCount:
+            case TeamColumn.Roles:
+                set.add(EnterpriseDataInclude.RoleTeams)
+                if (column === TeamColumn.Roles) set.add(EnterpriseDataInclude.Roles)
+                break
+        }
+    }
+    return Array.from(set)
+}
+
+function resolveColumns(input: ListTeamsOptions['columns']): TeamColumn[] {
+    if (input == null) return [...DEFAULT_TEAM_COLUMNS]
+    if (input === ALL_COLUMNS_WILDCARD) return [...SUPPORTED_TEAM_COLUMNS]
+
+    const requested = Array.isArray(input) ? input : input.split(',').map((part) => part.trim())
+    const allowed = new Set<string>(SUPPORTED_TEAM_COLUMNS)
+    const seen = new Set<TeamColumn>()
+    for (const column of requested) {
+        if (column && allowed.has(column)) seen.add(column as TeamColumn)
+    }
+    if (seen.size === 0) return [...DEFAULT_TEAM_COLUMNS]
+    return SUPPORTED_TEAM_COLUMNS.filter((column) => seen.has(column))
+}
+
+function teamDisplayName(team: { name?: string; team_uid: string }): string {
+    return (team.name || team.team_uid || '').trim() || team.team_uid
+}
+
+function tokenize(text: string): string[] {
+    return text.split(TOKEN_SEPARATOR_PATTERN).filter((token) => token.length > 0)
+}
+
+function rowMatchesPattern(row: ListTeamRow, pattern: string): boolean {
+    const lowered = pattern.toLowerCase()
+    const tokens: string[] = []
+    tokens.push(row.team_uid.toLowerCase())
+    tokens.push(...tokenize(row.name.toLowerCase()))
+    if (row.restricts) tokens.push(row.restricts.toLowerCase())
+    if (row.node) tokens.push(...tokenize(row.node.toLowerCase()))
+    if (row.user_count != null) tokens.push(String(row.user_count))
+    if (row.role_count != null) tokens.push(String(row.role_count))
+    for (const list of [row.users, row.roles]) {
+        if (!list) continue
+        for (const value of list) tokens.push(...tokenize(value.toLowerCase()))
+    }
+    return tokens.some((token) => token.includes(lowered))
+}
+
+function applyDecryptedNodeNames(nodes: EnterpriseNode[], decrypted: Map<number, string>): void {
+    if (decrypted.size === 0) return
+    for (const node of nodes) {
+        const display = decrypted.get(node.node_id)
+        if (display) node.displayName = display
+    }
+}
+
+function buildNodePathLookup(nodes: EnterpriseNode[]): Map<number, string> {
+    return new Map(
+        nodes.map((node) => [
+            node.node_id,
+            EnterpriseDataManager.getNodePath(nodes, node.node_id, { separator: NODE_PATH_SEPARATOR }),
+        ])
+    )
+}
+
+function buildTeamUserMap(links: EnterpriseTeamUserLink[]): Map<string, Set<number>> {
+    const byTeam = new Map<string, Set<number>>()
+    for (const link of links) {
+        if (!link.team_uid) continue
+        const set = byTeam.get(link.team_uid)
+        if (set) set.add(link.enterprise_user_id)
+        else byTeam.set(link.team_uid, new Set([link.enterprise_user_id]))
+    }
+    return byTeam
+}
+
+function buildRoleTeamMap(response: GetEnterpriseDataResponse): Map<string, Set<number>> {
+    const map = new Map<string, Set<number>>()
+    for (const link of response.role_teams || []) {
+        if (!link.team_uid) continue
+        const set = map.get(link.team_uid)
+        if (set) set.add(link.role_id)
+        else map.set(link.team_uid, new Set([link.role_id]))
+    }
+    return map
+}
+
+function buildUserUsernameMap(users: EnterpriseUser[]): Map<number, string> {
+    const map = new Map<number, string>()
+    for (const user of users) {
+        if (isNumber(user.enterprise_user_id ) && user.username) {
+            map.set(user.enterprise_user_id, user.username)
+        }
+    }
+    return map
+}
+
+function buildRoleNameMap(roles: EnterpriseRole[], decrypted: DecryptedRoleNames): Map<number, string> {
+    const map = new Map<number, string>()
+    for (const role of roles) {
+        if (isNumber(role.role_id)) continue
+        const display = (role.displayName || decrypted.get(role.role_id) || '').trim()
+        map.set(role.role_id, display || String(role.role_id))
+    }
+    return map
+}
+
+function resolveSortedNames(ids: Set<number>, nameById: Map<number, string>): string[] {
+    const result: string[] = []
+    for (const id of ids) {
+        const name = nameById.get(id)
+        if (name) result.push(name)
+    }
+    result.sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }))
+    return result
+}
+
+function decorateRow(
+    row: ListTeamRow,
+    team: EnterpriseTeamRecord,
+    columns: readonly TeamColumn[],
+    context: DecorateContext
+): void {
+    const { nodePaths, teamUsers, roleTeams, usernameById, roleNameById } = context
+
+    for (const column of columns) {
+        switch (column) {
+            case TeamColumn.Restricts:
+                row.restricts = formatTeamRestricts(team)
+                break
+            case TeamColumn.Node:
+                row.node = nodePaths.get(team.node_id) || ''
+                break
+            case TeamColumn.UserCount:
+                row.user_count = teamUsers.get(team.team_uid)?.size ?? 0
+                break
+            case TeamColumn.Users: {
+                const ids = teamUsers.get(team.team_uid)
+                row.users = ids ? resolveSortedNames(ids, usernameById) : []
+                break
+            }
+            case TeamColumn.RoleCount:
+                row.role_count = roleTeams.get(team.team_uid)?.size ?? 0
+                break
+            case TeamColumn.Roles: {
+                const ids = roleTeams.get(team.team_uid)
+                row.roles = ids ? resolveSortedNames(ids, roleNameById) : []
+                break
+            }
+        }
+    }
+}
+
+function formatListCell(values: string[] | undefined): string {
+    if (!values || values.length === 0) return ''
+    return values.join('\n')
+}
+
+function formatCell(row: ListTeamRow, column: TeamColumn): string {
+    switch (column) {
+        case TeamColumn.Restricts:
+            return row.restricts ?? ''
+        case TeamColumn.Node:
+            return row.node ?? ''
+        case TeamColumn.UserCount:
+            return row.user_count == null ? '' : String(row.user_count)
+        case TeamColumn.Users:
+            return formatListCell(row.users)
+        case TeamColumn.RoleCount:
+            return row.role_count == null ? '' : String(row.role_count)
+        case TeamColumn.Roles:
+            return formatListCell(row.roles)
+    }
+}

package/src/teams/viewTeam.ts

@@ -0,0 +1,248 @@
+import type { Auth } from '@keeper-security/keeperapi'
+import { KeeperSdkError, ResultCodes } from '../utils'
+import {
+    EnterpriseDataInclude,
+    EnterpriseDataManager,
+    type EnterpriseDisplayNames,
+    type EnterpriseNode,
+    type EnterpriseRoleTeamLink,
+    type EnterpriseTeamRecord,
+    type EnterpriseTeamUserLink,
+    type EnterpriseUser,
+} from './enterpriseData'
+
+const NODE_PATH_SEPARATOR = '\\'
+const VIEW_TEAM_INCLUDES: EnterpriseDataInclude[] = [
+    EnterpriseDataInclude.Teams,
+    EnterpriseDataInclude.TeamUsers,
+    EnterpriseDataInclude.RoleTeams,
+    EnterpriseDataInclude.Roles,
+    EnterpriseDataInclude.Users,
+    EnterpriseDataInclude.Nodes,
+]
+
+export type TeamRoleInfo = {
+    role_id: number
+    role_name: string
+}
+
+export type TeamUserInfo = {
+    enterprise_user_id: number
+    username: string
+}
+
+export type TeamView = {
+    team_uid: string
+    team_name: string
+    node_id: number
+    node_name: string
+    restrict_view: boolean
+    restrict_edit: boolean
+    restrict_share: boolean
+    team_roles?: TeamRoleInfo[]
+    team_users?: TeamUserInfo[]
+}
+
+export type FormatTeamViewOptions = {
+    verbose?: boolean
+}   
+
+export type TeamViewTableRow = {
+    label: string
+    value: string | string[]
+    id?: number | number[]
+}
+
+export type FormattedTeamViewTable = {
+    rows: TeamViewTableRow[]
+    hasIdColumn: boolean
+}
+
+export async function viewTeam(auth: Auth, identifier: string): Promise<TeamView> {
+    const enterpriseData = new EnterpriseDataManager(auth)
+    const [response, displayNames] = await Promise.all([
+        enterpriseData.getData(VIEW_TEAM_INCLUDES),
+        enterpriseData.getDisplayNames(),
+    ])
+
+    const team = resolveTeam(response.teams || [], identifier)
+    const nodePath = resolveNodePath(response.nodes || [], displayNames, team.node_id)
+    const teamUsers = buildTeamUsers(response.users || [], response.team_users || [], team.team_uid)
+    const teamRoles = buildTeamRoles(response.role_teams || [], displayNames.roles, team.team_uid)
+
+    const view: TeamView = {
+        team_uid: team.team_uid,
+        team_name: team.name,
+        node_id: team.node_id,
+        node_name: nodePath,
+        restrict_view: team.restrict_view === true,
+        restrict_edit: team.restrict_edit === true,
+        restrict_share: team.restrict_share === true || team.restrict_sharing === true,
+    }
+    if (teamRoles.length > 0) view.team_roles = teamRoles
+    if (teamUsers.length > 0) view.team_users = teamUsers
+    return view
+}
+
+export function formatTeamView(view: TeamView, options: FormatTeamViewOptions = {}): FormattedTeamViewTable {
+    const verbose = options.verbose === true
+    const rows: TeamViewTableRow[] = [
+        { label: 'Team UID', value: view.team_uid },
+        { label: 'Team Name', value: view.team_name },
+        {
+            label: 'Node Name',
+            value: view.node_name,
+            id: verbose ? view.node_id : undefined,
+        },
+        { label: 'Restrict Edit', value: boolText(view.restrict_edit) },
+        { label: 'Restrict Share', value: boolText(view.restrict_share) },
+        { label: 'Restrict View', value: boolText(view.restrict_view) },
+    ]
+
+    if (view.team_roles && view.team_roles.length > 0) {
+        rows.push({
+            label: 'Role(s)',
+            value: view.team_roles.map((role) => role.role_name),
+            id: verbose ? view.team_roles.map((role) => role.role_id) : undefined,
+        })
+    }
+
+    if (view.team_users && view.team_users.length > 0) {
+        rows.push({
+            label: 'User(s)',
+            value: view.team_users.map((user) => user.username),
+            id: verbose ? view.team_users.map((user) => user.enterprise_user_id) : undefined,
+        })
+    }
+
+    return { rows, hasIdColumn: verbose }
+}
+
+export function teamViewTable(table: FormattedTeamViewTable): string {
+    const labelWidth = table.rows.reduce((max, row) => Math.max(max, row.label.length), 0)
+    const expandedRows = table.rows.map((row) => ({
+        label: row.label,
+        valueLines: asLines(row.value),
+        idLines: table.hasIdColumn ? asIdLines(row.id) : [],
+    }))
+
+    const valueWidth = expandedRows.reduce(
+        (max, row) => Math.max(max, ...row.valueLines.map((line) => line.length)),
+        0
+    )
+    const idWidth = table.hasIdColumn
+        ? expandedRows.reduce((max, row) => Math.max(max, ...row.idLines.map((line) => line.length)), 0)
+        : 0
+
+    const padRight = (text: string, width: number): string =>
+        text + ' '.repeat(Math.max(0, width - text.length))
+    const padLeft = (text: string, width: number): string =>
+        ' '.repeat(Math.max(0, width - text.length)) + text
+
+    const lines: string[] = []
+    for (const row of expandedRows) {
+        const lineCount = Math.max(row.valueLines.length, table.hasIdColumn ? row.idLines.length : 0, 1)
+        for (let lineIndex = 0; lineIndex < lineCount; lineIndex += 1) {
+            const isFirstLine = lineIndex === 0
+            const labelCell = padLeft(isFirstLine ? row.label : '', labelWidth)
+            const valueCell = padRight(row.valueLines[lineIndex] ?? '', valueWidth)
+            const cells: string[] = [labelCell, valueCell]
+            if (table.hasIdColumn) {
+                const idCell = padRight(row.idLines[lineIndex] ?? '', idWidth)
+                cells.push(idCell)
+            }
+            lines.push(cells.join('  ').trimEnd())
+        }
+    }
+    return lines.join('\n')
+}
+
+function resolveTeam(teams: EnterpriseTeamRecord[], identifier: string): EnterpriseTeamRecord {
+    const trimmed = (identifier ?? '').trim()
+    if (!trimmed) {
+        throw new KeeperSdkError('Team name or UID is required.', ResultCodes.TEAM_REQUIRED)
+    }
+
+    const uidMatch = teams.find((team) => team.team_uid === trimmed)
+    if (uidMatch) return uidMatch
+
+    const lowered = trimmed.toLowerCase()
+    const nameMatches = teams.filter((team) => (team.name || '').trim().toLowerCase() === lowered)
+    if (nameMatches.length === 1) return nameMatches[0]
+    if (nameMatches.length > 1) {
+        throw new KeeperSdkError(
+            `Multiple teams match name "${trimmed}". Specify the team UID instead.`,
+            ResultCodes.MULTIPLE_TEAM_MATCHES
+        )
+    }
+    throw new KeeperSdkError(`Team "${trimmed}" does not exist.`, ResultCodes.TEAM_NOT_FOUND)
+}
+
+function resolveNodePath(
+    nodes: EnterpriseNode[],
+    displayNames: EnterpriseDisplayNames,
+    nodeId: number
+): string {
+    if (displayNames.nodes.size > 0) {
+        for (const node of nodes) {
+            const display = displayNames.nodes.get(node.node_id)
+            if (display) node.displayName = display
+        }
+    }
+    return EnterpriseDataManager.getNodePath(nodes, nodeId, { omitRoot: false, separator: NODE_PATH_SEPARATOR })
+}
+
+function buildTeamUsers(
+    users: EnterpriseUser[],
+    teamUserLinks: EnterpriseTeamUserLink[],
+    teamUid: string
+): TeamUserInfo[] {
+    const userById = new Map<number, EnterpriseUser>()
+    for (const user of users) userById.set(user.enterprise_user_id, user)
+
+    const memberIds = new Set<number>()
+    for (const link of teamUserLinks) {
+        if (link.team_uid === teamUid) memberIds.add(link.enterprise_user_id)
+    }
+
+    const result: TeamUserInfo[] = []
+    for (const id of memberIds) {
+        const user = userById.get(id)
+        if (user && user.username) result.push({ enterprise_user_id: id, username: user.username })
+    }
+    result.sort((a, b) => a.username.localeCompare(b.username, undefined, { sensitivity: 'base' }))
+    return result
+}
+
+function buildTeamRoles(
+    roleTeamLinks: EnterpriseRoleTeamLink[],
+    decryptedRoleNames: Map<number, string>,
+    teamUid: string
+): TeamRoleInfo[] {
+    const roleIds = new Set<number>()
+    for (const link of roleTeamLinks) {
+        if (link.team_uid === teamUid) roleIds.add(link.role_id)
+    }
+
+    const result: TeamRoleInfo[] = []
+    for (const id of roleIds) {
+        result.push({ role_id: id, role_name: decryptedRoleNames.get(id) || String(id) })
+    }
+    result.sort((a, b) => a.role_name.localeCompare(b.role_name, undefined, { sensitivity: 'base' }))
+    return result
+}
+
+function boolText(value: boolean): string {
+    return value ? 'True' : 'False'
+}
+
+function asLines(value: string | string[]): string[] {
+    if (Array.isArray(value)) return value.length > 0 ? value : ['']
+    return [value]
+}
+
+function asIdLines(id: number | number[] | undefined): string[] {
+    if (id == null) return []
+    if (Array.isArray(id)) return id.length > 0 ? id.map(String) : ['']
+    return [String(id)]
+}

package/src/utils/Logger.ts

@@ -0,0 +1,71 @@
+export enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    NONE = 4,
+}
+
+export interface ILogger {
+    debug(...args: unknown[]): void
+    info(...args: unknown[]): void
+    warn(...args: unknown[]): void
+    error(...args: unknown[]): void
+}
+
+export class ConsoleLogger implements ILogger {
+    private level: LogLevel
+
+    constructor(level: LogLevel = LogLevel.INFO) {
+        this.level = level
+    }
+
+    public setLevel(level: LogLevel): void {
+        this.level = level
+    }
+
+    public getLevel(): LogLevel {
+        return this.level
+    }
+
+    public debug(...args: unknown[]): void {
+        if (this.level <= LogLevel.DEBUG) console.debug(...args)
+    }
+
+    public info(...args: unknown[]): void {
+        if (this.level <= LogLevel.INFO) console.log(...args)
+    }
+
+    public warn(...args: unknown[]): void {
+        if (this.level <= LogLevel.WARN) console.warn(...args)
+    }
+
+    public error(...args: unknown[]): void {
+        if (this.level <= LogLevel.ERROR) console.error(...args)
+    }
+}
+
+let globalLogger: ILogger = new ConsoleLogger()
+
+export function setLogger(newLogger: ILogger): void {
+    globalLogger = newLogger
+}
+
+export function getLogger(): ILogger {
+    return globalLogger
+}
+
+export function resetLogger(level: LogLevel = LogLevel.INFO): ConsoleLogger {
+    const c = new ConsoleLogger(level)
+    globalLogger = c
+    return c
+}
+
+export const logger: ILogger = {
+    debug: (...args) => globalLogger.debug(...args),
+    info: (...args) => globalLogger.info(...args),
+    warn: (...args) => globalLogger.warn(...args),
+    error: (...args) => globalLogger.error(...args),
+}
+
+export { ConsoleLogger as Logger }