@cef-ai/cli 0.2.7 → 0.3.0

package/dist/commands/deploy/index.js

@@ -1,216 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { parse } from 'yaml';
-import dotenv from 'dotenv';
-import { loadConfig, loadEnv } from '../../lib/config.js';
-import { runDeploy, writeIdsBack } from './deploy.js';
-import { runStatus } from './status.js';
-import { runClone } from './clone.js';
-import { runDelete } from './delete.js';
-import { errorMessage } from '../../lib/utils.js';
-const DEPLOY_ENTITY_TYPES = ['engagement', 'agent', 'cubby', 'workspace', 'stream', 'deployment', 'raft'];
-function loadEnvFromDir(dir) {
-    const resolved = path.resolve(dir);
-    dotenv.config({ path: path.join(resolved, '.env') });
-    return loadEnv();
-}
-function printDeploySummary(results) {
-    const created = results.filter(r => r.action === 'created').length;
-    const updated = results.filter(r => r.action === 'updated').length;
-    const dryRun = results.filter(r => r.action === 'dry-run').length;
-    if (dryRun > 0) {
-        console.log(`\nDry-run complete. ${dryRun} operation(s) planned.`);
-        for (const r of results) {
-            console.log(`  [dry-run] ${r.entity}: ${r.name}`);
-        }
-        return;
-    }
-    console.log(`\nDeploy complete. ${created} created, ${updated} updated.`);
-    for (const r of results) {
-        const label = r.action === 'created' ? 'created' : 'updated';
-        console.log(`  [${label}] ${r.entity}: ${r.name}${r.id ? ` (${r.id})` : ''}`);
-    }
-}
-function statusIcon(status) {
-    if (status === 'up-to-date')
-        return 'ok';
-    return status.toUpperCase();
-}
-function printStatusSummary(results) {
-    console.log('');
-    for (const r of results) {
-        console.log(`  [${statusIcon(r.status)}] ${r.entity}: ${r.name}${r.id ? ` (${r.id})` : ''}`);
-        if (r.tasks) {
-            for (const t of r.tasks) {
-                console.log(`         task: ${t.name} [${statusIcon(t.status)}]`);
-            }
-        }
-    }
-    const outdated = results.filter(r => r.status === 'outdated').length;
-    const notDeployed = results.filter(r => r.status === 'not-deployed').length;
-    console.log(`\n${outdated} outdated, ${notDeployed} not deployed.`);
-}
-function printCloneSummary(results) {
-    const written = results.filter(r => r.action === 'written').length;
-    const skipped = results.filter(r => r.action === 'skipped').length;
-    console.log(`\nClone complete. ${written} written, ${skipped} skipped.`);
-    for (const r of results) {
-        console.log(`  [${r.action}] ${r.entity}: ${r.name}${r.file ? ` → ${r.file}` : ''}`);
-    }
-}
-function printDeleteSummary(results) {
-    const deleted = results.filter(r => r.action === 'deleted').length;
-    const failed = results.filter(r => r.action === 'failed').length;
-    const skipped = results.filter(r => r.action === 'skipped').length;
-    console.log(`\nDelete complete. ${deleted} deleted, ${failed} failed, ${skipped} skipped.`);
-    for (const r of results) {
-        const suffix = r.error ? ` (${r.error})` : '';
-        console.log(`  [${r.action}] ${r.entity}: ${r.name} (${r.id})${suffix}`);
-    }
-}
-async function handleDeploy(opts) {
-    let resolved;
-    try {
-        resolved = loadConfig(opts.config);
-    }
-    catch (err) {
-        console.error(`Config error: ${errorMessage(err)}`);
-        process.exit(1);
-    }
-    if (opts.dryRun) {
-        console.log(`Dry-run mode. Config: ${resolved.configPath}`);
-        console.log(`Agent service: ${resolved.config.agentServicePubKey}`);
-    }
-    else {
-        console.log(`Deploying to: ${resolved.env.orchestratorUrl}`);
-        console.log(`Agent service: ${resolved.config.agentServicePubKey}`);
-        if (opts.only)
-            console.log(`Scope: --only ${opts.only}`);
-    }
-    try {
-        const results = await runDeploy(resolved, { dryRun: opts.dryRun, only: opts.only });
-        printDeploySummary(results);
-    }
-    catch (err) {
-        if (!opts.dryRun) {
-            try {
-                writeIdsBack(resolved.configPath, resolved.config);
-            }
-            catch (writeErr) {
-                console.error(`Warning: failed to save partial IDs: ${errorMessage(writeErr)}`);
-            }
-        }
-        console.error(`Deploy failed: ${errorMessage(err)}`);
-        process.exit(1);
-    }
-}
-async function handleStatus(opts) {
-    let resolved;
-    try {
-        resolved = loadConfig(opts.config);
-    }
-    catch (err) {
-        console.error(`Config error: ${errorMessage(err)}`);
-        process.exit(1);
-    }
-    console.log(`Checking status: ${resolved.env.orchestratorUrl}`);
-    console.log(`Agent service: ${resolved.config.agentServicePubKey}`);
-    try {
-        const results = await runStatus(resolved);
-        printStatusSummary(results);
-    }
-    catch (err) {
-        console.error(`Status failed: ${errorMessage(err)}`);
-        process.exit(1);
-    }
-}
-async function handleClone(opts) {
-    const dir = opts.outputDir ?? path.dirname(path.resolve(opts.config));
-    const resolvedOutputDir = path.resolve(dir);
-    try {
-        const env = loadEnvFromDir(resolvedOutputDir);
-        let agentServicePubKey = opts.pubkey;
-        if (!agentServicePubKey) {
-            const absConfigPath = path.resolve(opts.config);
-            if (fs.existsSync(absConfigPath)) {
-                const raw = fs.readFileSync(absConfigPath, 'utf8');
-                const parsed = parse(raw);
-                agentServicePubKey = parsed?.agentServicePubKey;
-            }
-        }
-        if (!agentServicePubKey) {
-            console.error('No agentServicePubKey found. Provide --pubkey or ensure cef.config.yaml exists.');
-            process.exit(1);
-        }
-        console.log(`Cloning agent service: ${agentServicePubKey}`);
-        console.log(`Output: ${resolvedOutputDir}`);
-        const results = await runClone(env, {
-            pubkey: agentServicePubKey,
-            outputDir: resolvedOutputDir,
-            force: opts.force ?? false,
-        });
-        printCloneSummary(results);
-    }
-    catch (err) {
-        console.error(`Clone failed: ${errorMessage(err)}`);
-        process.exit(1);
-    }
-}
-async function handleDelete(opts) {
-    let resolved;
-    try {
-        resolved = loadConfig(opts.config);
-    }
-    catch (err) {
-        console.error(`Config error: ${errorMessage(err)}`);
-        process.exit(1);
-    }
-    console.log(`Deleting from: ${resolved.env.orchestratorUrl}`);
-    console.log(`Agent service: ${resolved.config.agentServicePubKey}`);
-    if (opts.only)
-        console.log(`Scope: --only ${opts.only}`);
-    try {
-        const results = await runDelete(resolved, { only: opts.only, force: opts.force });
-        printDeleteSummary(results);
-    }
-    catch (err) {
-        console.error(`Delete failed: ${errorMessage(err)}`);
-        process.exit(1);
-    }
-}
-export function registerDeployCommands(program) {
-    const types = DEPLOY_ENTITY_TYPES.join(', ');
-    const deploy = program
-        .command('deploy', { isDefault: true })
-        .description('Sync cef.config.yaml to the orchestrator')
-        .option('--config <path>', 'Config file path', './cef.config.yaml')
-        .option('--dry-run', 'Show planned operations without calling API')
-        .option('--only <type>', `Sync only one entity type (${types})`)
-        .action(async (opts) => {
-        if (opts.only && !DEPLOY_ENTITY_TYPES.includes(opts.only)) {
-            console.error(`Invalid --only value: "${opts.only}". Must be one of: ${types}`);
-            process.exit(1);
-        }
-        await handleDeploy(opts);
-    });
-    deploy
-        .command('status')
-        .description('Compare local config with deployed state')
-        .option('--config <path>', 'Config file path', './cef.config.yaml')
-        .action(handleStatus);
-    deploy
-        .command('clone')
-        .description('Download an existing agent service')
-        .option('--config <path>', 'Config file path', './cef.config.yaml')
-        .option('--pubkey <key>', 'Agent service public key (64-char hex)')
-        .option('--output-dir <dir>', 'Directory to write files into')
-        .option('--force', 'Overwrite existing files')
-        .action(handleClone);
-    deploy
-        .command('delete')
-        .description('Delete deployed entities in reverse dependency order')
-        .option('--config <path>', 'Config file path', './cef.config.yaml')
-        .option('--only <type>', `Delete only one entity type (${types})`)
-        .option('--force', 'Skip confirmation prompt')
-        .action(handleDelete);
-}

