@aquex/cmos-mcp 1.0.0

package/dist/tools/cmos/client.js

@@ -0,0 +1,669 @@
+"use strict";
+/**
+ * CmosDatabaseClient - Core database client wrapper for CMOS SQLite operations
+ *
+ * Provides:
+ * - Connection management with auto-close
+ * - Standard query patterns (getOne, getMany, execute)
+ * - Error translation to structured CmosToolError
+ * - Integration with CmosDetector for database path discovery
+ *
+ * All methods return CmosToolResult<T> for consistent agent-friendly responses.
+ *
+ * @module tools/cmos/client
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CmosDatabaseClient = exports.CMOS_PROJECT_ID_ENV = exports.CMOS_PROJECT_ROOT_ENV = exports.ProjectResolutionError = exports.resolveProjectRootPath = exports.resolveProjectRootEnhanced = exports.ProjectRegistry = void 0;
+exports.resolveProjectRoot = resolveProjectRoot;
+exports.withClient = withClient;
+exports.withClientAsync = withClientAsync;
+exports.withMultiClient = withMultiClient;
+exports.isReadAction = isReadAction;
+exports.withClientValidated = withClientValidated;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const cmos_detector_1 = require("../../intelligence/cmos-detector");
+const project_registry_1 = require("../../intelligence/project-registry");
+Object.defineProperty(exports, "ProjectRegistry", { enumerable: true, get: function () { return project_registry_1.ProjectRegistry; } });
+Object.defineProperty(exports, "resolveProjectRootEnhanced", { enumerable: true, get: function () { return project_registry_1.resolveProjectRootEnhanced; } });
+Object.defineProperty(exports, "resolveProjectRootPath", { enumerable: true, get: function () { return project_registry_1.resolveProjectRootPath; } });
+Object.defineProperty(exports, "ProjectResolutionError", { enumerable: true, get: function () { return project_registry_1.ProjectResolutionError; } });
+const errors_1 = require("./errors");
+/**
+ * Environment variable for CMOS project root.
+ * When set, tools use this as default instead of process.cwd().
+ * Useful for Claude Desktop where cwd may not be the project directory.
+ */
+exports.CMOS_PROJECT_ROOT_ENV = 'CMOS_PROJECT_ROOT';
+/**
+ * Environment variable for project ID validation.
+ * Used together with database self-protection: if database has project_id
+ * in metadata, this env var MUST match for mutation operations.
+ */
+exports.CMOS_PROJECT_ID_ENV = 'CMOS_PROJECT_ID';
+/**
+ * Resolve the project root directory (synchronous, simple fallback).
+ *
+ * Priority: explicit param > CMOS_PROJECT_ROOT env var > process.cwd()
+ *
+ * @deprecated Use resolveProjectRootEnhanced() for full 5-step resolution
+ * with auto-discovery and registry fallback. This synchronous version
+ * is kept for backward compatibility but doesn't support the registry.
+ *
+ * @param explicitRoot - Explicitly provided project root
+ * @returns Resolved project root path
+ */
+function resolveProjectRoot(explicitRoot) {
+    return explicitRoot ?? process.env[exports.CMOS_PROJECT_ROOT_ENV] ?? process.cwd();
+}
+/**
+ * CmosDatabaseClient - Wrapper around better-sqlite3 for CMOS operations
+ *
+ * Usage:
+ * ```typescript
+ * // Create client (auto-detects database)
+ * const client = await CmosDatabaseClient.create();
+ *
+ * // Query operations
+ * const missions = await client.getMany<Mission>('SELECT * FROM missions WHERE status = ?', ['In Progress']);
+ * const mission = await client.getOne<Mission>('SELECT * FROM missions WHERE id = ?', ['s12-m03']);
+ *
+ * // Mutation operations
+ * const result = await client.execute(
+ *   'UPDATE missions SET status = ? WHERE id = ?',
+ *   ['Completed', 's12-m03']
+ * );
+ *
+ * // Always close when done
+ * client.close();
+ * ```
+ */
+class CmosDatabaseClient {
+    /**
+     * Private constructor - use CmosDatabaseClient.create() instead
+     */
+    constructor(dbPath, options = {}) {
+        this.db = null;
+        this.statementCache = new Map();
+        this.dbPath = dbPath;
+        this.options = {
+            timeout: options.timeout ?? 5000,
+            readonly: options.readonly ?? false,
+            verbose: options.verbose ?? false,
+        };
+    }
+    /**
+     * Create a new CmosDatabaseClient
+     *
+     * Uses 5-step resolution priority:
+     * 1. Explicit dbPath option
+     * 2. Explicit projectRoot option
+     * 3. CMOS_PROJECT_ROOT environment variable
+     * 4. Auto-discover from cwd
+     * 5. Registry fallback (default project)
+     *
+     * @param options - Client options
+     * @returns CmosToolResult with the client or an error
+     */
+    static async create(options = {}) {
+        try {
+            let dbPath = options.dbPath;
+            // If no explicit dbPath, resolve project root and detect database
+            if (!dbPath) {
+                let projectRoot;
+                // If explicit projectRoot provided, use it directly
+                if (options.projectRoot) {
+                    projectRoot = options.projectRoot;
+                }
+                else {
+                    // Use enhanced resolution (env → auto-discover → registry → error)
+                    try {
+                        const resolution = await (0, project_registry_1.resolveProjectRootEnhanced)(undefined, {
+                            autoRegister: true,
+                            silent: true,
+                        });
+                        projectRoot = resolution.projectRoot;
+                    }
+                    catch (error) {
+                        if (error instanceof project_registry_1.ProjectResolutionError) {
+                            return (0, errors_1.createError)({
+                                code: errors_1.CMOS_ERROR_CODES.CMOS_NOT_DETECTED,
+                                message: error.message,
+                                suggestion: error.suggestion,
+                            });
+                        }
+                        throw error;
+                    }
+                }
+                const detector = cmos_detector_1.CmosDetector.getInstance();
+                const detection = await detector.detect(projectRoot);
+                if (!detection.hasCmosDirectory) {
+                    return (0, errors_1.createError)(errors_1.CmosErrors.cmosNotDetected(projectRoot));
+                }
+                if (!detection.hasDatabase || !detection.databasePath) {
+                    return (0, errors_1.createError)(errors_1.CmosErrors.dbNotFound(detection.cmosDirectory));
+                }
+                dbPath = detection.databasePath;
+            }
+            const client = new CmosDatabaseClient(dbPath, options);
+            // Test connection
+            const connectionResult = client.ensureConnection();
+            if (!connectionResult.success) {
+                return connectionResult;
+            }
+            return (0, errors_1.createSuccess)(client);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return (0, errors_1.createError)({
+                code: errors_1.CMOS_ERROR_CODES.DB_CONNECTION_FAILED,
+                message: `Failed to create database client: ${message}`,
+                suggestion: 'Check that the cmos/ directory exists and contains db/cmos.sqlite',
+            });
+        }
+    }
+    /**
+     * Create a CmosDatabaseClient from a detection result
+     *
+     * Useful when you've already run detection and want to avoid re-detecting.
+     *
+     * @param detection - CmosDetectionResult from CmosDetector
+     * @param options - Additional client options
+     * @returns CmosToolResult with the client or an error
+     */
+    static fromDetection(detection, options = {}) {
+        if (!detection.hasDatabase || !detection.databasePath) {
+            return (0, errors_1.createError)(errors_1.CmosErrors.dbNotFound(detection.cmosDirectory));
+        }
+        const client = new CmosDatabaseClient(detection.databasePath, options);
+        // Test connection
+        const connectionResult = client.ensureConnection();
+        if (!connectionResult.success) {
+            return connectionResult;
+        }
+        return (0, errors_1.createSuccess)(client);
+    }
+    /**
+     * Get the database path
+     */
+    get path() {
+        return this.dbPath;
+    }
+    /**
+     * Check if the database connection is open
+     */
+    get isOpen() {
+        return this.db !== null && this.db.open;
+    }
+    /**
+     * Ensure database connection is established
+     *
+     * @returns CmosToolResult indicating success or connection error
+     */
+    ensureConnection() {
+        if (this.db && this.db.open) {
+            return (0, errors_1.createSuccess)(undefined);
+        }
+        try {
+            this.db = new better_sqlite3_1.default(this.dbPath, {
+                readonly: this.options.readonly,
+                timeout: this.options.timeout,
+                verbose: this.options.verbose ? console.log : undefined,
+            });
+            // Enable foreign keys for referential integrity
+            this.db.pragma('foreign_keys = ON');
+            // Enable WAL mode for better concurrent access
+            this.db.pragma('journal_mode = WAL');
+            return (0, errors_1.createSuccess)(undefined);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return (0, errors_1.createError)(errors_1.CmosErrors.dbConnectionFailed(this.dbPath, message));
+        }
+    }
+    /**
+     * Get a single row from the database
+     *
+     * @param sql - SQL query (should return at most one row)
+     * @param params - Query parameters (array for positional, object for named)
+     * @returns CmosToolResult with the row or undefined if not found
+     */
+    getOne(sql, params) {
+        const connectionResult = this.ensureConnection();
+        if (!connectionResult.success) {
+            return connectionResult;
+        }
+        try {
+            const stmt = this.prepareStatement(sql);
+            const row = (params ? stmt.get(params) : stmt.get());
+            return (0, errors_1.createSuccess)(row);
+        }
+        catch (error) {
+            return this.handleQueryError(error, sql);
+        }
+    }
+    /**
+     * Get multiple rows from the database
+     *
+     * @param sql - SQL query
+     * @param params - Query parameters (array for positional, object for named)
+     * @returns CmosToolResult with array of rows (empty array if none found)
+     */
+    getMany(sql, params) {
+        const connectionResult = this.ensureConnection();
+        if (!connectionResult.success) {
+            return connectionResult;
+        }
+        try {
+            const stmt = this.prepareStatement(sql);
+            const rows = (params ? stmt.all(params) : stmt.all());
+            return (0, errors_1.createSuccess)(rows);
+        }
+        catch (error) {
+            return this.handleQueryError(error, sql);
+        }
+    }
+    /**
+     * Execute a mutation query (INSERT, UPDATE, DELETE)
+     *
+     * @param sql - SQL mutation query
+     * @param params - Query parameters (array for positional, object for named)
+     * @returns CmosToolResult with mutation result (changes, lastInsertRowid)
+     */
+    execute(sql, params) {
+        const connectionResult = this.ensureConnection();
+        if (!connectionResult.success) {
+            return connectionResult;
+        }
+        try {
+            const stmt = this.prepareStatement(sql);
+            const result = params ? stmt.run(params) : stmt.run();
+            return (0, errors_1.createSuccess)({
+                changes: result.changes,
+                lastInsertRowid: result.lastInsertRowid,
+            });
+        }
+        catch (error) {
+            return this.handleQueryError(error, sql);
+        }
+    }
+    /**
+     * Execute multiple statements in a transaction
+     *
+     * All statements succeed or all fail (atomic).
+     *
+     * @param fn - Function that performs database operations
+     * @returns CmosToolResult with the function's return value
+     */
+    transaction(fn) {
+        const connectionResult = this.ensureConnection();
+        if (!connectionResult.success) {
+            return connectionResult;
+        }
+        try {
+            const db = this.db;
+            const transaction = db.transaction(fn);
+            const result = transaction();
+            return (0, errors_1.createSuccess)(result);
+        }
+        catch (error) {
+            return this.handleQueryError(error, 'TRANSACTION');
+        }
+    }
+    /**
+     * Execute raw SQL (for complex operations like PRAGMA)
+     *
+     * Use with caution - prefer getOne/getMany/execute for standard queries.
+     *
+     * @param sql - Raw SQL to execute
+     * @returns CmosToolResult indicating success or error
+     */
+    raw(sql) {
+        const connectionResult = this.ensureConnection();
+        if (!connectionResult.success) {
+            return connectionResult;
+        }
+        try {
+            this.db.exec(sql);
+            return (0, errors_1.createSuccess)(undefined);
+        }
+        catch (error) {
+            return this.handleQueryError(error, sql);
+        }
+    }
+    /**
+     * Check database health and return statistics
+     *
+     * @returns CmosToolResult with database health information
+     */
+    health() {
+        const connectionResult = this.ensureConnection();
+        if (!connectionResult.success) {
+            return connectionResult;
+        }
+        try {
+            const db = this.db;
+            // Get SQLite version
+            const versionRow = db.prepare('SELECT sqlite_version() as version').get();
+            // Get table list
+            const tables = db
+                .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name")
+                .all();
+            // Get counts for key tables
+            const missionCount = this.safeCount('missions');
+            const sessionCount = this.safeCount('sessions');
+            const contextCount = this.safeCount('contexts');
+            return (0, errors_1.createSuccess)({
+                connected: true,
+                version: versionRow.version,
+                path: this.dbPath,
+                tables: tables.map((t) => t.name),
+                missionCount,
+                sessionCount,
+                contextCount,
+            });
+        }
+        catch (error) {
+            return this.handleQueryError(error, 'HEALTH_CHECK');
+        }
+    }
+    /**
+     * Close the database connection
+     *
+     * Clears the statement cache and releases all resources.
+     * Safe to call multiple times.
+     */
+    close() {
+        this.statementCache.clear();
+        if (this.db && this.db.open) {
+            this.db.close();
+        }
+        this.db = null;
+    }
+    /**
+     * Get a prepared statement (cached for performance)
+     */
+    prepareStatement(sql) {
+        let stmt = this.statementCache.get(sql);
+        if (!stmt) {
+            stmt = this.db.prepare(sql);
+            this.statementCache.set(sql, stmt);
+        }
+        return stmt;
+    }
+    /**
+     * Safely count rows in a table
+     */
+    safeCount(tableName) {
+        try {
+            const row = this.db.prepare(`SELECT COUNT(*) as count FROM ${tableName}`).get();
+            return row.count;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Handle query errors and translate to CmosToolError
+     */
+    handleQueryError(error, _sql) {
+        const rawMessage = error instanceof Error ? error.message : String(error ?? 'Unknown database error');
+        const message = rawMessage.toLowerCase();
+        const sqliteCode = typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            typeof error.code === 'string'
+            ? (error.code ?? '').toUpperCase()
+            : '';
+        // Check for specific SQLite error patterns
+        if (message.includes('no such table')) {
+            const tableMatch = rawMessage.match(/no such table:\s*(?:\w+\.)?([\w-]+)/i);
+            const tableName = tableMatch?.[1] ?? 'unknown';
+            return (0, errors_1.createError)({
+                code: errors_1.CMOS_ERROR_CODES.DB_SCHEMA_MISMATCH,
+                message: `Table '${tableName}' does not exist`,
+                suggestion: 'Ensure the database schema is up to date. Run migrations if needed.',
+            });
+        }
+        if (message.includes('no such column') || message.includes('has no column named')) {
+            const columnMatch = rawMessage.match(/(?:no such column|has no column named):?\s*(?:\w+\.)?([\w-]+)/i);
+            const columnName = columnMatch?.[1] ?? 'unknown';
+            return (0, errors_1.createError)({
+                code: errors_1.CMOS_ERROR_CODES.DB_SCHEMA_MISMATCH,
+                message: `Column '${columnName}' does not exist`,
+                suggestion: 'Ensure the database schema is up to date. Run migrations if needed.',
+            });
+        }
+        if (message.includes('unique constraint failed') || sqliteCode.includes('CONSTRAINT_UNIQUE')) {
+            const fieldMatch = rawMessage.match(/UNIQUE constraint failed:\s*(\S+)/i);
+            const field = fieldMatch?.[1] ?? 'unknown';
+            return (0, errors_1.createError)({
+                code: errors_1.CMOS_ERROR_CODES.INVALID_PARAMETER,
+                message: `Duplicate value for unique field '${field}'`,
+                field: field.split('.').pop(),
+                suggestion: 'Use a unique value for this field or update the existing record.',
+            });
+        }
+        if (message.includes('foreign key constraint failed') ||
+            sqliteCode.includes('CONSTRAINT_FOREIGNKEY')) {
+            return (0, errors_1.createError)({
+                code: errors_1.CMOS_ERROR_CODES.INVALID_PARAMETER,
+                message: 'Foreign key constraint violation',
+                suggestion: 'Ensure referenced records exist before inserting or updating.',
+            });
+        }
+        if (message.includes('database is locked') || sqliteCode === 'SQLITE_BUSY') {
+            return (0, errors_1.createError)({
+                code: errors_1.CMOS_ERROR_CODES.DB_CONNECTION_FAILED,
+                message: 'Database is locked by another process',
+                suggestion: 'Wait and retry, or close other applications using the database.',
+            });
+        }
+        if (message.includes('sqlite_readonly') || sqliteCode === 'SQLITE_READONLY') {
+            return (0, errors_1.createError)({
+                code: errors_1.CMOS_ERROR_CODES.DB_CONNECTION_FAILED,
+                message: 'Database is opened in read-only mode',
+                suggestion: 'Reopen the database with readonly: false to perform mutations.',
+            });
+        }
+        // Generic query error
+        return (0, errors_1.createError)({
+            code: errors_1.CMOS_ERROR_CODES.DB_QUERY_FAILED,
+            message: `Query failed: ${rawMessage}`,
+            suggestion: 'Check the SQL syntax and parameters.',
+        });
+    }
+    /**
+     * Validate project ID matches expected value from environment.
+     *
+     * Database self-protection: If the database has a project_id in metadata,
+     * the CMOS_PROJECT_ID env var MUST be set and match. This prevents
+     * cross-project contamination when multiple projects use CMOS.
+     *
+     * - Database has project_id + env var matches → success
+     * - Database has project_id + env var missing → error (protection active)
+     * - Database has project_id + env var mismatch → error
+     * - Database has no project_id → success (backward compatible)
+     *
+     * @returns CmosToolResult indicating success or mismatch error
+     */
+    validateProjectId() {
+        const expectedProjectId = process.env[exports.CMOS_PROJECT_ID_ENV];
+        const connectionResult = this.ensureConnection();
+        if (!connectionResult.success) {
+            return connectionResult;
+        }
+        try {
+            // Read project_id from metadata table
+            const stmt = this.db.prepare('SELECT value FROM metadata WHERE key = ?');
+            const row = stmt.get('project_id');
+            const databaseProjectId = row?.value ?? '';
+            // If database has no project_id, skip validation (backward compatible)
+            if (!databaseProjectId) {
+                return (0, errors_1.createSuccess)(undefined);
+            }
+            // Database has project_id - enforce validation
+            if (!expectedProjectId) {
+                return (0, errors_1.createError)({
+                    code: errors_1.CMOS_ERROR_CODES.PROJECT_ID_MISMATCH,
+                    message: `This database requires project ID validation. Database project: "${databaseProjectId}"`,
+                    suggestion: `Set CMOS_PROJECT_ID="${databaseProjectId}" environment variable to write to this database.`,
+                });
+            }
+            if (databaseProjectId !== expectedProjectId) {
+                return (0, errors_1.createError)({
+                    code: errors_1.CMOS_ERROR_CODES.PROJECT_ID_MISMATCH,
+                    message: `Project ID mismatch: env has "${expectedProjectId}", database has "${databaseProjectId}"`,
+                    suggestion: `You may be connected to the wrong database. Set CMOS_PROJECT_ID="${databaseProjectId}" or check your projectRoot.`,
+                });
+            }
+            return (0, errors_1.createSuccess)(undefined);
+        }
+        catch (error) {
+            // If metadata table doesn't exist, skip validation (old database)
+            const message = error instanceof Error ? error.message : String(error ?? '');
+            if (/no such table:\s*(?:\w+\.)?metadata/i.test(message)) {
+                // No metadata table = old database, skip validation for backward compatibility
+                return (0, errors_1.createSuccess)(undefined);
+            }
+            return this.handleQueryError(error, 'validateProjectId');
+        }
+    }
+}
+exports.CmosDatabaseClient = CmosDatabaseClient;
+/**
+ * Convenience function to create a client and run a single operation
+ *
+ * Automatically closes the connection after the operation.
+ *
+ * @param fn - Function that uses the client
+ * @param options - Client options
+ * @returns Result of the operation
+ */
+async function withClient(fn, options) {
+    const clientResult = await CmosDatabaseClient.create(options);
+    if (!clientResult.success || !clientResult.data) {
+        return clientResult;
+    }
+    const client = clientResult.data;
+    try {
+        return fn(client);
+    }
+    finally {
+        client.close();
+    }
+}
+/**
+ * Convenience function for async operations with automatic cleanup
+ *
+ * @param fn - Async function that uses the client
+ * @param options - Client options
+ * @returns Result of the operation
+ */
+async function withClientAsync(fn, options) {
+    const clientResult = await CmosDatabaseClient.create(options);
+    if (!clientResult.success || !clientResult.data) {
+        return clientResult;
+    }
+    const client = clientResult.data;
+    try {
+        return await fn(client);
+    }
+    finally {
+        client.close();
+    }
+}
+/**
+ * Fan-out a read operation across multiple CMOS instances.
+ *
+ * Runs fn against each projectRoot in parallel. Each result is tagged with
+ * resolvedFrom so callers can attribute results to their source instance.
+ * Partial failures are included in the result array rather than failing the
+ * whole call — the outer success is true as long as the fan-out itself ran.
+ *
+ * @param fn - Async operation to run against each client
+ * @param projectRoots - List of projectRoot paths to fan out across
+ * @returns Success result containing one entry per projectRoot
+ */
+async function withMultiClient(fn, projectRoots) {
+    const entries = await Promise.all(projectRoots.map(async (root) => {
+        const clientResult = await CmosDatabaseClient.create({ projectRoot: root });
+        if (!clientResult.success || !clientResult.data) {
+            return {
+                resolvedFrom: root,
+                success: false,
+                error: clientResult.error,
+            };
+        }
+        const client = clientResult.data;
+        try {
+            const result = await fn(client);
+            return {
+                resolvedFrom: root,
+                success: result.success,
+                data: result.data,
+                error: result.error,
+            };
+        }
+        finally {
+            client.close();
+        }
+    }));
+    return (0, errors_1.createSuccess)(entries);
+}
+/**
+ * Read-only CMOS actions eligible for projectRoot fan-out.
+ *
+ * When a caller omits projectRoot on one of these tool+action combinations,
+ * the server fans out across all registered instances instead of erroring.
+ * Write actions are intentionally absent — they always require an explicit
+ * projectRoot to prevent cross-instance contamination.
+ *
+ * Sprint 55 m01: cmos_sprint(list|show) and cmos_mission(list) were removed
+ * from the fan-out set. Their per-project payloads (full mission rosters and
+ * sprint_summary rows with decision counts) are large enough that fanning
+ * across a populated registry blew the tool-result size cap (~681KB for a
+ * single cmos_sprint(show) on the observed 1674-entry registry). The
+ * dispatcher now pins these actions to the caller's project via
+ * resolveToolSenderContext, the same resolution used by write actions.
+ */
+const READ_ACTIONS = {
+    cmos_mission: ['show', 'status'],
+    cmos_session: ['list'],
+    cmos_context: ['show'],
+};
+/**
+ * Return true if toolName+action is a read-only operation eligible for fan-out.
+ *
+ * cmos_agent_onboard is intentionally excluded — it has single-instance
+ * semantics (onboarding one project at a time is correct behavior).
+ *
+ * @param toolName - MCP tool name (e.g. 'cmos_mission')
+ * @param action - Action parameter value (e.g. 'list')
+ */
+function isReadAction(toolName, action) {
+    const allowed = READ_ACTIONS[toolName];
+    return allowed !== undefined && allowed.includes(action);
+}
+/**
+ * Convenience function for mutation operations.
+ *
+ * NOTE: Project ID validation has been removed. The explicit projectRoot
+ * requirement (no cwd fallback) provides sufficient protection against
+ * cross-project contamination without requiring env var configuration.
+ *
+ * This function is now identical to withClient but kept for backward
+ * compatibility with existing tool implementations.
+ *
+ * @param fn - Function that uses the client
+ * @param options - Client options
+ * @returns Result of the operation
+ */
+async function withClientValidated(fn, options) {
+    // Simply delegate to withClient - no additional validation needed
+    // since projectRoot is now required (no cwd fallback)
+    return withClient(fn, options);
+}
+//# sourceMappingURL=client.js.map