@imazhar101/mcp-bigquery-server 1.0.0

package/dist/servers/bigquery/src/index.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
+import { Logger } from '../../../shared/utils/logger.js';
+import { getEnvVar, getLogLevel, getOptionalEnvVar } from '../../../shared/utils/config.js';
+import { formatAsTable, formatAsJson } from '../../../shared/utils/formatter.js';
+import { BigQueryService } from './services/bigquery-service.js';
+import { bigqueryTools } from './tools/index.js';
+class BigQueryServer {
+    server;
+    service;
+    logger;
+    constructor() {
+        this.logger = new Logger(getLogLevel(), { server: 'bigquery' });
+        const projectId = getEnvVar('BIGQUERY_PROJECT_ID');
+        const location = getOptionalEnvVar('BIGQUERY_LOCATION', 'US');
+        const keyFilename = getOptionalEnvVar('BIGQUERY_KEY_FILE') || undefined;
+        this.service = new BigQueryService({ projectId, location, keyFilename }, this.logger);
+        this.server = new Server({ name: 'bigquery-server', version: '1.0.0' }, { capabilities: { tools: {} } });
+        this.setupToolHandlers();
+        this.setupErrorHandling();
+    }
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: bigqueryTools,
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            try {
+                return await this.handleToolCall(request.params.name, request.params.arguments);
+            }
+            catch (error) {
+                this.logger.error('Tool call failed', error);
+                if (error instanceof McpError)
+                    throw error;
+                throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error}`);
+            }
+        });
+    }
+    async handleToolCall(toolName, args) {
+        switch (toolName) {
+            case 'query': {
+                const result = await this.service.executeQuery(args.sql, args.max_rows ?? 100, args.project_id);
+                if (!result.success) {
+                    return { content: [{ type: 'text', text: result.error }], isError: true };
+                }
+                const { rows, rowCount, schema, bytesProcessed, cacheHit } = result.data;
+                const headers = schema?.map((f) => f.name) ?? Object.keys(rows[0] ?? {});
+                const body = args.format === 'json'
+                    ? formatAsJson(rows)
+                    : formatAsTable(headers, rows);
+                const meta = [
+                    `${rowCount} row${rowCount === 1 ? '' : 's'}`,
+                    bytesProcessed ? `${(Number(bytesProcessed) / 1e6).toFixed(2)} MB processed` : null,
+                    cacheHit ? 'cache hit' : null,
+                ]
+                    .filter(Boolean)
+                    .join(' · ');
+                return { content: [{ type: 'text', text: `${body}\n\n${meta}` }] };
+            }
+            case 'list_datasets': {
+                const result = await this.service.listDatasets(args.project_id);
+                if (!result.success) {
+                    return { content: [{ type: 'text', text: result.error }], isError: true };
+                }
+                const rows = result.data.map((d) => ({
+                    dataset: d.id,
+                    location: d.location,
+                    created: d.createdAt?.split('T')[0] ?? '',
+                    description: d.description ?? '',
+                }));
+                const text = rows.length === 0
+                    ? 'No datasets found.'
+                    : formatAsTable(['dataset', 'location', 'created', 'description'], rows) +
+                        `\n\n${rows.length} dataset${rows.length === 1 ? '' : 's'}`;
+                return { content: [{ type: 'text', text }] };
+            }
+            case 'list_tables': {
+                const result = await this.service.listTables(args.dataset, args.project_id);
+                if (!result.success) {
+                    return { content: [{ type: 'text', text: result.error }], isError: true };
+                }
+                const rows = result.data.map((t) => ({
+                    table: t.id,
+                    type: t.type,
+                    rows: t.rowCount ? Number(t.rowCount).toLocaleString() : '—',
+                    size: t.sizeBytes
+                        ? `${(Number(t.sizeBytes) / 1e6).toFixed(2)} MB`
+                        : '—',
+                    created: t.createdAt?.split('T')[0] ?? '',
+                }));
+                const text = rows.length === 0
+                    ? `No tables found in dataset "${args.dataset}".`
+                    : formatAsTable(['table', 'type', 'rows', 'size', 'created'], rows) +
+                        `\n\n${rows.length} table${rows.length === 1 ? '' : 's'} in ${args.dataset}`;
+                return { content: [{ type: 'text', text }] };
+            }
+            case 'get_table_schema': {
+                const result = await this.service.getTableSchema(args.dataset, args.table, args.project_id);
+                if (!result.success) {
+                    return { content: [{ type: 'text', text: result.error }], isError: true };
+                }
+                const rows = result.data.map((f) => ({
+                    column: f.name,
+                    type: f.type,
+                    mode: f.mode,
+                    description: f.description ?? '',
+                }));
+                const text = rows.length === 0
+                    ? 'Table has no schema fields.'
+                    : formatAsTable(['column', 'type', 'mode', 'description'], rows) +
+                        `\n\n${rows.length} column${rows.length === 1 ? '' : 's'} — ${args.dataset}.${args.table}`;
+                return { content: [{ type: 'text', text }] };
+            }
+            case 'preview_table': {
+                const result = await this.service.previewTable(args.dataset, args.table, args.limit ?? 10, args.project_id);
+                if (!result.success) {
+                    return { content: [{ type: 'text', text: result.error }], isError: true };
+                }
+                const { rows, rowCount, schema } = result.data;
+                const headers = schema?.map((f) => f.name) ?? Object.keys(rows[0] ?? {});
+                const text = rowCount === 0
+                    ? `Table "${args.dataset}.${args.table}" is empty.`
+                    : formatAsTable(headers, rows) + `\n\n${rowCount} row${rowCount === 1 ? '' : 's'} previewed`;
+                return { content: [{ type: 'text', text }] };
+            }
+            default:
+                throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${toolName}`);
+        }
+    }
+    setupErrorHandling() {
+        this.server.onerror = (error) => {
+            this.logger.error('MCP Server error', error);
+        };
+        const shutdown = async () => {
+            this.logger.info('Shutting down BigQuery MCP server');
+            await this.server.close();
+            process.exit(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        this.logger.info('BigQuery MCP server running on stdio');
+    }
+}
+const server = new BigQueryServer();
+server.run().catch((error) => {
+    console.error('Failed to start BigQuery MCP server:', error);
+    process.exit(1);
+});

package/dist/servers/bigquery/src/services/bigquery-service.js

@@ -0,0 +1,148 @@
+import { BigQuery } from '@google-cloud/bigquery';
+const MAX_ROWS_HARD_LIMIT = 1000;
+export class BigQueryService {
+    client;
+    config;
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+        const options = {
+            projectId: config.projectId,
+            location: config.location,
+        };
+        if (config.keyFilename) {
+            options.keyFilename = config.keyFilename;
+        }
+        this.client = new BigQuery(options);
+    }
+    async executeQuery(sql, maxRows = 100, projectId) {
+        const billingProject = projectId ?? this.config.projectId;
+        const clampedRows = Math.min(maxRows, MAX_ROWS_HARD_LIMIT);
+        this.logger.info(`Dry-run validating query on project: ${billingProject}`);
+        try {
+            // Enforce read-only via BigQuery dry-run — checks statementType server-side
+            const [dryRunJob] = await this.client.createQueryJob({
+                query: sql,
+                dryRun: true,
+                location: this.config.location,
+                defaultDataset: { projectId: billingProject },
+            });
+            const statementType = dryRunJob.metadata?.statistics?.query?.statementType ?? '';
+            if (statementType !== 'SELECT') {
+                return {
+                    success: false,
+                    error: `Only SELECT queries are allowed. Detected statement type: "${statementType}".`,
+                };
+            }
+            const bytesProcessed = dryRunJob.metadata?.statistics?.totalBytesProcessed ?? '0';
+            this.logger.info(`Dry-run OK — type: ${statementType}, bytes: ${bytesProcessed}`);
+            // Execute for real — use createQueryJob to access job metadata (schema, cacheHit)
+            const [job] = await this.client.createQueryJob({
+                query: sql,
+                location: this.config.location,
+                defaultDataset: { projectId: billingProject },
+                maximumBytesBilled: String(10 * 1024 * 1024 * 1024), // 10 GB safety cap
+            });
+            const [rows] = await job.getQueryResults({ maxResults: clampedRows });
+            const jobMeta = job.metadata?.statistics?.query;
+            const schemaFields = job.metadata?.configuration?.query?.destinationTable
+                ? []
+                : ((await job.getMetadata())[0]?.statistics?.query?.schema?.fields ?? []);
+            // Schema is more reliably fetched from the query response rows keys
+            const headers = rows.length > 0 ? Object.keys(rows[0]) : [];
+            const schema = schemaFields.length > 0
+                ? schemaFields.map((f) => ({
+                    name: f.name,
+                    type: f.type,
+                    mode: f.mode ?? 'NULLABLE',
+                    description: f.description,
+                }))
+                : headers.map((name) => ({ name, type: 'UNKNOWN', mode: 'NULLABLE' }));
+            return {
+                success: true,
+                data: {
+                    rows,
+                    rowCount: rows.length,
+                    schema,
+                    bytesProcessed,
+                    cacheHit: jobMeta?.cacheHit ?? false,
+                },
+            };
+        }
+        catch (err) {
+            this.logger.error('Query failed', err);
+            return {
+                success: false,
+                error: err?.message ?? String(err),
+            };
+        }
+    }
+    async listDatasets(projectId) {
+        const project = projectId ?? this.config.projectId;
+        this.logger.info(`Listing datasets in project: ${project}`);
+        try {
+            const [datasets] = await this.client.getDatasets({ projectId: project });
+            const data = datasets.map((ds) => ({
+                id: ds.id ?? '',
+                location: ds.metadata?.location ?? '',
+                createdAt: ds.metadata?.creationTime
+                    ? new Date(Number(ds.metadata.creationTime)).toISOString()
+                    : undefined,
+                description: ds.metadata?.description,
+            }));
+            return { success: true, data };
+        }
+        catch (err) {
+            return { success: false, error: err?.message ?? String(err) };
+        }
+    }
+    async listTables(datasetId, projectId) {
+        const project = projectId ?? this.config.projectId;
+        this.logger.info(`Listing tables in ${project}.${datasetId}`);
+        try {
+            const dataset = this.client.dataset(datasetId, { projectId: project });
+            const [tables] = await dataset.getTables();
+            const data = tables.map((t) => ({
+                id: t.id ?? '',
+                type: t.metadata?.type ?? 'TABLE',
+                rowCount: t.metadata?.numRows,
+                sizeBytes: t.metadata?.numBytes,
+                createdAt: t.metadata?.creationTime
+                    ? new Date(Number(t.metadata.creationTime)).toISOString()
+                    : undefined,
+                description: t.metadata?.description,
+            }));
+            return { success: true, data };
+        }
+        catch (err) {
+            return { success: false, error: err?.message ?? String(err) };
+        }
+    }
+    async getTableSchema(datasetId, tableId, projectId) {
+        const project = projectId ?? this.config.projectId;
+        this.logger.info(`Getting schema for ${project}.${datasetId}.${tableId}`);
+        try {
+            const table = this.client
+                .dataset(datasetId, { projectId: project })
+                .table(tableId);
+            const [metadata] = await table.getMetadata();
+            const fields = (metadata?.schema?.fields ?? []).map((f) => ({
+                name: f.name,
+                type: f.type,
+                mode: f.mode ?? 'NULLABLE',
+                description: f.description,
+            }));
+            return { success: true, data: fields };
+        }
+        catch (err) {
+            return { success: false, error: err?.message ?? String(err) };
+        }
+    }
+    async previewTable(datasetId, tableId, limit = 10, projectId) {
+        const project = projectId ?? this.config.projectId;
+        const clampedLimit = Math.min(limit, 100);
+        const sql = `SELECT * FROM \`${project}.${datasetId}.${tableId}\` LIMIT ${clampedLimit}`;
+        return this.executeQuery(sql, clampedLimit, project);
+    }
+}