package/dist/commands/deploy/status.d.ts

@@ -1,14 +0,0 @@
-import type { ResolvedConfig } from '../../lib/types.js';
-export type StatusValue = 'up-to-date' | 'outdated' | 'not-deployed' | 'not-found';
-export interface TaskStatus {
-    name: string;
-    status: StatusValue;
-}
-export interface StatusResult {
-    entity: 'engagement' | 'agent';
-    name: string;
-    id?: string;
-    status: StatusValue;
-    tasks?: TaskStatus[];
-}
-export declare function runStatus(resolved: ResolvedConfig): Promise<StatusResult[]>;

package/dist/commands/deploy/status.js

@@ -1,61 +0,0 @@
-import { createApiClient } from '../../lib/api.js';
-export async function runStatus(resolved) {
-    const { config, env } = resolved;
-    const api = createApiClient(env, config.agentServicePubKey);
-    const results = [];
-    const [remoteEngagementsRes, remoteAgentsRes] = await Promise.all([
-        api.getEngagements(),
-        api.getAgents(),
-    ]);
-    const remoteEngById = new Map(remoteEngagementsRes.data.map(e => [e.engagementId, e]));
-    // Includes concierge agents (isConcierge: true) which hold engagement tsCode
-    const remoteAgentById = new Map(remoteAgentsRes.data.map(a => [a.agentId, a]));
-    for (const eng of config.engagements ?? []) {
-        const localCode = eng.tsCode ?? '';
-        if (!eng.engagementId) {
-            results.push({ entity: 'engagement', name: eng.name, status: 'not-deployed' });
-            continue;
-        }
-        const remoteEng = remoteEngById.get(eng.engagementId);
-        if (!remoteEng) {
-            results.push({ entity: 'engagement', name: eng.name, id: eng.engagementId, status: 'not-found' });
-            continue;
-        }
-        // Resolve tsCode via concierge agent's first task
-        const conciergeAgent = remoteAgentById.get(remoteEng.conciergeAgentId);
-        const remoteCode = conciergeAgent?.tasks[0]?.tsCode ?? '';
-        results.push({
-            entity: 'engagement',
-            name: eng.name,
-            id: eng.engagementId,
-            status: localCode === remoteCode ? 'up-to-date' : 'outdated',
-        });
-    }
-    for (const agent of config.agents ?? []) {
-        if (!agent.agentId) {
-            results.push({ entity: 'agent', name: agent.name, status: 'not-deployed' });
-            continue;
-        }
-        const remote = remoteAgentById.get(agent.agentId);
-        if (!remote) {
-            results.push({ entity: 'agent', name: agent.name, id: agent.agentId, status: 'not-found' });
-            continue;
-        }
-        const remoteTaskByName = new Map(remote.tasks.map(t => [t.name, t]));
-        const taskStatuses = agent.tasks.map(task => {
-            const localCode = task.tsCode ?? '';
-            const remoteTask = remoteTaskByName.get(task.name);
-            if (!remoteTask)
-                return { name: task.name, status: 'not-found' };
-            return {
-                name: task.name,
-                status: localCode === remoteTask.tsCode ? 'up-to-date' : 'outdated',
-            };
-        });
-        const agentStatus = taskStatuses.some(t => t.status === 'outdated' || t.status === 'not-found')
-            ? 'outdated'
-            : 'up-to-date';
-        results.push({ entity: 'agent', name: agent.name, id: agent.agentId, status: agentStatus, tasks: taskStatuses });
-    }
-    return results;
-}

