helix-assistant-cli 0.2.14 → 0.6.1

package/src/commands/subagents.ts

@@ -0,0 +1,150 @@
+import type { AgentClient } from '../client/agent-client';
+import { CYAN_BOLD, DIM, RED, YELLOW } from '../ui/colors';
+
+interface SubagentProfile {
+  profile_id: string;
+  name: string;
+}
+
+interface SubagentStatus {
+  profile_id?: string;
+  name?: string;
+  status?: string;
+  progress?: number;
+  current_action?: string;
+}
+
+function boundedText(value: unknown, maxLength: number): string {
+  if (typeof value !== 'string') return '';
+  const clean = value.replace(/[\r\n|]/g, ' ').trim();
+  return clean.length > maxLength ? `${clean.slice(0, maxLength - 3)}...` : clean;
+}
+
+function statusLabel(status?: string): string {
+  const normalized = status?.toLowerCase() || 'idle';
+  if (['running', 'active', 'in_progress'].includes(normalized)) return 'RUNNING';
+  if (['failed', 'error'].includes(normalized)) return 'FAILED';
+  if (['completed', 'done'].includes(normalized)) return 'DONE';
+  if (['cancelled', 'canceled'].includes(normalized)) return 'STOPPED';
+  return 'IDLE';
+}
+
+export function renderSubagentPanel(
+  profiles: SubagentProfile[],
+  statuses: SubagentStatus[],
+): string {
+  const statusByProfile = new Map<string, SubagentStatus>();
+  for (const status of statuses) {
+    if (status.profile_id) statusByProfile.set(status.profile_id, status);
+  }
+
+  const rows = profiles.map((profile) => {
+    const status = statusByProfile.get(profile.profile_id);
+    const profileId = boundedText(profile.profile_id, 22);
+    const name = boundedText(profile.name, 18);
+    const state = statusLabel(status?.status);
+    const progress = Number.isFinite(status?.progress) ? ` ${status?.progress}%` : '';
+    const action = boundedText(status?.current_action, 26);
+    return [
+      profileId.padEnd(22),
+      name.padEnd(18),
+      `${state}${progress}`,
+      action,
+    ];
+  });
+
+  const headings = ['PROFILE ID', 'NAME', 'STATE', 'CURRENT ACTION'];
+  const widths = [22, 18, 16, 26];
+  const border = `+${widths.map((width) => '-'.repeat(width + 2)).join('+')}+`;
+  const row = (values: string[]) =>
+    `| ${values.map((value, index) => value.padEnd(widths[index])).join(' | ')} |`;
+  const lines = [
+    border,
+    row(headings),
+    border,
+    ...(rows.length > 0
+      ? rows.map(row)
+      : [row(['No profiles', 'available', '', ''])]),
+    border,
+  ];
+  return lines.join('\n');
+}
+
+function asArray<T>(
+  value: unknown,
+  label: string,
+  isItem: (item: unknown) => item is T,
+): T[] {
+  if (!Array.isArray(value) || !value.every(isItem)) {
+    throw new Error(`Agent returned an invalid ${label} list.`);
+  }
+  return value;
+}
+
+function isSubagentProfile(value: unknown): value is SubagentProfile {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
+  const profile = value as Record<string, unknown>;
+  return typeof profile.profile_id === 'string'
+    && typeof profile.name === 'string';
+}
+
+function isSubagentStatus(value: unknown): value is SubagentStatus {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
+  const status = value as Record<string, unknown>;
+  return (status.profile_id === undefined || typeof status.profile_id === 'string')
+    && (status.status === undefined || typeof status.status === 'string')
+    && (status.progress === undefined || typeof status.progress === 'number')
+    && (status.current_action === undefined || typeof status.current_action === 'string');
+}
+
+export async function handleSubagentsCommand(
+  client: AgentClient,
+  args = '',
+): Promise<void> {
+  const trimmed = args.trim();
+  const chatMatch = trimmed.match(/^chat\s+(\S+)\s+([\s\S]+)$/i);
+  if (chatMatch) {
+    const [, profileId, message] = chatMatch;
+    try {
+      const result = await client.request<unknown>(
+        'CHAT_SUBAGENT',
+        { profile_id: profileId, message: message.trim() },
+        120000,
+      );
+      console.log('\n' + CYAN_BOLD(`  SUBAGENT ${profileId}`));
+      if (
+        result !== null
+        && typeof result === 'object'
+        && 'response' in result
+        && typeof result.response === 'string'
+      ) {
+        console.log(result.response);
+      } else {
+        console.log(JSON.stringify(result, null, 2));
+      }
+      console.log('');
+    } catch (error) {
+      console.log(RED(`  No se pudo contactar al subagente: ${(error as Error).message}\n`));
+    }
+    return;
+  }
+
+  if (trimmed && !/^list$/i.test(trimmed)) {
+    console.log(YELLOW('  Uso: /subagents [list] | /subagents chat <id> <mensaje>\n'));
+    return;
+  }
+
+  try {
+    const [profilesValue, statusesValue] = await Promise.all([
+      client.request<unknown[]>('GET_SUBAGENT_PROFILES'),
+      client.request<unknown[]>('GET_SUBAGENT_STATUS'),
+    ]);
+    const profiles = asArray(profilesValue, 'subagent profile', isSubagentProfile);
+    const statuses = asArray(statusesValue, 'subagent status', isSubagentStatus);
+    console.log(`\n${CYAN_BOLD('  HELIX SUBAGENTS')}`);
+    console.log(renderSubagentPanel(profiles, statuses));
+    console.log(DIM('  Chat: /subagents chat <profile_id> <mensaje>\n'));
+  } catch (error) {
+    console.log(RED(`  No se pudo cargar el panel de subagentes: ${(error as Error).message}\n`));
+  }
+}

