reeboot 1.0.0

package/dist/scheduler.js

@@ -0,0 +1,143 @@
+/**
+ * Scheduler
+ *
+ * Loads enabled tasks from the SQLite `tasks` table on startup,
+ * registers node-cron jobs, and dispatches prompts to the orchestrator
+ * when jobs fire. Updates `last_run` after each execution.
+ */
+import * as cron from 'node-cron';
+import { nanoid } from 'nanoid';
+// ─── Scheduler ────────────────────────────────────────────────────────────────
+export class Scheduler {
+    _db;
+    _orchestrator;
+    _jobs = new Map();
+    constructor(db, orchestrator) {
+        this._db = db;
+        this._orchestrator = orchestrator;
+    }
+    async start() {
+        // Load all enabled tasks and register cron jobs
+        const tasks = this._db
+            .prepare('SELECT * FROM tasks WHERE enabled = 1')
+            .all();
+        for (const task of tasks) {
+            this.registerJob({
+                id: task.id,
+                contextId: task.context_id,
+                schedule: task.schedule,
+                prompt: task.prompt,
+            });
+        }
+    }
+    registerJob(task) {
+        // Cancel existing job for this task if any
+        const existing = this._jobs.get(task.id);
+        if (existing) {
+            existing.stop();
+        }
+        const job = cron.schedule(task.schedule, async () => {
+            try {
+                await this._orchestrator.handleScheduledTask({
+                    taskId: task.id,
+                    contextId: task.contextId,
+                    prompt: task.prompt,
+                });
+            }
+            catch (err) {
+                console.error(`[Scheduler] Task ${task.id} failed: ${err}`);
+            }
+            finally {
+                // Update last_run
+                this._db
+                    .prepare("UPDATE tasks SET last_run = datetime('now') WHERE id = ?")
+                    .run(task.id);
+            }
+        });
+        this._jobs.set(task.id, job);
+    }
+    cancelJob(taskId) {
+        const job = this._jobs.get(taskId);
+        if (job) {
+            job.stop();
+            this._jobs.delete(taskId);
+        }
+    }
+    stop() {
+        for (const [, job] of this._jobs) {
+            job.stop();
+        }
+        this._jobs.clear();
+    }
+}
+export function createSchedulerTools(db, scheduler) {
+    return {
+        async schedule_task(params) {
+            // Validate cron expression
+            if (!cron.validate(params.schedule)) {
+                return {
+                    content: [{ type: 'text', text: `Invalid cron expression: ${params.schedule}` }],
+                    details: {},
+                    isError: true,
+                };
+            }
+            const contextId = params.contextId ?? 'main';
+            const id = nanoid();
+            try {
+                db.prepare('INSERT INTO tasks (id, context_id, schedule, prompt, enabled) VALUES (?, ?, ?, ?, 1)').run(id, contextId, params.schedule, params.prompt);
+                scheduler.registerJob({
+                    id,
+                    contextId,
+                    schedule: params.schedule,
+                    prompt: params.prompt,
+                });
+                return {
+                    content: [{ type: 'text', text: `Scheduled task created (id: ${id})` }],
+                    details: { id, schedule: params.schedule, contextId },
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `Failed to schedule task: ${err.message}` }],
+                    details: {},
+                    isError: true,
+                };
+            }
+        },
+        async list_tasks(_params) {
+            const tasks = db
+                .prepare('SELECT id, context_id, schedule, prompt, enabled, last_run FROM tasks')
+                .all();
+            if (tasks.length === 0) {
+                return {
+                    content: [{ type: 'text', text: 'No scheduled tasks.' }],
+                    details: { tasks: [] },
+                };
+            }
+            const lines = tasks.map((t) => `[${t.id}] ${t.schedule} → ${t.prompt} (context: ${t.context_id}, enabled: ${t.enabled ? 'yes' : 'no'}, last_run: ${t.last_run ?? 'never'})`);
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }],
+                details: { tasks },
+            };
+        },
+        async cancel_task(params) {
+            const task = db
+                .prepare('SELECT id FROM tasks WHERE id = ?')
+                .get(params.task_id);
+            if (!task) {
+                return {
+                    content: [{ type: 'text', text: `Task not found: ${params.task_id}` }],
+                    details: {},
+                    isError: true,
+                };
+            }
+            db.prepare('DELETE FROM tasks WHERE id = ?').run(params.task_id);
+            scheduler.cancelJob(params.task_id);
+            return {
+                content: [{ type: 'text', text: `Cancelled task ${params.task_id}` }],
+                details: { taskId: params.task_id },
+            };
+        },
+    };
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../src/scheduler.ts"],"names":[],"mappings":"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"}