package/dist/servers/bigquery/src/tools/index.js

@@ -0,0 +1,105 @@
+export const bigqueryTools = [
+    {
+        name: 'query',
+        description: 'Execute a read-only BigQuery SQL query. Only SELECT statements are allowed — enforced via BigQuery dry-run before execution. Results are returned as a formatted table. Use backtick-quoted fully qualified table names: `project.dataset.table`.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sql: {
+                    type: 'string',
+                    description: 'The SQL SELECT query to execute',
+                },
+                max_rows: {
+                    type: 'number',
+                    description: 'Maximum rows to return (default: 100, max: 1000)',
+                },
+                format: {
+                    type: 'string',
+                    enum: ['table', 'json'],
+                    description: 'Output format — "table" (default) or "json"',
+                },
+            },
+            required: ['sql'],
+        },
+    },
+    {
+        name: 'list_datasets',
+        description: 'List all datasets in the configured BigQuery project.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: {
+                    type: 'string',
+                    description: 'Override project ID (defaults to configured project)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'list_tables',
+        description: 'List all tables and views in a BigQuery dataset.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                dataset: {
+                    type: 'string',
+                    description: 'Dataset ID to list tables from',
+                },
+                project_id: {
+                    type: 'string',
+                    description: 'Override project ID (defaults to configured project)',
+                },
+            },
+            required: ['dataset'],
+        },
+    },
+    {
+        name: 'get_table_schema',
+        description: 'Get the full schema (columns, types, modes) for a BigQuery table or view.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                dataset: {
+                    type: 'string',
+                    description: 'Dataset ID containing the table',
+                },
+                table: {
+                    type: 'string',
+                    description: 'Table or view name',
+                },
+                project_id: {
+                    type: 'string',
+                    description: 'Override project ID (defaults to configured project)',
+                },
+            },
+            required: ['dataset', 'table'],
+        },
+    },
+    {
+        name: 'preview_table',
+        description: 'Preview the first N rows of a BigQuery table without writing SQL.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                dataset: {
+                    type: 'string',
+                    description: 'Dataset ID containing the table',
+                },
+                table: {
+                    type: 'string',
+                    description: 'Table name to preview',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Number of rows to preview (default: 10, max: 100)',
+                },
+                project_id: {
+                    type: 'string',
+                    description: 'Override project ID (defaults to configured project)',
+                },
+            },
+            required: ['dataset', 'table'],
+        },
+    },
+];

