@animalabs/agent-framework 0.1.0

package/dist/src/api/server.js

@@ -0,0 +1,785 @@
+/**
+ * WebSocket API Server for the agent framework
+ *
+ * Provides real-time bidirectional communication:
+ * - Commands from clients (send messages, branch, inspect)
+ * - Events from framework (inference, tools, speech)
+ */
+import { WebSocketServer, WebSocket } from 'ws';
+import { createServer } from 'node:http';
+export * from './types.js';
+const DEFAULT_CONFIG = {
+    port: 8765,
+    host: 'localhost',
+    path: '/ws',
+    enableHttp: true,
+};
+/** Polling interval for subscriptions (ms) */
+const SUBSCRIPTION_POLL_INTERVAL = 50;
+/**
+ * API Server for the agent framework.
+ */
+export class ApiServer {
+    config;
+    framework;
+    wss = null;
+    httpServer = null;
+    clients = new Set();
+    currentBranch = 'main';
+    /** Map from client to their subscription IDs */
+    clientSubscriptions = new Map();
+    /** Subscription poll interval timer */
+    subscriptionPollInterval = null;
+    constructor(framework, config = {}) {
+        this.framework = framework;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Start the API server.
+     */
+    async start() {
+        // Create HTTP server for both WebSocket upgrade and REST endpoints
+        this.httpServer = createServer((req, res) => {
+            if (this.config.enableHttp) {
+                this.handleHttpRequest(req, res);
+            }
+            else {
+                res.writeHead(404);
+                res.end();
+            }
+        });
+        // Create WebSocket server
+        this.wss = new WebSocketServer({
+            server: this.httpServer,
+            path: this.config.path,
+        });
+        this.wss.on('connection', (ws) => {
+            this.handleConnection(ws);
+        });
+        // Subscribe to trace events
+        this.framework.onTrace((event) => {
+            this.handleTraceEvent(event);
+        });
+        // Start listening
+        await new Promise((resolve) => {
+            this.httpServer.listen(this.config.port, this.config.host, () => {
+                console.log(`API server listening on ws://${this.config.host}:${this.config.port}${this.config.path}`);
+                resolve();
+            });
+        });
+        // Start subscription polling
+        this.subscriptionPollInterval = setInterval(() => {
+            this.pollSubscriptions();
+        }, SUBSCRIPTION_POLL_INTERVAL);
+    }
+    /**
+     * Stop the API server.
+     */
+    async stop() {
+        // Stop subscription polling
+        if (this.subscriptionPollInterval) {
+            clearInterval(this.subscriptionPollInterval);
+            this.subscriptionPollInterval = null;
+        }
+        // Cleanup all subscriptions
+        const store = this.framework.getStore();
+        for (const [_, subscriptionIds] of this.clientSubscriptions) {
+            for (const subId of subscriptionIds) {
+                store.unsubscribe(subId);
+            }
+        }
+        this.clientSubscriptions.clear();
+        // Close all client connections
+        for (const client of this.clients) {
+            client.close();
+        }
+        this.clients.clear();
+        // Close servers
+        if (this.wss) {
+            this.wss.close();
+            this.wss = null;
+        }
+        if (this.httpServer) {
+            await new Promise((resolve) => {
+                this.httpServer.close(() => resolve());
+            });
+            this.httpServer = null;
+        }
+    }
+    /**
+     * Get the server URL.
+     */
+    get url() {
+        return `ws://${this.config.host}:${this.config.port}${this.config.path}`;
+    }
+    // ==========================================================================
+    // WebSocket Handling
+    // ==========================================================================
+    handleConnection(ws) {
+        this.clients.add(ws);
+        ws.on('message', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                this.handleClientMessage(ws, message);
+            }
+            catch (error) {
+                this.sendResponse(ws, {
+                    type: 'response',
+                    success: false,
+                    error: 'Invalid JSON',
+                });
+            }
+        });
+        ws.on('close', () => {
+            this.cleanupClientSubscriptions(ws);
+            this.clients.delete(ws);
+        });
+        ws.on('error', (error) => {
+            console.error('WebSocket error:', error);
+            this.cleanupClientSubscriptions(ws);
+            this.clients.delete(ws);
+        });
+        // Send welcome event
+        this.sendEvent(ws, 'connected', {
+            currentBranch: this.currentBranch,
+            agents: this.framework.getAllAgents().map((a) => a.name),
+        });
+    }
+    async handleClientMessage(ws, message) {
+        if (message.type !== 'request') {
+            this.sendResponse(ws, {
+                type: 'response',
+                id: message.id,
+                success: false,
+                error: 'Expected request message',
+            });
+            return;
+        }
+        try {
+            const result = await this.executeCommand(ws, message.command, message.params);
+            this.sendResponse(ws, {
+                type: 'response',
+                id: message.id,
+                success: true,
+                data: result,
+            });
+        }
+        catch (error) {
+            this.sendResponse(ws, {
+                type: 'response',
+                id: message.id,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    sendResponse(ws, response) {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify(response));
+        }
+    }
+    sendEvent(ws, event, data) {
+        if (ws.readyState === WebSocket.OPEN) {
+            const message = { type: 'event', event, data };
+            ws.send(JSON.stringify(message));
+        }
+    }
+    broadcast(event, data) {
+        const message = { type: 'event', event, data };
+        const json = JSON.stringify(message);
+        for (const client of this.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(json);
+            }
+        }
+    }
+    // ==========================================================================
+    // Trace Event Handling
+    // ==========================================================================
+    handleTraceEvent(event) {
+        // Skip process:received — clients don't need raw input events
+        if (event.type === 'process:received') {
+            return;
+        }
+        // Broadcast all other trace events directly — no translation needed
+        // TraceEvents are already serializable (error is string, not Error)
+        this.broadcast(event.type, event);
+    }
+    // ==========================================================================
+    // Command Execution
+    // ==========================================================================
+    async executeCommand(ws, command, params) {
+        switch (command) {
+            // Conversation
+            case 'message.send':
+                return this.cmdMessageSend(params);
+            case 'message.list':
+                return this.cmdMessageList(params);
+            case 'inference.request':
+                return this.cmdInferenceRequest(params);
+            case 'inference.abort':
+                return this.cmdInferenceAbort(params);
+            // Branching
+            case 'branch.list':
+                return this.cmdBranchList();
+            case 'branch.create':
+                return this.cmdBranchCreate(params);
+            case 'branch.switch':
+                return this.cmdBranchSwitch(params);
+            case 'branch.current':
+                return this.cmdBranchCurrent();
+            case 'branch.delete':
+                return this.cmdBranchDelete(params);
+            // Undo/Redo
+            case 'undo':
+                return this.cmdUndo(params);
+            case 'redo':
+                return this.cmdRedo(params);
+            case 'undo.state':
+                return this.cmdUndoState(params);
+            // Inspection
+            case 'agent.list':
+                return this.cmdAgentList();
+            case 'agent.context':
+                return this.cmdAgentContext(params);
+            case 'module.list':
+                return this.cmdModuleList();
+            case 'module.state':
+                return this.cmdModuleState(params);
+            case 'store.states':
+                return this.cmdStoreStates(params);
+            case 'store.inspect':
+                return this.cmdStoreInspect(params);
+            case 'store.search':
+                return this.cmdStoreSearch(params);
+            // Subscriptions
+            case 'store.subscribe':
+                return this.cmdStoreSubscribe(ws, params);
+            case 'store.unsubscribe':
+                return this.cmdStoreUnsubscribe(ws, params);
+            // Inference logs
+            case 'inference.tail':
+                return this.cmdInferenceTail(params);
+            case 'inference.inspect':
+                return this.cmdInferenceInspect(params);
+            case 'inference.search':
+                return this.cmdInferenceSearch(params);
+            // Event logs
+            case 'events.tail':
+                return this.cmdEventsTail(params);
+            case 'events.inspect':
+                return this.cmdEventsInspect(params);
+            case 'events.search':
+                return this.cmdEventsSearch(params);
+            case 'events.subscribe':
+                return this.cmdEventsSubscribe(params);
+            default:
+                throw new Error(`Unknown command: ${command}`);
+        }
+    }
+    // ==========================================================================
+    // Conversation Commands
+    // ==========================================================================
+    async cmdMessageSend(params) {
+        if (!params.participant || !params.content) {
+            throw new Error('participant and content are required');
+        }
+        // Push api:message event for the ApiModule to handle
+        this.framework.pushEvent({
+            type: 'api:message',
+            participant: params.participant,
+            content: params.content,
+            triggerInference: params.triggerInference ?? true,
+            targetAgents: params.targetAgents,
+        });
+        return { messageId: 'pending' }; // TODO: return actual ID
+    }
+    async cmdMessageList(params) {
+        // Get messages from first agent's context manager
+        const agent = this.framework.getAllAgents()[0];
+        if (!agent) {
+            return { messages: [] };
+        }
+        const contextManager = agent.getContextManager();
+        const { messages } = await contextManager.compile();
+        const limit = params?.limit ?? 50;
+        const offset = params?.offset ?? 0;
+        return {
+            messages: messages.slice(-(limit + offset), offset ? -offset : undefined),
+        };
+    }
+    async cmdInferenceRequest(params) {
+        // Push api:inference-request event for the ApiModule to handle
+        this.framework.pushEvent({
+            type: 'api:inference-request',
+            agentName: params?.agentName,
+            reason: params?.reason,
+        });
+        return { queued: true };
+    }
+    async cmdInferenceAbort(params) {
+        if (!params?.agentName) {
+            throw new Error('agentName is required');
+        }
+        const aborted = this.framework.abortInference(params.agentName, params.reason);
+        return { aborted };
+    }
+    // ==========================================================================
+    // Branch Commands
+    // ==========================================================================
+    async cmdBranchList() {
+        const store = this.framework.getStore();
+        const branches = store.listBranches();
+        return {
+            branches: branches.map((branch) => ({
+                name: branch.name,
+                isCurrent: branch.name === this.currentBranch,
+            })),
+        };
+    }
+    async cmdBranchCreate(params) {
+        if (!params.name) {
+            throw new Error('name is required');
+        }
+        const store = this.framework.getStore();
+        store.createBranch(params.name);
+        this.broadcast('branch:created', {
+            name: params.name,
+            parent: this.currentBranch,
+        });
+        if (params.switchTo) {
+            await this.cmdBranchSwitch({ name: params.name });
+        }
+        return { name: params.name };
+    }
+    async cmdBranchSwitch(params) {
+        if (!params.name) {
+            throw new Error('name is required');
+        }
+        const store = this.framework.getStore();
+        const previousBranch = this.currentBranch;
+        store.switchBranch(params.name);
+        this.currentBranch = params.name;
+        // Materialize config files from the new branch
+        const ws = this.framework.getModule('workspace');
+        if (ws && 'materializeMount' in ws) {
+            await ws.materializeMount('_config');
+        }
+        this.broadcast('branch:switched', {
+            from: previousBranch,
+            to: params.name,
+        });
+        return { switched: true };
+    }
+    async cmdBranchCurrent() {
+        return { name: this.currentBranch };
+    }
+    async cmdBranchDelete(params) {
+        if (!params.name) {
+            throw new Error('name is required');
+        }
+        if (params.name === this.currentBranch) {
+            throw new Error('Cannot delete current branch');
+        }
+        if (params.name === 'main') {
+            throw new Error('Cannot delete main branch');
+        }
+        const store = this.framework.getStore();
+        store.deleteBranch(params.name);
+        this.broadcast('branch:deleted', { name: params.name });
+        return { deleted: true };
+    }
+    // ==========================================================================
+    // Undo/Redo Commands
+    // ==========================================================================
+    cmdUndo(params) {
+        if (!params.agentName) {
+            throw new Error('agentName is required');
+        }
+        const result = this.framework.undoLastTurn(params.agentName);
+        if (result.undone) {
+            this.currentBranch = result.toBranch;
+            this.broadcast('branch:switched', {
+                from: result.fromBranch,
+                to: result.toBranch,
+                reason: 'undo',
+            });
+        }
+        return result;
+    }
+    cmdRedo(params) {
+        if (!params.agentName) {
+            throw new Error('agentName is required');
+        }
+        const result = this.framework.redo(params.agentName);
+        if (result.redone) {
+            this.currentBranch = result.toBranch;
+            this.broadcast('branch:switched', {
+                from: result.fromBranch,
+                to: result.toBranch,
+                reason: 'redo',
+            });
+        }
+        return result;
+    }
+    cmdUndoState(params) {
+        if (!params.agentName) {
+            throw new Error('agentName is required');
+        }
+        return this.framework.getUndoRedoState(params.agentName);
+    }
+    // ==========================================================================
+    // Inspection Commands
+    // ==========================================================================
+    async cmdAgentList() {
+        const agents = this.framework.getAllAgents();
+        return {
+            agents: agents.map((a) => ({
+                name: a.name,
+                model: a.model,
+                status: a.state.status,
+                systemPromptPreview: a.systemPrompt.substring(0, 200) + '...',
+                allowedTools: a.allowedTools,
+            })),
+        };
+    }
+    async cmdAgentContext(params) {
+        if (!params.agentName) {
+            throw new Error('agentName is required');
+        }
+        const agent = this.framework.getAgent(params.agentName);
+        if (!agent) {
+            throw new Error(`Agent not found: ${params.agentName}`);
+        }
+        const contextManager = agent.getContextManager();
+        const { messages } = await contextManager.compile(params.maxTokens
+            ? { maxTokens: params.maxTokens, reserveForResponse: 4096 }
+            : undefined);
+        return { context: messages };
+    }
+    async cmdModuleList() {
+        const modules = this.framework.getAllModules();
+        const allTools = this.framework.getAllTools();
+        return {
+            modules: modules.map((module) => ({
+                name: module.name,
+                tools: allTools
+                    .filter((t) => t.name.startsWith(`${module.name}:`))
+                    .map((t) => t.name),
+            })),
+        };
+    }
+    async cmdModuleState(params) {
+        if (!params.moduleName) {
+            throw new Error('moduleName is required');
+        }
+        const store = this.framework.getStore();
+        const stateId = `modules/${params.moduleName}/state`;
+        const state = store.getStateJson(stateId);
+        return { state };
+    }
+    async cmdStoreStates(params) {
+        const store = this.framework.getStore();
+        let stateInfos = store.listStates();
+        // Filter by namespace
+        if (params?.namespace) {
+            stateInfos = stateInfos.filter((info) => info.id.startsWith(params.namespace));
+        }
+        // Apply limit (default 50)
+        const limit = params?.limit ?? 50;
+        stateInfos = stateInfos.slice(-limit);
+        return {
+            states: stateInfos.map((info) => ({
+                id: info.id,
+                strategy: info.strategy,
+                hasData: store.getStateJson(info.id) !== null,
+            })),
+        };
+    }
+    async cmdStoreSearch(params) {
+        const store = this.framework.getStore();
+        let stateInfos = store.listStates();
+        // Filter by namespace
+        if (params?.namespace) {
+            stateInfos = stateInfos.filter((info) => info.id.startsWith(params.namespace));
+        }
+        const limit = params?.limit ?? 20;
+        const offset = params?.offset ?? 0;
+        const previewLength = params?.previewLength ?? 300;
+        const pattern = params?.contentPattern ? new RegExp(params.contentPattern, 'i') : null;
+        // Collect all matching results first (for accurate total count)
+        const allMatches = [];
+        for (const info of stateInfos) {
+            const data = store.getStateJson(info.id);
+            if (data === null)
+                continue;
+            const content = JSON.stringify(data);
+            // If pattern specified, filter by it
+            if (pattern && !pattern.test(content))
+                continue;
+            allMatches.push({ stateId: info.id, content });
+        }
+        // Apply pagination
+        const paged = allMatches.slice(offset, offset + limit);
+        const results = paged.map(({ stateId, content }) => ({
+            stateId,
+            preview: content.length > previewLength ? content.slice(0, previewLength) + '...' : content,
+        }));
+        return {
+            results,
+            total: allMatches.length,
+            hasMore: offset + limit < allMatches.length,
+        };
+    }
+    async cmdStoreInspect(params) {
+        if (!params.stateId) {
+            throw new Error('stateId is required');
+        }
+        const store = this.framework.getStore();
+        const data = store.getStateJson(params.stateId);
+        return { data };
+    }
+    // ==========================================================================
+    // Inference Log Commands
+    // ==========================================================================
+    async cmdInferenceTail(params) {
+        const entries = this.framework.tailInferenceLogs(params?.count ?? 10, params?.agentName);
+        return { entries };
+    }
+    async cmdInferenceInspect(params) {
+        if (params.sequence === undefined || params.sequence === null) {
+            throw new Error('sequence is required');
+        }
+        const entry = this.framework.getInferenceLog(params.sequence);
+        if (!entry) {
+            throw new Error(`Inference log not found: ${params.sequence}`);
+        }
+        return { entry };
+    }
+    async cmdInferenceSearch(params) {
+        const result = this.framework.queryInferenceLogs({
+            agentName: params?.agentName,
+            limit: params?.limit,
+            offset: params?.offset,
+            pattern: params?.pattern,
+            errorsOnly: params?.errorsOnly,
+        });
+        return result;
+    }
+    // ==========================================================================
+    // Event Log Commands
+    // ==========================================================================
+    async cmdEventsTail(params) {
+        const entries = this.framework.tailProcessLogs(params?.count ?? 10, params?.eventType);
+        return { entries };
+    }
+    async cmdEventsInspect(params) {
+        if (params.sequence === undefined || params.sequence === null) {
+            throw new Error('sequence is required');
+        }
+        const entry = this.framework.getProcessLog(params.sequence);
+        if (!entry) {
+            throw new Error(`Process log not found: ${params.sequence}`);
+        }
+        return { entry };
+    }
+    async cmdEventsSearch(params) {
+        const result = this.framework.queryProcessLogs({
+            eventType: params?.eventType,
+            moduleName: params?.moduleName,
+            limit: params?.limit,
+            offset: params?.offset,
+            pattern: params?.pattern,
+        });
+        return result;
+    }
+    async cmdEventsSubscribe(params) {
+        const types = params?.types ?? ['*'];
+        const limit = params?.limit ?? 100;
+        // Get historical events from the process log
+        const processEntries = this.framework.tailProcessLogs(limit);
+        // Convert ProcessLogEntry to PersistedEvent format
+        const history = processEntries.map((item) => {
+            const { sequence, entry } = item;
+            const event = entry.processEvent;
+            const timestamp = entry.timestamp;
+            // Extract agent/module info from event if available
+            const agentName = event.agentName;
+            const moduleName = event.moduleName;
+            return {
+                id: `evt-${sequence}`,
+                sequence,
+                timestamp,
+                type: event?.type ?? 'unknown',
+                payload: event,
+                source: 'chronicle',
+                agentName,
+                moduleName,
+            };
+        });
+        // Filter by types if not wildcard
+        const filteredHistory = types.includes('*')
+            ? history
+            : history.filter((evt) => types.some((pattern) => matchEventType(pattern, evt.type)));
+        return {
+            subscribed: types,
+            history: filteredHistory,
+        };
+    }
+    // ==========================================================================
+    // HTTP Handling (optional REST endpoints)
+    // ==========================================================================
+    handleHttpRequest(req, res) {
+        // CORS headers
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        const url = new URL(req.url ?? '/', `http://${req.headers.host}`);
+        // Health check
+        if (url.pathname === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok', branch: this.currentBranch }));
+            return;
+        }
+        // Status
+        if (url.pathname === '/status') {
+            const agents = this.framework.getAllAgents();
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                branch: this.currentBranch,
+                agents: agents.map((a) => ({ name: a.name, status: a.state.status })),
+                clients: this.clients.size,
+                queueDepth: this.framework.getQueueDepth(),
+            }));
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Not found' }));
+    }
+    // ==========================================================================
+    // Subscription Commands
+    // ==========================================================================
+    async cmdStoreSubscribe(ws, params) {
+        const store = this.framework.getStore();
+        // Build subscription config
+        const config = {};
+        if (params?.bufferSize !== undefined) {
+            config.bufferSize = params.bufferSize;
+        }
+        if (params?.maxSnapshotBytes !== undefined) {
+            config.maxSnapshotBytes = params.maxSnapshotBytes;
+        }
+        if (params?.fromSequence !== undefined) {
+            config.fromSequence = params.fromSequence;
+        }
+        if (params?.filter) {
+            config.filter = {
+                recordTypes: params.filter.recordTypes,
+                branch: params.filter.branch,
+                stateIds: params.filter.stateIds,
+                includeRecords: params.filter.includeRecords ?? false,
+                includeStateChanges: params.filter.includeStateChanges ?? false,
+                includeBranchEvents: params.filter.includeBranchEvents ?? false,
+            };
+        }
+        // Create subscription
+        const subscriptionId = store.subscribe(config);
+        // Track this subscription for the client
+        if (!this.clientSubscriptions.has(ws)) {
+            this.clientSubscriptions.set(ws, new Set());
+        }
+        this.clientSubscriptions.get(ws).add(subscriptionId);
+        // If fromSequence is set, perform catch-up
+        if (params?.fromSequence !== undefined) {
+            store.catchUpSubscription(subscriptionId);
+        }
+        else {
+            // Mark as caught up immediately for live-only subscriptions
+            // The store will send the CaughtUp event
+            store.catchUpSubscription(subscriptionId);
+        }
+        return { subscriptionId };
+    }
+    async cmdStoreUnsubscribe(ws, params) {
+        if (!params.subscriptionId) {
+            throw new Error('subscriptionId is required');
+        }
+        const store = this.framework.getStore();
+        // Remove from client tracking
+        const clientSubs = this.clientSubscriptions.get(ws);
+        if (clientSubs) {
+            clientSubs.delete(params.subscriptionId);
+        }
+        // Unsubscribe from store
+        store.unsubscribe(params.subscriptionId);
+        return { success: true };
+    }
+    // ==========================================================================
+    // Subscription Helpers
+    // ==========================================================================
+    /**
+     * Cleanup all subscriptions for a disconnected client.
+     */
+    cleanupClientSubscriptions(ws) {
+        const subscriptionIds = this.clientSubscriptions.get(ws);
+        if (!subscriptionIds)
+            return;
+        const store = this.framework.getStore();
+        for (const subId of subscriptionIds) {
+            store.unsubscribe(subId);
+        }
+        this.clientSubscriptions.delete(ws);
+    }
+    /**
+     * Poll all active subscriptions and push events to clients.
+     */
+    pollSubscriptions() {
+        const store = this.framework.getStore();
+        for (const [ws, subscriptionIds] of this.clientSubscriptions) {
+            if (ws.readyState !== WebSocket.OPEN)
+                continue;
+            for (const subId of subscriptionIds) {
+                // Poll events from this subscription (non-blocking)
+                let event = store.pollSubscription(subId);
+                let eventCount = 0;
+                const maxEventsPerPoll = 100; // Prevent blocking too long
+                while (event && eventCount < maxEventsPerPoll) {
+                    // Parse the event data and send to client
+                    try {
+                        const eventData = JSON.parse(event.data);
+                        const eventType = `store:${event.eventType}`;
+                        this.sendEvent(ws, eventType, {
+                            subscriptionId: subId,
+                            ...eventData,
+                        });
+                    }
+                    catch (error) {
+                        console.error('Failed to parse subscription event:', error);
+                    }
+                    // Check for more events
+                    event = store.pollSubscription(subId);
+                    eventCount++;
+                }
+            }
+        }
+    }
+}
+/**
+ * Check if an event type matches a pattern.
+ * Supports wildcards like 'inference:*' or exact matches.
+ */
+function matchEventType(pattern, eventType) {
+    if (pattern === '*')
+        return true;
+    if (pattern.endsWith(':*')) {
+        const prefix = pattern.slice(0, -1);
+        return eventType.startsWith(prefix);
+    }
+    return pattern === eventType;
+}
+//# sourceMappingURL=server.js.map