package/dist/commands/dev/index.d.ts

@@ -1,2 +0,0 @@
-import { Command } from 'commander';
-export declare function registerDevCommands(program: Command): void;

package/dist/commands/dev/index.js

@@ -1,134 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { loadConfigForDev } from '../../lib/config.js';
-import { LocalRuntime } from '../../lib/runtime/index.js';
-import { createDevServer } from './server.js';
-export function registerDevCommands(program) {
-    program
-        .command('dev')
-        .description('Start local development server for agent testing')
-        .option('--config <path>', 'Config file path', './cef.config.yaml')
-        .option('--port <port>', 'Server port', '8787')
-        .option('--host <host>', 'Server host', 'localhost')
-        .option('--persist', 'Keep .cef-dev/ data after server stops (default: cleared on shutdown)', false)
-        .action(handleDev);
-}
-async function handleDev(opts) {
-    const port = parseInt(opts.port, 10);
-    const host = opts.host;
-    // Load config (no auth required)
-    let resolved;
-    try {
-        resolved = loadConfigForDev(opts.config);
-    }
-    catch (err) {
-        console.error(chalk.red(`Failed to load config: ${err.message}`));
-        process.exit(1);
-    }
-    const { config, configDir } = resolved;
-    // Data directory for local state (cleared on shutdown unless --persist)
-    const cefDevDir = path.join(configDir, '.cef-dev');
-    const dataDir = path.join(cefDevDir, 'cubbies');
-    fs.mkdirSync(dataDir, { recursive: true });
-    // Initialize runtime
-    const runtime = new LocalRuntime(dataDir);
-    await runtime.initialize(config);
-    // Start HTTP server
-    const server = createDevServer(runtime, { port, host });
-    try {
-        await server.start();
-    }
-    catch (err) {
-        console.error(chalk.red(err.message));
-        runtime.shutdown();
-        process.exit(1);
-    }
-    // Summary
-    const topology = runtime.getTopology();
-    console.log('');
-    console.log(chalk.bold('CEF Dev Server'));
-    console.log(chalk.gray('─'.repeat(40)));
-    console.log(`  Engagements: ${chalk.cyan(String(topology.engagements.length))}`);
-    console.log(`  Agents:      ${chalk.cyan(String(topology.agents.length))}`);
-    console.log(`  Cubbies:     ${chalk.cyan(String(topology.cubbies.length))}`);
-    console.log('');
-    console.log(`  ${chalk.green(`http://${host}:${port}`)}`);
-    console.log('');
-    console.log(chalk.gray('Endpoints:'));
-    console.log(chalk.gray('  POST /api/trigger              Trigger engagement'));
-    console.log(chalk.gray('  POST /api/agents/:alias/:task  Call agent task'));
-    console.log(chalk.gray('  POST /api/streams/:id/push     Push stream packet'));
-    console.log(chalk.gray('  POST /api/cubbies/:alias/query SQL query'));
-    console.log(chalk.gray('  GET  /api/topology             View topology'));
-    console.log(chalk.gray('  WS   /ws                       Real-time logs'));
-    console.log('');
-    console.log(chalk.gray('Watching for file changes. Press Ctrl+C to stop.'));
-    console.log('');
-    // Stream runtime logs to console
-    runtime.logEmitter.on('log', (entry) => {
-        const prefix = entry.agentAlias
-            ? chalk.blue(`[${entry.agentAlias}${entry.taskAlias ? '.' + entry.taskAlias : ''}]`)
-            : chalk.gray('[engagement]');
-        const level = entry.level === 'error' ? chalk.red(entry.level)
-            : entry.level === 'warn' ? chalk.yellow(entry.level)
-                : chalk.gray(entry.level);
-        const args = entry.args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
-        console.log(`${chalk.gray(new Date(entry.timestamp).toISOString().slice(11, 23))} ${level} ${prefix} ${args}`);
-    });
-    // File watcher
-    const watchedFiles = new Map();
-    for (const agent of config.agents ?? []) {
-        for (const task of agent.tasks) {
-            if (task._resolvedFilePath) {
-                watchedFiles.set(task._resolvedFilePath, `${agent.alias}/${task.alias}`);
-            }
-        }
-    }
-    for (const eng of config.engagements ?? []) {
-        if (eng._resolvedFilePath) {
-            watchedFiles.set(eng._resolvedFilePath, `engagement:${eng.name}`);
-        }
-    }
-    for (const [filePath, label] of watchedFiles) {
-        try {
-            fs.watch(filePath, () => {
-                try {
-                    const tsCode = fs.readFileSync(filePath, 'utf8');
-                    const parts = label.split('/');
-                    if (parts.length === 2 && parts[0] && parts[1]) {
-                        runtime.reloadFile(parts[0], parts[1], tsCode);
-                    }
-                    console.log(chalk.yellow(`[reload] ${path.relative(configDir, filePath)}`));
-                }
-                catch (err) {
-                    console.error(chalk.red(`Failed to reload ${filePath}: ${err.message}`));
-                }
-            });
-        }
-        catch {
-            // File watch not supported on all platforms for all paths
-        }
-    }
-    // Graceful shutdown with hard timeout
-    let shuttingDown = false;
-    const shutdown = async () => {
-        if (shuttingDown) {
-            process.exit(0);
-            return;
-        }
-        shuttingDown = true;
-        console.log(chalk.gray('\nShutting down...'));
-        runtime.shutdown();
-        if (!opts.persist && fs.existsSync(cefDevDir)) {
-            fs.rmSync(cefDevDir, { recursive: true, force: true });
-            console.log(chalk.gray('Cleared .cef-dev/'));
-        }
-        const hardExit = setTimeout(() => process.exit(0), 1000);
-        hardExit.unref();
-        await server.stop();
-        process.exit(0);
-    };
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
-}

package/dist/commands/dev/server.d.ts

@@ -1,14 +0,0 @@
-import http from 'http';
-import { type WebSocket } from 'ws';
-import type { LocalRuntime } from '../../lib/runtime/index.js';
-interface ServerOptions {
-    port: number;
-    host: string;
-}
-export declare function createDevServer(runtime: LocalRuntime, options: ServerOptions): {
-    start: () => Promise<void>;
-    stop: () => Promise<void>;
-    server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
-    wss: import("ws").Server<typeof WebSocket, typeof http.IncomingMessage>;
-};
-export {};

package/dist/commands/dev/server.js

@@ -1,195 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import http from 'http';
-import { WebSocketServer } from 'ws';
-const STATIC_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), 'static');
-const MIME_TYPES = {
-    '.html': 'text/html; charset=utf-8',
-    '.css': 'text/css; charset=utf-8',
-    '.js': 'application/javascript; charset=utf-8',
-};
-function loadStaticFiles() {
-    const files = new Map();
-    for (const name of fs.readdirSync(STATIC_DIR)) {
-        const ext = path.extname(name);
-        const contentType = MIME_TYPES[ext];
-        if (!contentType)
-            continue;
-        const content = fs.readFileSync(path.join(STATIC_DIR, name));
-        files.set('/' + name, { content, contentType });
-    }
-    // Alias "/" to "/index.html"
-    const index = files.get('/index.html');
-    if (index)
-        files.set('/', index);
-    return files;
-}
-export function createDevServer(runtime, options) {
-    const staticFiles = loadStaticFiles();
-    const wsClients = new Set();
-    // Stream logs and trace events to WebSocket clients
-    const broadcast = (msg) => {
-        for (const ws of wsClients) {
-            if (ws.readyState === ws.OPEN)
-                ws.send(msg);
-        }
-    };
-    runtime.logEmitter.on('log', (entry) => {
-        broadcast(JSON.stringify({ type: 'log', data: entry }));
-    });
-    runtime.logEmitter.on('trace', (event) => {
-        broadcast(JSON.stringify({ type: 'trace', data: event }));
-    });
-    const server = http.createServer(async (req, res) => {
-        // CORS headers for dev
-        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}`);
-        const pathname = url.pathname;
-        try {
-            // ─── API Routes ───────────────────────────────────────────────
-            if (req.method === 'GET' && pathname === '/api/topology') {
-                json(res, runtime.getTopology());
-                return;
-            }
-            if (req.method === 'GET' && pathname === '/api/executions') {
-                json(res, runtime.getLogs());
-                return;
-            }
-            if (req.method === 'POST' && pathname === '/api/trigger') {
-                const body = await readBody(req);
-                const { engagement, payload } = body;
-                if (!engagement) {
-                    json(res, { error: 'Missing "engagement" field' }, 400);
-                    return;
-                }
-                const handle = await runtime.startEngagement(engagement, payload ?? {});
-                json(res, { executionId: handle.executionId, started: true });
-                return;
-            }
-            {
-                let m;
-                if (req.method === 'POST' && (m = pathname.match(/^\/api\/streams\/([^/]+)\/push$/))) {
-                    const streamId = m[1];
-                    const body = await readBody(req);
-                    const packet = body.data ?? body;
-                    // Ensure payload is Uint8Array
-                    if (typeof packet.payload === 'string') {
-                        packet.payload = new TextEncoder().encode(packet.payload);
-                    }
-                    else if (Array.isArray(packet.payload)) {
-                        packet.payload = new Uint8Array(packet.payload);
-                    }
-                    else if (packet.payload && !ArrayBuffer.isView(packet.payload)) {
-                        packet.payload = new TextEncoder().encode(JSON.stringify(packet.payload));
-                    }
-                    if (!packet.sequenceNum)
-                        packet.sequenceNum = 0;
-                    runtime.pushToStream(streamId, packet);
-                    json(res, { pushed: true });
-                    return;
-                }
-                if (req.method === 'POST' && (m = pathname.match(/^\/api\/agents\/([^/]+)\/([^/]+)$/))) {
-                    const body = await readBody(req);
-                    const result = await runtime.callAgentTask(m[1], m[2], body.payload ?? body);
-                    json(res, result);
-                    return;
-                }
-                if (req.method === 'POST' && (m = pathname.match(/^\/api\/cubbies\/([^/]+)\/query$/))) {
-                    const body = await readBody(req);
-                    const result = await runtime.queryCubby(m[1], body.instanceId ?? 'default', body.sql, body.params ?? []);
-                    json(res, result);
-                    return;
-                }
-                if (req.method === 'POST' && (m = pathname.match(/^\/api\/cubbies\/([^/]+)\/exec$/))) {
-                    const body = await readBody(req);
-                    const result = await runtime.execCubby(m[1], body.instanceId ?? 'default', body.sql, body.params ?? []);
-                    json(res, result);
-                    return;
-                }
-                if (req.method === 'GET' && (m = pathname.match(/^\/api\/cubbies\/([^/]+)\/instances$/))) {
-                    json(res, { instances: runtime.listCubbyInstances(m[1]) });
-                    return;
-                }
-            }
-            // ─── Static files (Dev UI) ──────────────────────────────────
-            if (req.method === 'GET') {
-                const file = staticFiles.get(pathname);
-                if (file) {
-                    res.writeHead(200, { 'Content-Type': file.contentType });
-                    res.end(file.content);
-                    return;
-                }
-            }
-            // ─── 404 ────────────────────────────────────────────────────
-            json(res, { error: 'Not found' }, 404);
-        }
-        catch (err) {
-            json(res, { error: err.message }, 500);
-        }
-    });
-    // Track open sockets so we can destroy them on shutdown
-    const sockets = new Set();
-    server.on('connection', (socket) => {
-        sockets.add(socket);
-        socket.on('close', () => sockets.delete(socket));
-    });
-    // WebSocket server
-    const wss = new WebSocketServer({ server });
-    wss.on('connection', (ws) => {
-        wsClients.add(ws);
-        ws.on('close', () => wsClients.delete(ws));
-    });
-    return {
-        start: () => new Promise((resolve, reject) => {
-            server.on('error', (err) => {
-                if (err.code === 'EADDRINUSE') {
-                    reject(new Error(`Port ${options.port} is already in use. Stop the other process or use --port <number>.`));
-                }
-                else {
-                    reject(err);
-                }
-            });
-            server.listen(options.port, options.host, () => resolve());
-        }),
-        stop: () => new Promise((resolve) => {
-            for (const ws of wsClients)
-                ws.terminate();
-            wsClients.clear();
-            for (const socket of sockets)
-                socket.destroy();
-            sockets.clear();
-            wss.close();
-            server.close(() => resolve());
-        }),
-        server,
-        wss,
-    };
-}
-function json(res, data, status = 200) {
-    res.writeHead(status, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(data));
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function readBody(req) {
-    return new Promise((resolve, reject) => {
-        let body = '';
-        req.on('data', chunk => { body += chunk; });
-        req.on('end', () => {
-            try {
-                resolve(body ? JSON.parse(body) : {});
-            }
-            catch {
-                reject(new Error('Invalid JSON body'));
-            }
-        });
-        req.on('error', reject);
-    });
-}