package/dist/servers/bigquery/src/types/index.js

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

package/dist/shared/middleware/auth.js

@@ -0,0 +1,40 @@
+import { validateRequired, validateApiKey } from '../utils/validation.js';
+export class AuthMiddleware {
+    credentials;
+    constructor(credentials) {
+        this.credentials = credentials;
+        this.validateCredentials();
+    }
+    validateCredentials() {
+        if (this.credentials.apiKey) {
+            if (!validateApiKey(this.credentials.apiKey)) {
+                throw new Error('Invalid API key format');
+            }
+        }
+        if (this.credentials.username) {
+            validateRequired(this.credentials.username, 'Username');
+        }
+        if (this.credentials.baseUrl) {
+            validateRequired(this.credentials.baseUrl, 'Base URL');
+        }
+    }
+    getAuthHeaders() {
+        const headers = {};
+        if (this.credentials.apiKey) {
+            headers['Authorization'] = `Bearer ${this.credentials.apiKey}`;
+        }
+        if (this.credentials.token) {
+            headers['Authorization'] = `Bearer ${this.credentials.token}`;
+        }
+        if (this.credentials.username && this.credentials.password) {
+            const auth = Buffer.from(`${this.credentials.username}:${this.credentials.password}`).toString('base64');
+            headers['Authorization'] = `Basic ${auth}`;
+        }
+        return headers;
+    }
+    isAuthenticated() {
+        return !!(this.credentials.apiKey ||
+            this.credentials.token ||
+            (this.credentials.username && this.credentials.password));
+    }
+}

