mcpbox 0.0.1

package/dist/config/loader.d.ts

@@ -0,0 +1,3 @@
+import { type Config } from "./schema.js";
+export declare function resolveConfigPath(configPath?: string): string;
+export declare function loadConfig(configPath: string): Config;

package/dist/config/loader.js

@@ -0,0 +1,134 @@
+import { existsSync, readFileSync } from "node:fs";
+import { RawConfigSchema, } from "./schema.js";
+function substituteEnvVars(obj) {
+    if (typeof obj === "string") {
+        return obj.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] ?? "");
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(substituteEnvVars);
+    }
+    if (obj && typeof obj === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = substituteEnvVars(value);
+        }
+        return result;
+    }
+    return obj;
+}
+function parseMcpServers(mcpServers) {
+    const mcps = [];
+    for (const [name, entry] of Object.entries(mcpServers)) {
+        mcps.push({
+            name,
+            command: entry.command,
+            args: entry.args,
+            env: entry.env,
+            tools: entry.tools,
+        });
+    }
+    return mcps;
+}
+function formatZodIssue(issue) {
+    const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    const code = issue.code;
+    // Handle discriminated union errors (wrong type value)
+    if (code === "invalid_union" && "discriminator" in issue) {
+        const discriminator = issue.discriminator;
+        // Get valid options from the schema based on the discriminator
+        if (discriminator === "type" && path === "auth.type") {
+            return `${path}: must be one of: "none", "apikey", "oauth"`;
+        }
+        if (discriminator === "type" && path === "storage.type") {
+            return `${path}: must be one of: "memory", "sqlite"`;
+        }
+        return `${path}: invalid value for "${discriminator}"`;
+    }
+    // Handle unrecognized keys
+    if (code === "unrecognized_keys" && "keys" in issue) {
+        const keys = issue.keys.map((k) => `"${k}"`).join(", ");
+        const location = path === "" ? "config" : path;
+        return `${location}: unknown field${issue.keys.length > 1 ? "s" : ""} ${keys}`;
+    }
+    // Handle missing required fields
+    if (code === "invalid_type" && "expected" in issue) {
+        const expected = issue.expected;
+        if (issue.message.includes("received undefined")) {
+            return `${path}: required field missing`;
+        }
+        return `${path}: expected ${expected}`;
+    }
+    // Handle enum errors (Zod v4 uses "invalid_value" with options)
+    if ("options" in issue && Array.isArray(issue.options)) {
+        const options = issue.options.map((o) => `"${o}"`).join(", ");
+        return `${path}: must be one of: ${options}`;
+    }
+    // Clean up Zod's default messages
+    const message = issue.message;
+    // "Invalid option: expected one of X" -> cleaner format
+    if (message.startsWith("Invalid option: expected one of ")) {
+        const options = message.replace("Invalid option: expected one of ", "");
+        return `${path}: must be one of: ${options.replace(/\|/g, ", ").replace(/"/g, "")}`;
+    }
+    return `${path}: ${message}`;
+}
+function formatZodError(error) {
+    // Filter out "missing required field" errors if there's an "unrecognized key" error at the same path
+    // This happens when someone uses wrong field name - we want to show the typo, not the missing field
+    const issues = error.issues;
+    const unrecognizedPaths = new Set();
+    for (const issue of issues) {
+        if (issue.code === "unrecognized_keys") {
+            const basePath = issue.path.join(".");
+            unrecognizedPaths.add(basePath);
+        }
+    }
+    const filteredIssues = issues.filter((issue) => {
+        // Keep unrecognized_keys errors
+        if (issue.code === "unrecognized_keys")
+            return true;
+        // Filter out "required field missing" if there's an unrecognized key at the parent path
+        if (issue.code === "invalid_type" &&
+            issue.message.includes("received undefined")) {
+            const parentPath = issue.path.slice(0, -1).join(".");
+            if (unrecognizedPaths.has(parentPath)) {
+                return false;
+            }
+        }
+        return true;
+    });
+    const formatted = filteredIssues.map(formatZodIssue);
+    return `Invalid configuration:\n${formatted.map((f) => `  - ${f}`).join("\n")}`;
+}
+export function resolveConfigPath(configPath) {
+    return configPath ?? "mcpbox.json";
+}
+export function loadConfig(configPath) {
+    if (!existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    const content = readFileSync(configPath, "utf-8");
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (e) {
+        throw new Error(`Invalid JSON in config file: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // Substitute environment variables before validation
+    const substituted = substituteEnvVars(parsed);
+    // Validate with Zod schema
+    const result = RawConfigSchema.safeParse(substituted);
+    if (!result.success) {
+        throw new Error(formatZodError(result.error));
+    }
+    const raw = result.data;
+    const mcps = raw.mcpServers ? parseMcpServers(raw.mcpServers) : [];
+    return {
+        server: raw.server ?? { port: 8080 },
+        auth: raw.auth,
+        storage: raw.storage,
+        log: raw.log,
+        mcps,
+    };
+}

package/dist/config/schema.d.ts

@@ -0,0 +1,220 @@
+import { z } from "zod";
+/**
+ * MCP server entry (command + args + env)
+ */
+export declare const McpServerEntrySchema: z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/**
+ * OAuth user credentials
+ */
+export declare const OAuthUserSchema: z.ZodObject<{
+    username: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strict>;
+/**
+ * OAuth client configuration
+ */
+export declare const OAuthClientSchema: z.ZodObject<{
+    client_id: z.ZodString;
+    client_name: z.ZodOptional<z.ZodString>;
+    client_secret: z.ZodOptional<z.ZodString>;
+    redirect_uris: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    grant_type: z.ZodEnum<{
+        authorization_code: "authorization_code";
+        client_credentials: "client_credentials";
+    }>;
+}, z.core.$strict>;
+/**
+ * Auth config - discriminated union based on type
+ */
+export declare const AuthConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"apikey">;
+    apiKey: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"oauth">;
+    issuer: z.ZodOptional<z.ZodString>;
+    users: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        username: z.ZodString;
+        password: z.ZodString;
+    }, z.core.$strict>>>;
+    clients: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        client_id: z.ZodString;
+        client_name: z.ZodOptional<z.ZodString>;
+        client_secret: z.ZodOptional<z.ZodString>;
+        redirect_uris: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        grant_type: z.ZodEnum<{
+            authorization_code: "authorization_code";
+            client_credentials: "client_credentials";
+        }>;
+    }, z.core.$strict>>>;
+    dynamic_registration: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>], "type">;
+/**
+ * Server configuration
+ */
+export declare const ServerConfigSchema: z.ZodObject<{
+    port: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * Log configuration
+ */
+export declare const LogConfigSchema: z.ZodObject<{
+    level: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>>;
+    format: z.ZodOptional<z.ZodEnum<{
+        pretty: "pretty";
+        json: "json";
+    }>>;
+    redactSecrets: z.ZodOptional<z.ZodBoolean>;
+    mcpDebug: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/**
+ * Storage configuration - discriminated union based on type
+ */
+export declare const StorageConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"memory">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"sqlite">;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "type">;
+/**
+ * Raw config file schema (before processing)
+ */
+export declare const RawConfigSchema: z.ZodObject<{
+    server: z.ZodOptional<z.ZodObject<{
+        port: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    auth: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"apikey">;
+        apiKey: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"oauth">;
+        issuer: z.ZodOptional<z.ZodString>;
+        users: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            username: z.ZodString;
+            password: z.ZodString;
+        }, z.core.$strict>>>;
+        clients: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            client_id: z.ZodString;
+            client_name: z.ZodOptional<z.ZodString>;
+            client_secret: z.ZodOptional<z.ZodString>;
+            redirect_uris: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grant_type: z.ZodEnum<{
+                authorization_code: "authorization_code";
+                client_credentials: "client_credentials";
+            }>;
+        }, z.core.$strict>>>;
+        dynamic_registration: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>], "type">>;
+    storage: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"memory">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"sqlite">;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "type">>;
+    log: z.ZodOptional<z.ZodObject<{
+        level: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            debug: "debug";
+            info: "info";
+            warn: "warn";
+        }>>;
+        format: z.ZodOptional<z.ZodEnum<{
+            pretty: "pretty";
+            json: "json";
+        }>>;
+        redactSecrets: z.ZodOptional<z.ZodBoolean>;
+        mcpDebug: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+/**
+ * Internal MCP config (with name resolved from key)
+ */
+export declare const McpConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Processed config (after loader adds defaults and resolves mcpServers)
+ */
+export declare const ConfigSchema: z.ZodObject<{
+    server: z.ZodObject<{
+        port: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    auth: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"apikey">;
+        apiKey: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"oauth">;
+        issuer: z.ZodOptional<z.ZodString>;
+        users: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            username: z.ZodString;
+            password: z.ZodString;
+        }, z.core.$strict>>>;
+        clients: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            client_id: z.ZodString;
+            client_name: z.ZodOptional<z.ZodString>;
+            client_secret: z.ZodOptional<z.ZodString>;
+            redirect_uris: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            grant_type: z.ZodEnum<{
+                authorization_code: "authorization_code";
+                client_credentials: "client_credentials";
+            }>;
+        }, z.core.$strict>>>;
+        dynamic_registration: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>], "type">>;
+    storage: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"memory">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"sqlite">;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "type">>;
+    log: z.ZodOptional<z.ZodObject<{
+        level: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            debug: "debug";
+            info: "info";
+            warn: "warn";
+        }>>;
+        format: z.ZodOptional<z.ZodEnum<{
+            pretty: "pretty";
+            json: "json";
+        }>>;
+        redactSecrets: z.ZodOptional<z.ZodBoolean>;
+        mcpDebug: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    mcps: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type McpServerEntry = z.infer<typeof McpServerEntrySchema>;
+export type OAuthUser = z.infer<typeof OAuthUserSchema>;
+export type OAuthClient = z.infer<typeof OAuthClientSchema>;
+export type AuthConfig = z.infer<typeof AuthConfigSchema>;
+export type ServerConfig = z.infer<typeof ServerConfigSchema>;
+export type LogConfig = z.infer<typeof LogConfigSchema>;
+export type StorageConfig = z.infer<typeof StorageConfigSchema>;
+export type RawConfig = z.infer<typeof RawConfigSchema>;
+export type McpConfig = z.infer<typeof McpConfigSchema>;
+export type Config = z.infer<typeof ConfigSchema>;

package/dist/config/schema.js

@@ -0,0 +1,159 @@
+import { z } from "zod";
+/**
+ * API key format: 16-128 characters, alphanumeric with hyphens and underscores.
+ */
+const ApiKeySchema = z
+    .string()
+    .min(16, "API key must be at least 16 characters")
+    .max(128, "API key must be at most 128 characters")
+    .regex(/^[A-Za-z0-9_-]+$/, "API key must contain only A-Z, a-z, 0-9, hyphens, and underscores");
+/**
+ * MCP server entry (command + args + env)
+ */
+export const McpServerEntrySchema = z
+    .object({
+    command: z.string().min(1, "Command is required"),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    tools: z.array(z.string()).optional(),
+})
+    .strict();
+/**
+ * OAuth user credentials
+ */
+export const OAuthUserSchema = z
+    .object({
+    username: z.string().min(1, "Username is required"),
+    password: z.string().min(1, "Password is required"),
+})
+    .strict();
+/**
+ * OAuth client configuration
+ */
+export const OAuthClientSchema = z
+    .object({
+    client_id: z.string().min(1, "Client ID is required"),
+    client_name: z.string().optional(),
+    client_secret: z.string().optional(),
+    redirect_uris: z.array(z.string().url("Invalid redirect URI")).optional(),
+    grant_type: z.enum(["authorization_code", "client_credentials"]),
+})
+    .strict()
+    .refine((client) => {
+    // client_credentials requires client_secret
+    if (client.grant_type === "client_credentials" && !client.client_secret) {
+        return false;
+    }
+    return true;
+}, {
+    message: "client_secret is required for client_credentials grant type",
+})
+    .refine((client) => {
+    // authorization_code requires redirect_uris
+    if (client.grant_type === "authorization_code" &&
+        (!client.redirect_uris || client.redirect_uris.length === 0)) {
+        return false;
+    }
+    return true;
+}, {
+    message: "redirect_uris is required for authorization_code grant type",
+});
+/**
+ * Auth config - discriminated union based on type
+ */
+export const AuthConfigSchema = z.discriminatedUnion("type", [
+    // API key authentication
+    z
+        .object({
+        type: z.literal("apikey"),
+        apiKey: ApiKeySchema,
+    })
+        .strict(),
+    // OAuth authentication
+    z
+        .object({
+        type: z.literal("oauth"),
+        issuer: z.string().url("Invalid issuer URL").optional(),
+        users: z.array(OAuthUserSchema).optional(),
+        clients: z.array(OAuthClientSchema).optional(),
+        dynamic_registration: z.boolean().optional(),
+    })
+        .strict()
+        .refine((oauth) => {
+        // Must have at least users, clients, or dynamic_registration
+        const hasUsers = oauth.users && oauth.users.length > 0;
+        const hasClients = oauth.clients && oauth.clients.length > 0;
+        const hasDynamicReg = oauth.dynamic_registration === true;
+        return hasUsers || hasClients || hasDynamicReg;
+    }, {
+        message: "OAuth requires at least one of: users, clients, or dynamic_registration enabled",
+    }),
+]);
+/**
+ * Server configuration
+ */
+export const ServerConfigSchema = z
+    .object({
+    port: z
+        .number()
+        .int()
+        .min(1, "Port must be at least 1")
+        .max(65535, "Port must be at most 65535")
+        .default(8080),
+})
+    .strict();
+/**
+ * Log configuration
+ */
+export const LogConfigSchema = z
+    .object({
+    level: z.enum(["debug", "info", "warn", "error"]).optional(),
+    format: z.enum(["pretty", "json"]).optional(),
+    redactSecrets: z.boolean().optional(),
+    mcpDebug: z.boolean().optional(),
+})
+    .strict();
+/**
+ * Storage configuration - discriminated union based on type
+ */
+export const StorageConfigSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("memory") }).strict(),
+    z
+        .object({
+        type: z.literal("sqlite"),
+        path: z.string().optional(),
+    })
+        .strict(),
+]);
+/**
+ * Raw config file schema (before processing)
+ */
+export const RawConfigSchema = z
+    .object({
+    server: ServerConfigSchema.optional(),
+    auth: AuthConfigSchema.optional(),
+    storage: StorageConfigSchema.optional(),
+    log: LogConfigSchema.optional(),
+    mcpServers: z.record(z.string(), McpServerEntrySchema).optional(),
+})
+    .strict();
+/**
+ * Internal MCP config (with name resolved from key)
+ */
+export const McpConfigSchema = z.object({
+    name: z.string(),
+    command: z.string(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    tools: z.array(z.string()).optional(),
+});
+/**
+ * Processed config (after loader adds defaults and resolves mcpServers)
+ */
+export const ConfigSchema = z.object({
+    server: ServerConfigSchema,
+    auth: AuthConfigSchema.optional(),
+    storage: StorageConfigSchema.optional(),
+    log: LogConfigSchema.optional(),
+    mcps: z.array(McpConfigSchema),
+});

package/dist/config/types.d.ts

@@ -0,0 +1,5 @@
+export type { AuthConfig, Config, LogConfig, McpConfig, McpServerEntry, OAuthClient, OAuthUser, ServerConfig, StorageConfig, } from "./schema.js";
+export type GrantType = "authorization_code" | "client_credentials";
+export type McpServersConfig = {
+    mcpServers: Record<string, import("./schema.js").McpServerEntry>;
+};

package/dist/config/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import { loadConfig, resolveConfigPath } from "./config/loader.js";
+import { configureLogger, logger } from "./logger.js";
+import { createServer } from "./server.js";
+import { VERSION } from "./version.js";
+function printHelp() {
+    console.log(`
+mcpbox - Expose MCP servers via HTTP
+
+Usage:
+  mcpbox [options]
+
+Options:
+  -c, --config <path>   Path to config file (default: mcpbox.json)
+  -h, --help            Show this help message
+  -v, --version         Show version
+`);
+}
+function parseArgs(args) {
+    const result = {
+        config: undefined,
+        help: false,
+        version: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "-h" || arg === "--help") {
+            result.help = true;
+        }
+        else if (arg === "-v" || arg === "--version") {
+            result.version = true;
+        }
+        else if (arg === "-c" || arg === "--config") {
+            result.config = args[++i];
+        }
+        else if (!arg.startsWith("-")) {
+            // Positional arg = config path (backwards compat)
+            result.config = arg;
+        }
+    }
+    return result;
+}
+const args = parseArgs(process.argv.slice(2));
+if (args.help) {
+    printHelp();
+    process.exit(0);
+}
+if (args.version) {
+    console.log(VERSION);
+    process.exit(0);
+}
+const configPath = resolveConfigPath(args.config);
+let config;
+try {
+    config = loadConfig(configPath);
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    // Log to stderr directly since logger config isn't loaded yet
+    console.error(`Failed to load config from ${configPath}:\n${message}`);
+    process.exit(1);
+}
+// Reconfigure logger with settings from config
+configureLogger(config.log);
+logger.info({
+    mcps: config.mcps.map((m) => m.name),
+    auth: config.auth?.type ?? "none",
+}, "Config loaded");
+let closeServer;
+let isShuttingDown = false;
+async function shutdown(signal) {
+    if (isShuttingDown) {
+        logger.warn("Shutdown already in progress, forcing exit");
+        process.exit(1);
+    }
+    isShuttingDown = true;
+    logger.info(`Received ${signal}, shutting down gracefully...`);
+    try {
+        if (closeServer) {
+            await closeServer();
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        logger.error({
+            error: error instanceof Error ? error.message : String(error),
+        }, "Error during shutdown");
+        process.exit(1);
+    }
+}
+// Graceful shutdown handlers
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+// Handle uncaught errors
+process.on("uncaughtException", (error) => {
+    logger.error({
+        error: error.message,
+        stack: error.stack,
+    }, "Uncaught exception");
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+    logger.error({
+        reason: reason instanceof Error ? reason.message : String(reason),
+    }, "Unhandled rejection");
+    process.exit(1);
+});
+try {
+    const { close } = await createServer(config);
+    closeServer = close;
+}
+catch (error) {
+    logger.error({
+        error: error instanceof Error ? error.message : String(error),
+    }, "Failed to start server");
+    process.exit(1);
+}

package/dist/logger.d.ts

@@ -0,0 +1,5 @@
+import pino from "pino";
+import type { LogConfig } from "./config/types.js";
+export declare function redactSensitiveStrings(obj: unknown): unknown;
+export declare let logger: pino.Logger;
+export declare function configureLogger(config?: LogConfig): void;