@shykaruu/jarvis-brain 0.4.0

package/src/comms/channels.test.ts

@@ -0,0 +1,173 @@
+import { test, expect, describe } from 'bun:test';
+import { ChannelManager } from './index.ts';
+import type { ChannelAdapter, ChannelMessage } from './channels/telegram.ts';
+import { splitMessage } from './channels/discord.ts';
+
+// Mock channel adapter for testing
+class MockChannel implements ChannelAdapter {
+  name = 'mock';
+  private _connected = false;
+  private _handler: ((msg: ChannelMessage) => Promise<string>) | null = null;
+
+  async connect(): Promise<void> {
+    this._connected = true;
+  }
+
+  async disconnect(): Promise<void> {
+    this._connected = false;
+  }
+
+  async sendMessage(to: string, text: string): Promise<void> {
+    // Mock implementation
+  }
+
+  onMessage(handler: (msg: ChannelMessage) => Promise<string>): void {
+    this._handler = handler;
+  }
+
+  isConnected(): boolean {
+    return this._connected;
+  }
+
+  // Test helper to simulate receiving a message
+  async simulateMessage(text: string): Promise<string | null> {
+    if (!this._handler) return null;
+
+    const msg: ChannelMessage = {
+      id: '1',
+      channel: 'mock',
+      from: 'testuser',
+      text,
+      timestamp: Date.now(),
+      metadata: {},
+    };
+
+    return this._handler(msg);
+  }
+}
+
+test('ChannelManager - register channel', () => {
+  const manager = new ChannelManager();
+  const channel = new MockChannel();
+
+  manager.register(channel);
+  expect(manager.listChannels()).toEqual(['mock']);
+  expect(manager.getChannel('mock')).toBe(channel);
+});
+
+test('ChannelManager - set handler', async () => {
+  const manager = new ChannelManager();
+  const channel = new MockChannel();
+
+  manager.register(channel);
+
+  let handlerCalled = false;
+  manager.setHandler(async (msg) => {
+    handlerCalled = true;
+    return `Echo: ${msg.text}`;
+  });
+
+  const response = await channel.simulateMessage('test');
+  expect(handlerCalled).toBe(true);
+  expect(response).toBe('Echo: test');
+});
+
+test('ChannelManager - connect all channels', async () => {
+  const manager = new ChannelManager();
+  const channel1 = new MockChannel();
+  const channel2 = new MockChannel();
+  channel2.name = 'mock2';
+
+  manager.register(channel1);
+  manager.register(channel2);
+
+  await manager.connectAll();
+
+  const status = manager.getStatus();
+  expect(status.mock).toBe(true);
+  expect(status.mock2).toBe(true);
+});
+
+test('ChannelManager - disconnect all channels', async () => {
+  const manager = new ChannelManager();
+  const channel = new MockChannel();
+
+  manager.register(channel);
+  await manager.connectAll();
+
+  expect(manager.getStatus().mock).toBe(true);
+
+  await manager.disconnectAll();
+  expect(manager.getStatus().mock).toBe(false);
+});
+
+test('ChannelManager - list channels', () => {
+  const manager = new ChannelManager();
+
+  expect(manager.listChannels()).toEqual([]);
+
+  manager.register(new MockChannel());
+  expect(manager.listChannels()).toEqual(['mock']);
+
+  const channel2 = new MockChannel();
+  channel2.name = 'mock2';
+  manager.register(channel2);
+
+  expect(manager.listChannels()).toContain('mock');
+  expect(manager.listChannels()).toContain('mock2');
+});
+
+// Discord splitMessage tests
+describe('Discord splitMessage', () => {
+  test('returns single chunk for short message', () => {
+    const result = splitMessage('Hello world', 2000);
+    expect(result).toEqual(['Hello world']);
+  });
+
+  test('returns single chunk for message exactly at limit', () => {
+    const text = 'a'.repeat(2000);
+    const result = splitMessage(text, 2000);
+    expect(result).toEqual([text]);
+  });
+
+  test('splits long message at newline boundary', () => {
+    const line = 'This is a line of text\n';
+    // Create text that exceeds 100 chars, with newlines
+    const text = line.repeat(10); // 220 chars
+    const result = splitMessage(text, 100);
+    expect(result.length).toBeGreaterThan(1);
+    // Each chunk should be <= 100 chars
+    for (const chunk of result) {
+      expect(chunk.length).toBeLessThanOrEqual(100);
+    }
+    // Recombined should equal original (modulo trimmed whitespace)
+    const recombined = result.join('');
+    // The original text is preserved (whitespace trimming might remove leading spaces between chunks)
+    expect(recombined.replace(/\s+/g, '')).toBe(text.replace(/\s+/g, ''));
+  });
+
+  test('hard splits when no good break point', () => {
+    // No spaces or newlines — must hard split
+    const text = 'a'.repeat(5000);
+    const result = splitMessage(text, 2000);
+    expect(result.length).toBe(3); // 2000 + 2000 + 1000
+    expect(result[0]!.length).toBe(2000);
+    expect(result[1]!.length).toBe(2000);
+    expect(result[2]!.length).toBe(1000);
+  });
+
+  test('handles empty string', () => {
+    const result = splitMessage('', 2000);
+    expect(result).toEqual(['']);
+  });
+
+  test('splits at space when no newlines available', () => {
+    // Words separated by spaces, no newlines
+    const words = Array(200).fill('word').join(' '); // "word word word..." ~1000 chars
+    const result = splitMessage(words, 100);
+    expect(result.length).toBeGreaterThan(1);
+    for (const chunk of result) {
+      expect(chunk.length).toBeLessThanOrEqual(100);
+    }
+  });
+});