package/dist/shared/middleware/error-handler.js

@@ -0,0 +1,44 @@
+export class ErrorHandler {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    handleError(error, context) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const contextMsg = context ? `[${context}]` : '';
+        this.logger.error(`${contextMsg} ${errorMessage}`, error);
+        return {
+            success: false,
+            error: errorMessage,
+            message: 'An error occurred while processing your request',
+        };
+    }
+    handleApiError(error, apiName) {
+        if (error.response) {
+            const status = error.response.status;
+            const statusText = error.response.statusText;
+            const message = error.response.data?.message ||
+                error.response.data?.error ||
+                statusText;
+            this.logger.error(`${apiName} API error: ${status} ${statusText}`, {
+                status,
+                statusText,
+                data: error.response.data,
+            });
+            return {
+                success: false,
+                error: `${apiName} API error: ${message}`,
+                message: `Failed to communicate with ${apiName}`,
+            };
+        }
+        return this.handleError(error, `${apiName} API`);
+    }
+    handleValidationError(field, message) {
+        this.logger.warn(`Validation error for field '${field}': ${message}`);
+        return {
+            success: false,
+            error: `Validation failed for ${field}: ${message}`,
+            message: 'Please check your input and try again',
+        };
+    }
+}

package/dist/shared/middleware/request-logger.js