package/src/config/mcp-defaults.ts

@@ -9,10 +9,19 @@ export interface McpDefaultDefinition {
 
 /** Catalog only: entries are never enabled or installed automatically. */
 export const MCP_DEFAULTS: McpDefaultDefinition[] = [
-  { id: 'filesystem', label: 'Archivos locales', purpose: 'Carpeta elegida por el usuario', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo rutas autorizadas' },
+  { id: 'filesystem', label: 'Archivos locales', purpose: 'Carpetas y archivos del equipo del usuario', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo rutas autorizadas' },
   { id: 'obsidian', label: 'Obsidian / Helix Vault', purpose: 'Leer y gestionar una bóveda concreta', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo la bóveda seleccionada' },
   { id: 'vscode', label: 'VS Code', purpose: 'Trabajar con el workspace seleccionado', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo el workspace seleccionado' },
-  { id: 'github', label: 'GitHub', purpose: 'Repositorios, issues y pull requests', transport: 'stdio', activation: 'oauth-opt-in', privacy: 'Requiere token u OAuth del usuario' },
-  { id: 'gmail', label: 'Gmail', purpose: 'Correo y búsqueda de mensajes', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere OAuth explícito del usuario' },
-  { id: 'notion', label: 'Notion', purpose: 'Páginas y bases de datos', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere integración autorizada' },
+  { id: 'cursor', label: 'Cursor', purpose: 'Proyectos y editor de código del usuario', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo el workspace autorizado' },
+  { id: 'github', label: 'GitHub', purpose: 'Repositorios, issues, pull requests y código', transport: 'stdio', activation: 'oauth-opt-in', privacy: 'Requiere token u OAuth del usuario' },
+  { id: 'linear', label: 'Linear', purpose: 'Issues, roadmap y trabajo del equipo', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere acceso autorizado del workspace' },
+  { id: 'gmail', label: 'Gmail', purpose: 'Correo, búsquedas y mensajes relevantes', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere OAuth explícito del usuario' },
+  { id: 'google-drive', label: 'Google Drive', purpose: 'Documentos y archivos compartidos', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere acceso autorizado a la cuenta' },
+  { id: 'notion', label: 'Notion', purpose: 'Páginas, bases de datos y conocimiento', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere integración autorizada' },
+  { id: 'chatgpt', label: 'ChatGPT', purpose: 'Acceso a tareas y contexto de chat del usuario', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere conexión autorizada del usuario' },
+  { id: 'claude-desktop', label: 'Claude Desktop', purpose: 'Contexto y trabajo en la app desktop de Claude', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo los recursos autorizados por el usuario' },
+  { id: 'word', label: 'Microsoft Word', purpose: 'Documentos y edición de texto', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo archivos autorizados' },
+  { id: 'excel', label: 'Microsoft Excel', purpose: 'Hojas de cálculo, análisis y tabulación', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo archivos autorizados' },
+  { id: 'powerpoint', label: 'Microsoft PowerPoint', purpose: 'Presentaciones y material visual', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo archivos autorizados' },
+  { id: 'antigravity', label: 'Antigravity', purpose: 'Workspace y flujos de automatización del usuario', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere conexión explícita del usuario' },
 ];

package/src/global.d.ts

@@ -0,0 +1,23 @@
+// Declaration shims for modules without bundled @types in this workspace.
+// These are minimal stubs to satisfy TypeScript when explicit "types" is set.
+
+declare module 'prompts' {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function prompts(questions: any | any[]): Promise<Record<string, any>>;
+  export = prompts;
+}
+
+declare module 'jpeg-js' {
+  interface RawImageData {
+    width: number;
+    height: number;
+    data: Buffer | Uint8Array;
+  }
+  interface DecodeResult extends RawImageData {
+    comments?: string[];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function decode(jpegData: Buffer | Uint8Array, opts?: Record<string, any>): DecodeResult;
+  function encode(rawImageData: RawImageData, quality?: number): { data: Buffer; width: number; height: number };
+  export { decode, encode };
+}

package/src/index.ts

@@ -32,6 +32,7 @@ import type { HelixSettings } from './client/types';
 import { handleShowApiKey } from './commands/apikey';
 import { ORANGE, CYAN, GREEN, RED, BOLD, DIM } from './ui/colors';
 import { getAsciiLogo } from './ui/banner';
+import packageJson from '../package.json';
 
 async function readStdin(): Promise<string> {
   if (process.stdin.isTTY) {
@@ -73,7 +74,7 @@ const program = new Command();
 program
   .name('helix')
   .description('HELIX - Interactive Terminal CLI for Windows AI Desktop Agent')
-  .version('0.2.14')
+  .version(packageJson.version)
   .option('-u, --ws-url <url>', 'URL del servidor WebSocket del agente', getWsUrl())
   .option('-t, --token <token>', 'Token de autenticación WebSocket de HELIX', getWsToken())
   .option('--plain', 'Desactivar formato enriquecido de Markdown y mostrar texto plano sin asteriscos')

package/src/ui/autocomplete.ts

@@ -14,12 +14,15 @@ export const SLASH_COMMANDS: CommandDefinition[] = [
   { command: '/skill', description: 'Listar o inspeccionar skills registradas', usage: '/skill [nombre]' },
   { command: '/mcp', description: 'Listar servidores MCP y sus herramientas', usage: '/mcp [defaults]' },
   { command: '/create-mcp', description: 'Registrar y configurar un nuevo servidor MCP' },
-  { command: '/browser', description: 'Ver estado del navegador web o abrir URLs', usage: '/browser [open <url>]' },
+  { command: '/browser', description: 'Ver estado, abrir URLs o alternar la vista ASCII', usage: '/browser [open <url>|live [on|off]]' },
+  { command: '/subagents', description: 'Ver el panel ASCII o chatear con un subagente', usage: '/subagents [list|chat <id> <mensaje>]' },
   { command: '/config-apikey', description: 'Configurador interactivo de API Keys (OpenAI, Anthropic, Gemini, etc.)' },
   { command: '/show-apikey', description: 'Ver estado y validez de las API Keys configuradas' },
   { command: '/microphone', description: 'Ver o alternar estado del micrófono', usage: '/microphone [enable|disable]' },
   { command: '/tasks', description: 'Ver tareas activas y recientes del agente' },
+  { command: '/model', description: 'Ver o cambiar el modelo activo (free/local/cloud)', usage: '/model [list|set <id>|effort <low|medium|high>]' },
   { command: '/models', description: 'Listar modelos disponibles de proveedores configurados' },
+  { command: '/memory', description: 'Ver estadísticas del harness de aprendizaje adaptativo', usage: '/memory [stats|rules|reset]' },
   { command: '/status', description: 'Mostrar resumen del estado del sistema' },
   { command: '/providers', description: 'Ver proveedores configurados y salud de sus claves' },
   { command: '/capabilities', description: 'Ver capacidades activas: sandbox, subagentes, voz y browser' },
@@ -116,7 +119,21 @@ export class Autocompleter {
       return [hits.length ? hits : options, line];
     }
 
-    // 3. Browser sub-arguments
+    // 3. Model sub-arguments
+    if (trimmed.startsWith('/model ')) {
+      const options = ['/model list', '/model set ', '/model effort low', '/model effort medium', '/model effort high'];
+      const hits = options.filter((o) => o.toLowerCase().startsWith(trimmed.toLowerCase()));
+      return [hits.length ? hits : options, line];
+    }
+
+    // 3b. Memory sub-arguments
+    if (trimmed.startsWith('/memory ')) {
+      const options = ['/memory stats', '/memory rules', '/memory reset'];
+      const hits = options.filter((o) => o.toLowerCase().startsWith(trimmed.toLowerCase()));
+      return [hits.length ? hits : options, line];
+    }
+
+    // 4. Browser sub-arguments
     if (trimmed.startsWith('/browser ')) {
       const options = ['/browser open https://'];
       return [options, line];

package/src/ui/browser-ascii.ts

@@ -0,0 +1,82 @@
+import jpeg from 'jpeg-js';
+
+const ASCII_RAMP = ' .:-=+*#%@';
+const MAX_FRAME_WIDTH = 76;
+const MAX_FRAME_HEIGHT = 34;
+const MAX_JPEG_BYTES = 560_000;
+
+export function grayscaleToAscii(
+  pixels: number[][],
+  width = MAX_FRAME_WIDTH,
+): string {
+  if (!pixels.length || !pixels[0]?.length) {
+    throw new Error('Browser frame has no pixels to render.');
+  }
+  const boundedWidth = Math.max(1, Math.min(MAX_FRAME_WIDTH, Math.floor(width)));
+  const sourceHeight = pixels.length;
+  const sourceWidth = pixels[0].length;
+  const outputHeight = Math.max(
+    1,
+    Math.min(MAX_FRAME_HEIGHT, Math.round((sourceHeight / sourceWidth) * boundedWidth * 0.5)),
+  );
+  const lines: string[] = [];
+
+  for (let y = 0; y < outputHeight; y += 1) {
+    const sourceY = Math.min(sourceHeight - 1, Math.floor((y / outputHeight) * sourceHeight));
+    let line = '';
+    for (let x = 0; x < boundedWidth; x += 1) {
+      const sourceX = Math.min(sourceWidth - 1, Math.floor((x / boundedWidth) * sourceWidth));
+      const value = Math.max(0, Math.min(255, pixels[sourceY][sourceX]));
+      const index = Math.round(((255 - value) / 255) * (ASCII_RAMP.length - 1));
+      line += ASCII_RAMP[index];
+    }
+    lines.push(line);
+  }
+  return lines.join('\n');
+}
+
+export function renderJpegAsAscii(base64: string, width = MAX_FRAME_WIDTH): string {
+  if (
+    typeof base64 !== 'string'
+    || !/^[A-Za-z0-9+/]+={0,2}$/.test(base64)
+    || base64.length > Math.ceil(MAX_JPEG_BYTES * 4 / 3)
+  ) {
+    throw new Error('Browser frame is not a valid, bounded Base64 JPEG.');
+  }
+  const bytes = Buffer.from(base64, 'base64');
+  if (bytes.length === 0 || bytes.length > MAX_JPEG_BYTES) {
+    throw new Error('Browser frame exceeds the supported JPEG size.');
+  }
+  const image = jpeg.decode(bytes, {
+    useTArray: true,
+    formatAsRGBA: true,
+    maxResolutionInMP: 4,
+    maxMemoryUsageInMB: 128,
+  });
+  const pixels: number[][] = [];
+  const outputWidth = Math.min(MAX_FRAME_WIDTH, image.width);
+  const outputHeight = Math.max(
+    1,
+    Math.min(
+      MAX_FRAME_HEIGHT,
+      Math.round((image.height / image.width) * outputWidth * 0.5),
+    ),
+  );
+
+  for (let y = 0; y < outputHeight; y += 1) {
+    const row: number[] = [];
+    const sourceY = Math.min(image.height - 1, Math.floor((y / outputHeight) * image.height));
+    for (let x = 0; x < outputWidth; x += 1) {
+      const sourceX = Math.min(image.width - 1, Math.floor((x / outputWidth) * image.width));
+      const offset = (sourceY * image.width + sourceX) * 4;
+      row.push(
+        image.data[offset] * 0.299
+        + image.data[offset + 1] * 0.587
+        + image.data[offset + 2] * 0.114,
+      );
+    }
+    pixels.push(row);
+  }
+
+  return grayscaleToAscii(pixels, Math.min(width, outputWidth));
+}

package/src/ui/repl.ts

@@ -24,9 +24,13 @@ import { handleCreateSkill, handleListSkills } from '../commands/skills';
 import { handleCreateMcp, handleListMcp, handleMcpDefaults } from '../commands/mcp';
 import { handleMicrophoneCommand } from '../commands/mic';
 import { handleBrowserCommand } from '../commands/browser';
+import { handleSubagentsCommand } from '../commands/subagents';
 import type { ConfirmationRequest } from '../client/types';
 import { formatTerminalMarkdown } from './markdown';
 import { handleCapabilities, handleProviders, handleSettings } from '../commands/diagnostics';
+import { renderJpegAsAscii } from './browser-ascii';
+import { handleModelCommand } from '../commands/model';
+import { handleMemoryCommand } from '../commands/memory';
 
 export interface ReplOptions {
   wsUrl: string;
@@ -47,6 +51,7 @@ export class HelixRepl {
   private activeTasksCount: number = 0;
   private isProcessingPrompt: boolean = false;
   private plain: boolean = false;
+  private browserLiveViewEnabled: boolean = false;
 
   constructor(private options: ReplOptions) {
     this.conversationId = `cli_conv_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
@@ -210,6 +215,29 @@ export class HelixRepl {
         this.activeTaskId = task.task_id || null;
       }
     });
+
+    this.client.on('browser_frame', (payload: {
+      conversation_id?: string;
+      mime_type?: string;
+      image_base64?: string;
+    }) => {
+      if (
+        !this.browserLiveViewEnabled
+        || !payload?.conversation_id?.startsWith('cli_')
+        || payload.mime_type !== 'image/jpeg'
+        || typeof payload.image_base64 !== 'string'
+      ) {
+        return;
+      }
+      try {
+        process.stdout.write('\r\x1b[K');
+        console.log(`\n${CYAN_BOLD('  HELIX LIVE BROWSER')}`);
+        console.log(renderJpegAsAscii(payload.image_base64));
+        this._promptUser();
+      } catch (error) {
+        console.log(RED(`  No se pudo representar el cuadro del navegador: ${(error as Error).message}`));
+      }
+    });
   }
 
   private async _handleConfirmationDialog(req: ConfirmationRequest): Promise<void> {
@@ -383,18 +411,48 @@ export class HelixRepl {
           break;
         }
 
-        case '/browser':
+        case '/browser': {
+          const browserArgs = args.trim().split(/\s+/);
+          if (browserArgs[0]?.toLowerCase() === 'live') {
+            const requestedState = browserArgs[1]?.toLowerCase();
+            if (requestedState && !['on', 'off'].includes(requestedState)) {
+              console.log(YELLOW('  Uso: /browser live [on|off]\n'));
+              break;
+            }
+            this.browserLiveViewEnabled = requestedState
+              ? requestedState === 'on'
+              : !this.browserLiveViewEnabled;
+            console.log(
+              this.browserLiveViewEnabled
+                ? GREEN('  Vista ASCII del navegador activada.\n')
+                : YELLOW('  Vista ASCII del navegador desactivada.\n'),
+            );
+            break;
+          }
           await handleBrowserCommand(this.client, args);
           break;
+        }
+
+        case '/subagents':
+          await handleSubagentsCommand(this.client, args);
+          break;
 
         case '/tasks':
           await this._handleListTasks();
           break;
 
+        case '/model':
+          await handleModelCommand(this.client, args);
+          break;
+
         case '/models':
           await this._handleListModels();
           break;
 
+        case '/memory':
+          await handleMemoryCommand(this.client, args);
+          break;
+
         case '/status':
           await this._handleStatus();
           break;

package/tests/cli.test.ts

@@ -7,6 +7,9 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { discoverUserSkillNames } from '../src/skills/user-skill-discovery';
+import { renderSubagentPanel } from '../src/commands/subagents';
+import { grayscaleToAscii, renderJpegAsAscii } from '../src/ui/browser-ascii';
+import jpeg from 'jpeg-js';
 
 test('Autocompleter suggests slash commands', () => {
   const completer = new Autocompleter();
@@ -18,6 +21,7 @@ test('Autocompleter suggests slash commands', () => {
   assert.ok(completions.includes('/mcp'));
   assert.ok(completions.includes('/create-mcp'));
   assert.ok(completions.includes('/browser'));
+  assert.ok(completions.includes('/subagents'));
   assert.ok(completions.includes('/config-apikey'));
   assert.ok(completions.includes('/show-apikey'));
   assert.ok(completions.includes('/microphone'));
@@ -28,6 +32,43 @@ test('Autocompleter suggests slash commands', () => {
   assert.ok(completions.includes('/clear'));
 });
 
+test('Subagent panel renders ASCII rows with current status and action', () => {
+  const panel = renderSubagentPanel(
+    [{ profile_id: 'flowbot', name: 'Flowbot', role: 'Browser automation' }],
+    [{
+      profile_id: 'flowbot',
+      status: 'running',
+      progress: 50,
+      current_action: 'Opening browser',
+    }],
+  );
+
+  assert.ok(panel.includes('+'));
+  assert.ok(panel.includes('flowbot'));
+  assert.ok(panel.includes('Flowbot'));
+  assert.ok(panel.includes('RUNNING'));
+  assert.ok(panel.includes('50%'));
+  assert.ok(panel.includes('Opening browser'));
+});
+
+test('Browser image renderer maps grayscale to a bounded ASCII frame', () => {
+  assert.equal(
+    grayscaleToAscii([[0, 255], [0, 255], [128, 64], [128, 64]], 2),
+    '@ \n=#',
+  );
+});
+
+test('Browser image renderer decodes JPEG frames and rejects invalid payloads', () => {
+  const image = jpeg.encode({
+    data: Buffer.from([255, 255, 255, 255]),
+    width: 1,
+    height: 1,
+  }, 80);
+
+  assert.equal(renderJpegAsAscii(image.data.toString('base64'), 1), ' ');
+  assert.throws(() => renderJpegAsAscii('not-a-jpeg'), /valid, bounded Base64 JPEG/);
+});
+
 test('Autocompleter filters slash commands by prefix', () => {
   const completer = new Autocompleter();
 

package/tsconfig.json

@@ -9,11 +9,11 @@
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    // @ts-ignore - node is deprecated but required for CommonJS compatibility with current dependencies
     "moduleResolution": "node",
     "resolveJsonModule": true,
-    "declaration": true
+    "declaration": true,
+    "types": ["node", "ws"]
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]
-}
+}