package/src/comms/dashboard-auth.ts

@@ -0,0 +1,75 @@
+import { timingSafeEqual } from 'node:crypto';
+import type { JarvisConfig } from '../config/types.ts';
+import {
+  createDashboardSession,
+  deleteDashboardSession,
+  validateDashboardSession,
+  type DashboardSession,
+} from '../vault/dashboard-sessions.ts';
+
+export const DASHBOARD_SESSION_COOKIE = 'jarvis_dashboard_session';
+export const DASHBOARD_SESSION_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+export const DASHBOARD_SESSION_MAX_AGE_SECONDS = Math.floor(DASHBOARD_SESSION_MAX_AGE_MS / 1000);
+
+export function getCookie(req: Request, name: string): string | null {
+  const cookies = req.headers.get('Cookie');
+  if (!cookies) return null;
+  const match = cookies.match(new RegExp(`(?:^|;\\s*)${name}=([^;]*)`));
+  return match ? decodeURIComponent(match[1]!) : null;
+}
+
+export function safeCompare(a: string, b: string): boolean {
+  if (a.length !== b.length) return false;
+  return timingSafeEqual(Buffer.from(a), Buffer.from(b));
+}
+
+export function isDashboardPasswordEnabled(config: Pick<JarvisConfig, 'dashboard'> | { dashboard?: { password_hash?: string } } | null | undefined): boolean {
+  return Boolean(config?.dashboard?.password_hash?.trim());
+}
+
+export function shouldUseSecureCookies(req: Request): boolean {
+  const forwardedProto = req.headers.get('x-forwarded-proto');
+  if (forwardedProto) {
+    return forwardedProto.split(',')[0]!.trim().toLowerCase() === 'https';
+  }
+  return new URL(req.url).protocol === 'https:';
+}
+
+export function buildCookieAttributes(req: Request, expiresAt?: number): string {
+  const parts = ['Path=/', 'HttpOnly', 'SameSite=Lax'];
+  if (shouldUseSecureCookies(req)) parts.push('Secure');
+  if (expiresAt) {
+    parts.push(`Max-Age=${DASHBOARD_SESSION_MAX_AGE_SECONDS}`);
+    parts.push(`Expires=${new Date(expiresAt).toUTCString()}`);
+  }
+  return parts.join('; ');
+}
+
+export function buildDashboardSessionCookie(req: Request, sessionId: string, expiresAt: number): string {
+  return `${DASHBOARD_SESSION_COOKIE}=${encodeURIComponent(sessionId)}; ${buildCookieAttributes(req, expiresAt)}`;
+}
+
+export function buildClearedDashboardSessionCookie(req: Request): string {
+  const epoch = new Date(0).toUTCString();
+  const parts = ['Path=/', 'HttpOnly', 'SameSite=Lax', 'Max-Age=0', `Expires=${epoch}`];
+  if (shouldUseSecureCookies(req)) parts.push('Secure');
+  return `${DASHBOARD_SESSION_COOKIE}=; ${parts.join('; ')}`;
+}
+
+export function createAuthenticatedDashboardSession(): DashboardSession {
+  const sessionId = crypto.randomUUID();
+  const expiresAt = Date.now() + DASHBOARD_SESSION_MAX_AGE_MS;
+  return createDashboardSession(sessionId, expiresAt);
+}
+
+export function getDashboardSessionFromRequest(req: Request): DashboardSession | null {
+  const sessionId = getCookie(req, DASHBOARD_SESSION_COOKIE);
+  if (!sessionId) return null;
+  return validateDashboardSession(sessionId);
+}
+
+export function revokeDashboardSessionFromRequest(req: Request): void {
+  const sessionId = getCookie(req, DASHBOARD_SESSION_COOKIE);
+  if (!sessionId) return;
+  deleteDashboardSession(sessionId);
+}