@@ -0,0 +1,14 @@
+export function logToolCall(logger, toolName, args, fn) {
+    const start = Date.now();
+    const argKeys = args && typeof args === 'object' ? Object.keys(args) : [];
+    logger.debug(`→ ${toolName}`, { args: argKeys });
+    return fn().then((result) => {
+        const ms = Date.now() - start;
+        logger.info(`← ${toolName}`, { ms, ok: true });
+        return result;
+    }, (error) => {
+        const ms = Date.now() - start;
+        logger.error(`✗ ${toolName} (${ms}ms)`, error instanceof Error ? error.message : String(error));
+        throw error;
+    });
+}

package/dist/shared/types/common.js

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

package/dist/shared/types/mcp.js

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

package/dist/shared/utils/config.js

@@ -0,0 +1,23 @@
+export function getEnvVar(key, defaultValue) {
+    const value = process.env[key];
+    if (value === undefined) {
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        throw new Error(`Environment variable ${key} is required but not set`);
+    }
+    return value;
+}
+export function getOptionalEnvVar(key, defaultValue = '') {
+    return process.env[key] || defaultValue;
+}
+export function getLogLevel() {
+    const level = process.env.LOG_LEVEL?.toLowerCase();
+    return ['debug', 'info', 'warn', 'error'].includes(level) ? level : 'info';
+}
+export function isProduction() {
+    return process.env.NODE_ENV === 'production';
+}
+export function isDevelopment() {
+    return process.env.NODE_ENV === 'development';
+}

package/dist/shared/utils/formatter.js

