@cef-ai/cli 0.2.1

package/dist/commands/deploy/index.js

@@ -0,0 +1,216 @@
+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 (0x...)')
+        .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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,61 @@
+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

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

package/dist/commands/dev/index.js

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,167 @@
+import http from 'http';
+import { WebSocketServer } from 'ws';
+import { getDevUiHtml } from './ui.js';
+export function createDevServer(runtime, options) {
+    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;
+                }
+            }
+            // ─── Dev UI ──────────────────────────────────────────────────
+            if (req.method === 'GET' && (pathname === '/' || pathname === '/index.html')) {
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(getDevUiHtml());
+                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);
+    });
+}

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

@@ -0,0 +1 @@
+export declare function getDevUiHtml(): string;