package/dist/server.d.ts

@@ -0,0 +1,18 @@
+import { FastifyInstance } from 'fastify';
+import type Database from 'better-sqlite3';
+export interface ServerOptions {
+    port?: number;
+    host?: string;
+    logLevel?: string;
+    /** Injected DB for testing (otherwise uses getDb() singleton) */
+    db?: Database.Database;
+    /** Override ~/.reeboot directory for testing */
+    reebotDir?: string;
+    /** Auth token (if set, non-loopback WS connections must provide it) */
+    token?: string;
+    /** App config for runner creation */
+    config?: import('./config.js').Config;
+}
+export declare function startServer(opts?: ServerOptions): Promise<FastifyInstance>;
+export declare function stopServer(): Promise<void>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAgB,EAAE,eAAe,EAAkB,MAAM,SAAS,CAAC;AAMnE,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAmC3C,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,EAAE,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC;IACvB,gDAAgD;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,MAAM,CAAC,EAAE,OAAO,aAAa,EAAE,MAAM,CAAC;CACvC;AAoCD,wBAAsB,WAAW,CAAC,IAAI,GAAE,aAAkB,GAAG,OAAO,CAAC,eAAe,CAAC,CA+dpF;AAID,wBAAsB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAmChD"}

package/dist/server.js