@@ -0,0 +1,47 @@
+export function formatAsTable(headers, rows) {
+    if (!headers || headers.length === 0)
+        return '(no columns)';
+    const cellValue = (val) => {
+        if (val === null || val === undefined)
+            return '';
+        if (typeof val === 'object')
+            return JSON.stringify(val);
+        return String(val);
+    };
+    // Support both array rows and object rows (keyed by header name)
+    const normalizedRows = rows.map((row) => {
+        if (Array.isArray(row))
+            return row.map(cellValue);
+        return headers.map((h) => cellValue(row[h]));
+    });
+    const headerRow = '|' + headers.join('|');
+    const dataRows = normalizedRows.map((row) => '|' + row.join('|'));
+    return [headerRow, ...dataRows].join('\n');
+}
+export function formatAsJson(data) {
+    return JSON.stringify(data, null, 2);
+}
+export function formatAsCsv(headers, rows) {
+    const escape = (val) => {
+        if (val === null || val === undefined)
+            return '';
+        const str = typeof val === 'object' ? JSON.stringify(val) : String(val);
+        // Quote fields containing commas, quotes, or newlines
+        if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+            return `"${str.replace(/"/g, '""')}"`;
+        }
+        return str;
+    };
+    const normalizedRows = rows.map((row) => {
+        if (Array.isArray(row))
+            return row.map(escape);
+        return headers.map((h) => escape(row[h]));
+    });
+    return [
+        headers.map(escape).join(','),
+        ...normalizedRows.map((row) => row.join(',')),
+    ].join('\n');
+}
+export function formatWriteResult(rowCount) {
+    return `${rowCount} row${rowCount === 1 ? '' : 's'} affected`;
+}

package/dist/shared/utils/logger.js

@@ -0,0 +1,46 @@
+export class Logger {
+    level;
+    context;
+    constructor(level = 'info', context = {}) {
+        this.level = level;
+        this.context = context;
+    }
+    shouldLog(level) {
+        const levels = {
+            debug: 0,
+            info: 1,
+            warn: 2,
+            error: 3,
+        };
+        return levels[level] >= levels[this.level];
+    }
+    formatMessage(level, message, data) {
+        const timestamp = new Date().toISOString();
+        const contextStr = this.context.server ? `[${this.context.server}]` : '';
+        const dataStr = data ? ` ${JSON.stringify(data)}` : '';
+        return `${timestamp} ${level.toUpperCase()} ${contextStr} ${message}${dataStr}`;
+    }
+    debug(message, data) {
+        if (this.shouldLog('debug')) {
+            console.error(this.formatMessage('debug', message, data));
+        }
+    }
+    info(message, data) {
+        if (this.shouldLog('info')) {
+            console.error(this.formatMessage('info', message, data));
+        }
+    }
+    warn(message, data) {
+        if (this.shouldLog('warn')) {
+            console.error(this.formatMessage('warn', message, data));
+        }
+    }
+    error(message, error) {
+        if (this.shouldLog('error')) {
+            console.error(this.formatMessage('error', message, error));
+        }
+    }
+    withContext(context) {
+        return new Logger(this.level, { ...this.context, ...context });
+    }
+}

package/dist/shared/utils/validation.js

@@ -0,0 +1,24 @@
+export function validateRequired(value, fieldName) {
+    if (value === undefined || value === null || value === '') {
+        throw new Error(`${fieldName} is required`);
+    }
+}
+export function validateEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+export function validateUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function sanitizeString(input) {
+    return input.trim().replace(/[<>]/g, '');
+}
+export function validateApiKey(apiKey, minLength = 10) {
+    return typeof apiKey === 'string' && apiKey.length >= minLength;
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@imazhar101/mcp-bigquery-server",
+  "version": "1.0.0",
+  "description": "BigQuery MCP server — read-only query execution, schema exploration, dataset discovery",
+  "type": "module",
+  "main": "dist/servers/bigquery/src/index.js",
+  "bin": {
+    "mcp-bigquery": "dist/servers/bigquery/src/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@google-cloud/bigquery": "7.9.4",
+    "@modelcontextprotocol/sdk": "1.29.0"
+  },
+  "devDependencies": {
+    "@types/node": "20.0.0",
+    "typescript": "5.9.3"
+  },
+  "files": [
+    "dist"
+  ]
+}