package/src/comms/desktop-notify.ts

@@ -0,0 +1,114 @@
+/**
+ * Desktop Notification Sender
+ *
+ * Sends native desktop notifications.
+ * Tries in order:
+ *   1. notify-send (Linux/WSLg)
+ *   2. PowerShell toast (WSL2 → Windows)
+ * Gracefully degrades if neither is available.
+ */
+
+type NotifyMethod = 'notify-send' | 'powershell' | null;
+
+let method: NotifyMethod | undefined;
+
+function detectMethod(): NotifyMethod {
+  if (method !== undefined) return method;
+
+  // Try notify-send first (native Linux/WSLg)
+  try {
+    const result = Bun.spawnSync(['which', 'notify-send']);
+    if (result.exitCode === 0) {
+      method = 'notify-send';
+      console.log('[DesktopNotify] Using notify-send');
+      return method;
+    }
+  } catch { /* continue */ }
+
+  // Try PowerShell (WSL2 → Windows toast)
+  try {
+    const result = Bun.spawnSync(['which', 'powershell.exe']);
+    if (result.exitCode === 0) {
+      method = 'powershell';
+      console.log('[DesktopNotify] Using PowerShell toasts');
+      return method;
+    }
+  } catch { /* continue */ }
+
+  method = null;
+  console.log('[DesktopNotify] No notification method available');
+  return method;
+}
+
+/**
+ * Send a native desktop notification.
+ * Returns true if sent, false if unavailable.
+ */
+export function sendDesktopNotification(
+  title: string,
+  body: string,
+  options?: {
+    urgency?: 'low' | 'normal' | 'critical';
+    expireMs?: number;
+  }
+): boolean {
+  const m = detectMethod();
+  if (!m) return false;
+
+  try {
+    if (m === 'notify-send') {
+      return sendViaNotifySend(title, body, options);
+    } else {
+      return sendViaPowerShell(title, body);
+    }
+  } catch {
+    return false;
+  }
+}
+
+function sendViaNotifySend(
+  title: string,
+  body: string,
+  options?: { urgency?: string; expireMs?: number }
+): boolean {
+  const urgency = options?.urgency ?? 'normal';
+  const expireMs = options?.expireMs ?? (urgency === 'critical' ? 10000 : 5000);
+
+  Bun.spawn([
+    'notify-send',
+    `--urgency=${urgency}`,
+    `--expire-time=${expireMs}`,
+    '--app-name=JARVIS',
+    title,
+    body,
+  ], { stdout: 'ignore', stderr: 'ignore' });
+  return true;
+}
+
+function sendViaPowerShell(title: string, body: string): boolean {
+  // Escape single quotes for PowerShell
+  const safeTitle = title.replace(/'/g, "''").slice(0, 100);
+  const safeBody = body.replace(/'/g, "''").slice(0, 200);
+
+  const script = `
+    [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+    [Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom, ContentType = WindowsRuntime] | Out-Null
+    $xml = [Windows.Data.Xml.Dom.XmlDocument]::new()
+    $xml.LoadXml('<toast><visual><binding template="ToastText02"><text id="1">${safeTitle}</text><text id="2">${safeBody}</text></binding></visual></toast>')
+    $toast = [Windows.UI.Notifications.ToastNotification]::new($xml)
+    [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('JARVIS').Show($toast)
+  `.trim();
+
+  Bun.spawn(['powershell.exe', '-NoProfile', '-NonInteractive', '-Command', script], {
+    stdout: 'ignore',
+    stderr: 'ignore',
+  });
+  return true;
+}
+
+/**
+ * Check if desktop notifications are available.
+ */
+export function isDesktopNotifyAvailable(): boolean {
+  return detectMethod() !== null;
+}

package/src/comms/example.ts

@@ -0,0 +1,129 @@
+/**
+ * Example usage of J.A.R.V.I.S. Communication Layer
+ *
+ * This demonstrates how to:
+ * 1. Start the WebSocket server
+ * 2. Set up Telegram bot integration
+ * 3. Handle messages from multiple channels
+ * 4. Relay LLM streaming responses
+ */
+
+import {
+  WebSocketServer,
+  ChannelManager,
+  TelegramAdapter,
+  StreamRelay,
+  type WSMessage,
+  type ChannelMessage,
+} from './index.ts';
+
+async function main() {
+  console.log('🤖 Starting J.A.R.V.I.S. Communication Layer...\n');
+
+  // 1. Initialize WebSocket server
+  const wsServer = new WebSocketServer(3142);
+
+  wsServer.setHandler({
+    async onMessage(msg: WSMessage) {
+      console.log('[WS] Received message:', msg.type);
+
+      if (msg.type === 'chat') {
+        // Echo back for demo
+        return {
+          type: 'chat' as const,
+          payload: {
+            reply: `You said: ${msg.payload}`,
+          },
+          id: msg.id,
+          timestamp: Date.now(),
+        };
+      }
+    },
+    onConnect() {
+      console.log('[WS] Client connected');
+    },
+    onDisconnect() {
+      console.log('[WS] Client disconnected');
+    },
+  });
+
+  wsServer.start();
+
+  // 2. Initialize Channel Manager
+  const channelManager = new ChannelManager();
+
+  // Set up unified message handler
+  channelManager.setHandler(async (message: ChannelMessage) => {
+    console.log(`\n[${message.channel.toUpperCase()}] Message from ${message.from}:`);
+    console.log(`  "${message.text}"`);
+
+    // Broadcast to WebSocket clients
+    wsServer.broadcast({
+      type: 'chat',
+      payload: {
+        channel: message.channel,
+        from: message.from,
+        text: message.text,
+      },
+      id: message.id,
+      timestamp: message.timestamp,
+    });
+
+    // Simple echo response for demo
+    return `Received your message: "${message.text}"`;
+  });
+
+  // 3. Register channels (Telegram only for demo)
+  const telegramToken = process.env.TELEGRAM_BOT_TOKEN;
+
+  if (telegramToken) {
+    const telegram = new TelegramAdapter(telegramToken);
+    channelManager.register(telegram);
+    console.log('✓ Telegram adapter registered');
+  } else {
+    console.log('⚠️  TELEGRAM_BOT_TOKEN not set, skipping Telegram');
+  }
+
+  // Connect all channels
+  try {
+    await channelManager.connectAll();
+    console.log('\n✓ All channels connected');
+    console.log('Status:', channelManager.getStatus());
+  } catch (error) {
+    console.error('Error connecting channels:', error);
+  }
+
+  // 4. Demo: Stream relay (requires LLM provider setup)
+  const streamRelay = new StreamRelay(wsServer);
+
+  // Example stream simulation
+  console.log('\n📡 Streaming demo (simulated)...');
+  const simulatedStream = (async function* () {
+    yield { type: 'text' as const, text: 'Hello ' };
+    await new Promise(r => setTimeout(r, 100));
+    yield { type: 'text' as const, text: 'from ' };
+    await new Promise(r => setTimeout(r, 100));
+    yield { type: 'text' as const, text: 'J.A.R.V.I.S.!' };
+    await new Promise(r => setTimeout(r, 100));
+    yield { type: 'done' as const, response: { content: 'Hello from J.A.R.V.I.S.!', tool_calls: [], usage: { input_tokens: 0, output_tokens: 10 }, model: 'demo', finish_reason: 'stop' as const } };
+  })();
+
+  const fullResponse = await streamRelay.relayStream(simulatedStream, 'demo-123');
+  console.log('Full response:', fullResponse);
+
+  console.log('\n✓ Communication layer is running');
+  console.log(`  WebSocket: ws://localhost:${wsServer.getPort()}/ws`);
+  console.log(`  Health: http://localhost:${wsServer.getPort()}/health`);
+  console.log(`  Channels: ${channelManager.listChannels().join(', ')}`);
+  console.log('\nPress Ctrl+C to stop...');
+
+  // Graceful shutdown
+  process.on('SIGINT', async () => {
+    console.log('\n\n🛑 Shutting down...');
+    await channelManager.disconnectAll();
+    wsServer.stop();
+    process.exit(0);
+  });
+}
+
+main().catch(console.error);

package/src/comms/index.ts

@@ -0,0 +1,129 @@
+// Core WebSocket and Streaming
+export { WebSocketServer, type WSMessage, type WSClientHandler } from './websocket.ts';
+export { StreamRelay } from './streaming.ts';
+
+// Voice I/O
+export {
+  OpenAIWhisperSTT,
+  GroqWhisperSTT,
+  LocalWhisperSTT,
+  EdgeTTSProvider,
+  ElevenLabsTTSProvider,
+  createSTTProvider,
+  createTTSProvider,
+  listElevenLabsVoices,
+  splitIntoSentences,
+  type STTProvider,
+  type TTSProvider,
+} from './voice.ts';
+
+// Channel adapters
+export {
+  TelegramAdapter,
+  type ChannelMessage,
+  type ChannelHandler,
+  type ChannelAdapter,
+} from './channels/telegram.ts';
+export { WhatsAppAdapter } from './channels/whatsapp.ts';
+export { DiscordAdapter } from './channels/discord.ts';
+export { SignalAdapter } from './channels/signal.ts';
+
+// Channel Manager
+export class ChannelManager {
+  private channels: Map<string, import('./channels/telegram.ts').ChannelAdapter> = new Map();
+  private handler: import('./channels/telegram.ts').ChannelHandler | null = null;
+
+  /**
+   * Register a channel adapter
+   */
+  register(adapter: import('./channels/telegram.ts').ChannelAdapter): void {
+    if (this.channels.has(adapter.name)) {
+      console.warn(`[ChannelManager] Channel "${adapter.name}" already registered, overwriting`);
+    }
+
+    this.channels.set(adapter.name, adapter);
+    console.log(`[ChannelManager] Registered channel: ${adapter.name}`);
+  }
+
+  /**
+   * Set the message handler for all channels
+   */
+  setHandler(handler: import('./channels/telegram.ts').ChannelHandler): void {
+    this.handler = handler;
+
+    // Apply handler to all registered channels
+    for (const adapter of this.channels.values()) {
+      adapter.onMessage(handler);
+    }
+
+    console.log('[ChannelManager] Handler set for all channels');
+  }
+
+  /**
+   * Connect all registered channels
+   */
+  async connectAll(): Promise<void> {
+    const results = await Promise.allSettled(
+      Array.from(this.channels.values()).map(async (adapter) => {
+        try {
+          await adapter.connect();
+          console.log(`[ChannelManager] Connected: ${adapter.name}`);
+        } catch (error) {
+          console.error(`[ChannelManager] Failed to connect ${adapter.name}:`, error);
+          throw error;
+        }
+      })
+    );
+
+    const failures = results.filter((r) => r.status === 'rejected');
+    if (failures.length > 0) {
+      console.warn(`[ChannelManager] ${failures.length} channel(s) failed to connect`);
+    }
+
+    const successes = results.filter((r) => r.status === 'fulfilled').length;
+    console.log(`[ChannelManager] ${successes}/${this.channels.size} channels connected`);
+  }
+
+  /**
+   * Disconnect all registered channels
+   */
+  async disconnectAll(): Promise<void> {
+    await Promise.allSettled(
+      Array.from(this.channels.values()).map(async (adapter) => {
+        try {
+          await adapter.disconnect();
+          console.log(`[ChannelManager] Disconnected: ${adapter.name}`);
+        } catch (error) {
+          console.error(`[ChannelManager] Error disconnecting ${adapter.name}:`, error);
+        }
+      })
+    );
+
+    console.log('[ChannelManager] All channels disconnected');
+  }
+
+  /**
+   * Get a specific channel adapter by name
+   */
+  getChannel(name: string): import('./channels/telegram.ts').ChannelAdapter | undefined {
+    return this.channels.get(name);
+  }
+
+  /**
+   * List all registered channel names
+   */
+  listChannels(): string[] {
+    return Array.from(this.channels.keys());
+  }
+
+  /**
+   * Get status of all channels
+   */
+  getStatus(): Record<string, boolean> {
+    const status: Record<string, boolean> = {};
+    for (const [name, adapter] of this.channels) {
+      status[name] = adapter.isConnected();
+    }
+    return status;
+  }
+}