@@ -0,0 +1,489 @@
+import Fastify from 'fastify';
+import fastifyWebsocket from '@fastify/websocket';
+import fastifyStatic from '@fastify/static';
+import { readFileSync } from 'fs';
+import { resolve, dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { createRunner } from './agent-runner/index.js';
+import { listContexts, createContext, getContextById, listSessions, initContextWorkspace, createContextsTable, } from './context.js';
+import { nanoid } from 'nanoid';
+import { homedir } from 'os';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Read version from package.json
+function getVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf-8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+const startTime = Date.now();
+// ─── Singleton ───────────────────────────────────────────────────────────────
+let _server = null;
+// Active runners: contextId → AgentRunner
+const _activeRunners = new Map();
+// Channel adapters (set during startServer)
+let _channelAdapters = new Map();
+// Orchestrator (set during startServer)
+let _orchestrator = null;
+// Scheduler (set during startServer)
+let _scheduler = null;
+// Credential proxy (set during startServer)
+let _credProxy = null;
+// ─── Auth helper ─────────────────────────────────────────────────────────────
+function isLoopback(ip) {
+    return ip === '127.0.0.1' || ip === '::1' || ip === 'localhost';
+}
+function extractToken(req) {
+    const authHeader = req.headers['authorization'];
+    if (authHeader?.startsWith('Bearer '))
+        return authHeader.slice(7);
+    const url = new URL(req.url, 'http://localhost');
+    return url.searchParams.get('token') ?? undefined;
+}
+// ─── startServer ─────────────────────────────────────────────────────────────
+export async function startServer(opts = {}) {
+    const port = opts.port ?? 3000;
+    const host = opts.host ?? '127.0.0.1';
+    const logLevel = opts.logLevel ?? 'info';
+    const reebotDir = opts.reebotDir ?? join(homedir(), '.reeboot');
+    const serverToken = opts.token;
+    const isDev = process.env.NODE_ENV !== 'production';
+    const logger = logLevel === 'silent'
+        ? false
+        : {
+            level: logLevel,
+            ...(isDev ? { transport: { target: 'pino-pretty', options: { colorize: true } } } : {}),
+        };
+    const server = Fastify({ logger });
+    // Register WebSocket plugin
+    await server.register(fastifyWebsocket);
+    // Register static file serving for webchat
+    const webchatDir = resolve(__dirname, '../webchat');
+    try {
+        await server.register(fastifyStatic, {
+            root: webchatDir,
+            prefix: '/',
+            decorateReply: false,
+        });
+    }
+    catch {
+        // webchat dir may not exist in test environments — that's OK
+    }
+    // Get or set up the DB
+    let db;
+    if (opts.db) {
+        db = opts.db;
+        createContextsTable(db);
+        // Ensure main context exists
+        if (!getContextById(db, 'main')) {
+            createContext(db, { id: 'main', name: 'main', modelProvider: '', modelId: '' });
+        }
+    }
+    else {
+        const { openDatabase } = await import('./db/index.js');
+        db = openDatabase();
+        // Ensure main context exists
+        if (!getContextById(db, 'main')) {
+            createContext(db, { id: 'main', name: 'main', modelProvider: '', modelId: '' });
+        }
+    }
+    // Ensure context workspace for "main"
+    await initContextWorkspace('main', reebotDir);
+    // ── Channel & Orchestrator init ───────────────────────────────────────────
+    const appConfig = opts.config;
+    if (appConfig) {
+        try {
+            // Import built-in adapters so they self-register
+            await import('./channels/web.js');
+            await import('./channels/whatsapp.js');
+            await import('./channels/signal.js');
+            const { globalRegistry } = await import('./channels/registry.js');
+            const { MessageBus } = await import('./channels/interface.js');
+            const { Orchestrator: OrchestratorClass } = await import('./orchestrator.js');
+            const bus = new MessageBus();
+            // Init channels from config
+            _channelAdapters = await globalRegistry.initChannels(appConfig, bus);
+            // Build runner map for orchestrator (main context)
+            const orchestratorRunners = new Map();
+            const contexts = listContexts(db);
+            for (const ctx of contexts) {
+                orchestratorRunners.set(ctx.id, createRunner({ id: ctx.id, workspacePath: join(reebotDir, 'contexts', ctx.id, 'workspace') }, appConfig));
+            }
+            _orchestrator = new OrchestratorClass(appConfig, bus, _channelAdapters, orchestratorRunners);
+            _orchestrator.start();
+            // ── Credential proxy init ──────────────────────────────────────────
+            if (appConfig.credentialProxy?.enabled) {
+                try {
+                    const { startProxy } = await import('./credential-proxy.js');
+                    const proxyServer = await startProxy(appConfig);
+                    if (proxyServer) {
+                        _credProxy = proxyServer;
+                        console.log('[server] Credential proxy started on 127.0.0.1:3001');
+                    }
+                }
+                catch (err) {
+                    console.error('[server] Credential proxy init failed:', err);
+                }
+            }
+            // ── Scheduler init (after orchestrator) ────────────────────────────
+            try {
+                const { Scheduler } = await import('./scheduler.js');
+                const { setGlobalScheduler } = await import('./scheduler-registry.js');
+                const schedulerOrchestrator = {
+                    handleScheduledTask: async (task) => {
+                        // Inject scheduled task as a message via the bus
+                        const { MessageBus: MB, createIncomingMessage } = await import('./channels/interface.js');
+                        bus.publish(createIncomingMessage({
+                            channelType: 'scheduler',
+                            peerId: 'scheduler',
+                            content: task.prompt,
+                            raw: { taskId: task.taskId },
+                        }));
+                    },
+                };
+                const schedulerInstance = new Scheduler(db, schedulerOrchestrator);
+                await schedulerInstance.start();
+                setGlobalScheduler(schedulerInstance);
+                _scheduler = schedulerInstance;
+                console.log('[server] Scheduler started');
+            }
+            catch (err) {
+                console.error('[server] Scheduler init failed:', err);
+            }
+        }
+        catch (err) {
+            console.error('[server] Channel/orchestrator init failed:', err);
+        }
+    }
+    // ── Routes ────────────────────────────────────────────────────────────────
+    // GET / — serve WebChat
+    server.get('/', async (req, reply) => {
+        const webchatPath = resolve(__dirname, '../webchat/index.html');
+        try {
+            const html = readFileSync(webchatPath, 'utf-8');
+            reply.type('text/html').send(html);
+        }
+        catch {
+            reply.status(404).send({ error: 'WebChat not found' });
+        }
+    });
+    // GET /api/health
+    server.get('/api/health', async (_req, _reply) => {
+        return {
+            status: 'ok',
+            uptime: Math.floor((Date.now() - startTime) / 1000),
+            version: getVersion(),
+        };
+    });
+    // GET /api/status
+    server.get('/api/status', async (_req, _reply) => {
+        return {
+            agent: { name: 'Reeboot', model: { provider: '', id: '' } },
+            channels: [],
+            uptime: Math.floor((Date.now() - startTime) / 1000),
+        };
+    });
+    // ── Channel REST API ──────────────────────────────────────────────────────
+    // GET /api/channels
+    server.get('/api/channels', async (_req, _reply) => {
+        const result = [];
+        for (const [type, adapter] of _channelAdapters) {
+            result.push({ type, status: adapter.status(), connectedAt: adapter.connectedAt() });
+        }
+        return result;
+    });
+    // POST /api/channels/:type/login
+    server.post('/api/channels/:type/login', async (req, reply) => {
+        const { type } = req.params;
+        const adapter = _channelAdapters.get(type);
+        if (!adapter) {
+            return reply.status(404).send({ error: `Unknown channel type: ${type}` });
+        }
+        // Start login flow asynchronously (QR appears in terminal)
+        adapter.start().catch((err) => console.error(`[channels] login error for ${type}:`, err));
+        return reply.status(202).send({ message: 'Login initiated. Check terminal for QR code.' });
+    });
+    // POST /api/channels/:type/logout
+    server.post('/api/channels/:type/logout', async (req, reply) => {
+        const { type } = req.params;
+        const adapter = _channelAdapters.get(type);
+        if (!adapter) {
+            return reply.status(404).send({ error: `Unknown channel type: ${type}` });
+        }
+        await adapter.stop();
+        return reply.status(200).send({ message: `${type} logged out.` });
+    });
+    // ── Reload & Restart ──────────────────────────────────────────────────────
+    // POST /api/reload — hot-reload extensions/skills on all runners
+    server.post('/api/reload', async (_req, reply) => {
+        if (!_orchestrator) {
+            return reply.status(503).send({ error: 'Orchestrator not running' });
+        }
+        const errors = [];
+        for (const [id, runner] of _orchestrator.runners) {
+            try {
+                await runner.reload();
+            }
+            catch (err) {
+                errors.push(`${id}: ${err.message}`);
+            }
+        }
+        if (errors.length > 0) {
+            return reply.status(500).send({ error: errors.join('; ') });
+        }
+        return { message: 'Extensions and skills reloaded.' };
+    });
+    // POST /api/restart — graceful shutdown, process supervisor restarts
+    server.post('/api/restart', async (_req, reply) => {
+        reply.status(200).send({ message: 'Restarting...' });
+        // Drain in-flight turns (timeout 30s)
+        const DRAIN_TIMEOUT_MS = 30_000;
+        const drainStart = Date.now();
+        // Stop orchestrator so no new messages are dispatched
+        if (_orchestrator) {
+            _orchestrator.stop();
+        }
+        // Wait for active runners (ws handler uses _activeRunners)
+        while (_activeRunners.size > 0 && Date.now() - drainStart < DRAIN_TIMEOUT_MS) {
+            await new Promise(r => setTimeout(r, 100));
+        }
+        // Stop channels and dispose orchestrator runners
+        for (const adapter of _channelAdapters.values()) {
+            try {
+                await adapter.stop();
+            }
+            catch { /* ignore */ }
+        }
+        if (_orchestrator) {
+            for (const runner of _orchestrator.runners.values()) {
+                try {
+                    await runner.dispose();
+                }
+                catch { /* ignore */ }
+            }
+            _orchestrator = null;
+        }
+        // Close server and exit — supervisor restarts
+        try {
+            await _server?.close();
+        }
+        catch { /* ignore */ }
+        process.exit(0);
+    });
+    // ── REST: Task API ────────────────────────────────────────────────────────
+    // GET /api/tasks
+    server.get('/api/tasks', async (_req, _reply) => {
+        const tasks = db
+            .prepare('SELECT id, context_id as contextId, schedule, prompt, enabled, last_run as lastRun, created_at as createdAt FROM tasks')
+            .all();
+        return tasks;
+    });
+    // POST /api/tasks
+    server.post('/api/tasks', async (req, reply) => {
+        const { contextId = 'main', schedule, prompt } = req.body ?? {};
+        if (!schedule || !prompt) {
+            return reply.status(400).send({ error: 'schedule and prompt are required' });
+        }
+        // Validate cron expression
+        const { validate: cronValidate } = await import('node-cron');
+        if (!cronValidate(schedule)) {
+            return reply.status(400).send({ error: 'Invalid cron expression' });
+        }
+        const { nanoid: nanoId } = await import('nanoid');
+        const id = nanoId();
+        db.prepare('INSERT INTO tasks (id, context_id, schedule, prompt, enabled) VALUES (?, ?, ?, ?, 1)').run(id, contextId, schedule, prompt);
+        // Register with scheduler if available
+        if (_scheduler) {
+            _scheduler.registerJob({ id, contextId, schedule, prompt });
+        }
+        const task = db
+            .prepare('SELECT id, context_id as contextId, schedule, prompt, enabled, last_run as lastRun FROM tasks WHERE id = ?')
+            .get(id);
+        return reply.status(201).send(task);
+    });
+    // DELETE /api/tasks/:id
+    server.delete('/api/tasks/:id', async (req, reply) => {
+        const { id } = req.params;
+        const task = db.prepare('SELECT id FROM tasks WHERE id = ?').get(id);
+        if (!task) {
+            return reply.status(404).send({ error: `Task not found: ${id}` });
+        }
+        db.prepare('DELETE FROM tasks WHERE id = ?').run(id);
+        if (_scheduler) {
+            _scheduler.cancelJob(id);
+        }
+        return reply.status(204).send();
+    });
+    // ── REST: Context API ─────────────────────────────────────────────────────
+    // GET /api/contexts
+    server.get('/api/contexts', async (_req, _reply) => {
+        return listContexts(db);
+    });
+    // POST /api/contexts
+    server.post('/api/contexts', async (req, reply) => {
+        const { name, model_provider, model_id } = req.body ?? {};
+        if (!name) {
+            return reply.status(400).send({ error: 'name is required' });
+        }
+        const ctx = createContext(db, {
+            name,
+            modelProvider: model_provider ?? '',
+            modelId: model_id ?? '',
+        });
+        await initContextWorkspace(ctx.id, reebotDir);
+        return reply.status(201).send(ctx);
+    });
+    // GET /api/contexts/:id/sessions
+    server.get('/api/contexts/:id/sessions', async (req, reply) => {
+        const ctx = getContextById(db, req.params.id);
+        if (!ctx) {
+            return reply.status(404).send({ error: 'Context not found' });
+        }
+        const sessions = await listSessions(req.params.id, reebotDir);
+        return sessions;
+    });
+    // ── WebSocket: /ws/chat/:contextId ───────────────────────────────────────
+    server.get('/ws/chat/:contextId', { websocket: true }, async (socket, req) => {
+        const { contextId } = req.params;
+        // Auth check for non-loopback connections
+        if (serverToken) {
+            const clientIp = req.socket.remoteAddress ?? '';
+            if (!isLoopback(clientIp)) {
+                const provided = extractToken(req);
+                if (provided !== serverToken) {
+                    socket.close(1008, 'Unauthorized');
+                    return;
+                }
+            }
+        }
+        // Validate context exists
+        const ctx = getContextById(db, contextId);
+        if (!ctx) {
+            socket.close(4004, 'Unknown context');
+            return;
+        }
+        // Generate session ID
+        const sessionId = nanoid();
+        // Send connected message
+        socket.send(JSON.stringify({ type: 'connected', contextId, sessionId }));
+        let activeRunId = null;
+        socket.on('message', async (rawData) => {
+            let msg;
+            try {
+                msg = JSON.parse(rawData.toString());
+            }
+            catch {
+                socket.send(JSON.stringify({ type: 'error', message: 'Invalid JSON' }));
+                return;
+            }
+            if (msg.type === 'cancel') {
+                const runner = _activeRunners.get(contextId);
+                if (runner) {
+                    runner.abort();
+                    socket.send(JSON.stringify({ type: 'cancelled', runId: activeRunId }));
+                    _activeRunners.delete(contextId);
+                    activeRunId = null;
+                }
+                return;
+            }
+            if (msg.type === 'message') {
+                // Check if a turn is already in-flight
+                if (_activeRunners.has(contextId)) {
+                    socket.send(JSON.stringify({
+                        type: 'error',
+                        message: 'Agent is busy. Cancel the current turn first.',
+                    }));
+                    return;
+                }
+                const runId = nanoid();
+                activeRunId = runId;
+                // Get or create runner
+                let runner;
+                try {
+                    const { defaultConfig } = await import('./config.js');
+                    const cfg = opts.config ?? defaultConfig;
+                    runner = createRunner({ id: contextId, workspacePath: join(reebotDir, 'contexts', contextId, 'workspace') }, cfg);
+                }
+                catch (err) {
+                    socket.send(JSON.stringify({ type: 'error', message: String(err.message) }));
+                    return;
+                }
+                _activeRunners.set(contextId, runner);
+                try {
+                    await runner.prompt(msg.content ?? '', (event) => {
+                        socket.send(JSON.stringify(event));
+                    });
+                }
+                catch (err) {
+                    if (err?.name !== 'AbortError') {
+                        socket.send(JSON.stringify({ type: 'error', message: String(err?.message ?? err) }));
+                    }
+                }
+                finally {
+                    _activeRunners.delete(contextId);
+                    activeRunId = null;
+                }
+            }
+        });
+        socket.on('close', () => {
+            // Abort runner if still active
+            const runner = _activeRunners.get(contextId);
+            if (runner) {
+                runner.abort();
+                _activeRunners.delete(contextId);
+            }
+        });
+    });
+    // Custom 404 handler
+    server.setNotFoundHandler((_req, reply) => {
+        reply.status(404).send({ error: 'Not found' });
+    });
+    await server.listen({ port, host });
+    _server = server;
+    return server;
+}
+// ─── stopServer ──────────────────────────────────────────────────────────────
+export async function stopServer() {
+    // Stop credential proxy
+    if (_credProxy) {
+        try {
+            await _credProxy.close();
+        }
+        catch { /* ignore */ }
+        _credProxy = null;
+    }
+    // Stop scheduler
+    if (_scheduler) {
+        _scheduler.stop();
+        _scheduler = null;
+    }
+    // Stop orchestrator
+    if (_orchestrator) {
+        _orchestrator.stop();
+        _orchestrator = null;
+    }
+    // Stop channel adapters
+    for (const adapter of _channelAdapters.values()) {
+        try {
+            await adapter.stop();
+        }
+        catch { /* ignore */ }
+    }
+    _channelAdapters.clear();
+    // Abort all active runners before closing
+    for (const runner of _activeRunners.values()) {
+        try {
+            runner.abort();
+        }
+        catch { /* ignore */ }
+    }
+    _activeRunners.clear();
+    if (_server) {
+        await _server.close();
+        _server = null;
+    }
+}
+//# sourceMappingURL=server.js.map