bloby-bot 0.17.2

package/supervisor/chat/src/lib/ws-client.ts

@@ -0,0 +1,126 @@
+type MessageHandler = (msg: any) => void;
+type StatusHandler = (connected: boolean) => void;
+
+interface QueuedMessage {
+  type: string;
+  data: any;
+}
+
+export class WsClient {
+  private ws: WebSocket | null = null;
+  private handlers = new Map<string, Set<MessageHandler>>();
+  private statusHandlers = new Set<StatusHandler>();
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private url: string;
+  private queue: QueuedMessage[] = [];
+  private intentionalClose = false;
+  private reconnectDelay = 1000;
+  private static MAX_RECONNECT_DELAY = 8000;
+  private tokenGetter: (() => string | null) | null = null;
+
+  constructor(url?: string, tokenGetter?: (() => string | null) | null) {
+    const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const host = import.meta.env.DEV ? 'localhost:3000' : location.host;
+    this.url = url ?? `${proto}//${host}/ws`;
+    this.tokenGetter = tokenGetter ?? null;
+  }
+
+  connect(): void {
+    this.intentionalClose = false;
+    let wsUrl = this.url;
+    if (this.tokenGetter) {
+      const token = this.tokenGetter();
+      if (token) {
+        const sep = wsUrl.includes('?') ? '&' : '?';
+        wsUrl = `${wsUrl}${sep}token=${token}`;
+      }
+    }
+    this.ws = new WebSocket(wsUrl);
+
+    this.ws.onopen = () => {
+      this.reconnectDelay = 1000;
+      this.notifyStatus(true);
+      this.flushQueue();
+      this.startHeartbeat();
+    };
+
+    this.ws.onmessage = (e) => {
+      // Ignore pong frames
+      if (e.data === 'pong') return;
+      const msg = JSON.parse(e.data);
+      const handlers = this.handlers.get(msg.type);
+      handlers?.forEach((h) => h(msg.data));
+    };
+
+    this.ws.onclose = () => {
+      this.stopHeartbeat();
+      this.notifyStatus(false);
+      if (!this.intentionalClose) {
+        this.reconnectTimer = setTimeout(() => {
+          this.reconnectDelay = Math.min(this.reconnectDelay * 2, WsClient.MAX_RECONNECT_DELAY);
+          this.connect();
+        }, this.reconnectDelay);
+      }
+    };
+
+    this.ws.onerror = () => this.ws?.close();
+  }
+
+  disconnect(): void {
+    this.intentionalClose = true;
+    if (this.reconnectTimer) { clearTimeout(this.reconnectTimer); this.reconnectTimer = null; }
+    this.stopHeartbeat();
+    this.ws?.close();
+    this.ws = null;
+  }
+
+  on(type: string, handler: MessageHandler): () => void {
+    if (!this.handlers.has(type)) this.handlers.set(type, new Set());
+    this.handlers.get(type)!.add(handler);
+    return () => this.handlers.get(type)?.delete(handler);
+  }
+
+  onStatus(handler: StatusHandler): () => void {
+    this.statusHandlers.add(handler);
+    return () => this.statusHandlers.delete(handler);
+  }
+
+  send(type: string, data: any): void {
+    const message = { type, data };
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(message));
+    } else {
+      // Queue for delivery on reconnect
+      this.queue.push(message);
+    }
+  }
+
+  get connected(): boolean {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  private flushQueue(): void {
+    while (this.queue.length > 0 && this.ws?.readyState === WebSocket.OPEN) {
+      const msg = this.queue.shift()!;
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+
+  private notifyStatus(connected: boolean): void {
+    this.statusHandlers.forEach((h) => h(connected));
+  }
+
+  private startHeartbeat(): void {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send('ping');
+      }
+    }, 25_000);
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = null; }
+  }
+}

package/supervisor/chat/src/styles/globals.css

@@ -0,0 +1,116 @@
+@import "tailwindcss";
+
+@custom-variant dark (&:is(.dark *));
+
+@theme inline {
+  --color-background: #212121;
+  --color-foreground: #f5f5f5;
+  --color-card: #2a2a2a;
+  --color-card-foreground: #f5f5f5;
+  --color-popover: #2a2a2a;
+  --color-popover-foreground: #f5f5f5;
+  --color-primary: #3C8FFF;
+  --color-primary-foreground: #ffffff;
+  --color-secondary: #333333;
+  --color-secondary-foreground: #f5f5f5;
+  --color-muted: #333333;
+  --color-muted-foreground: #999999;
+  --color-accent: #333333;
+  --color-accent-foreground: #f5f5f5;
+  --color-destructive: #FD486B;
+  --color-destructive-foreground: #ffffff;
+  --color-border: #3a3a3a;
+  --color-input: #3a3a3a;
+  --color-ring: #3C8FFF;
+  --color-chart-1: #3C8FFF;
+  --color-chart-2: #FD486B;
+  --color-chart-3: #F59E0B;
+  --color-chart-4: #8B5CF6;
+  --color-chart-5: #10B981;
+  --color-sidebar: #1c1c1c;
+  --color-sidebar-foreground: #f5f5f5;
+  --color-sidebar-primary: #3C8FFF;
+  --color-sidebar-primary-foreground: #ffffff;
+  --color-sidebar-accent: #282828;
+  --color-sidebar-accent-foreground: #f5f5f5;
+  --color-sidebar-border: #3a3a3a;
+  --color-sidebar-ring: #3C8FFF;
+  --radius: 0.75rem;
+}
+
+html {
+  touch-action: manipulation;
+  -ms-touch-action: manipulation;
+}
+
+body {
+  background-color: var(--color-background);
+  color: var(--color-foreground);
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  overscroll-behavior: none;
+}
+
+::selection {
+  background-color: rgba(175, 39, 227, 0.25);
+}
+
+::-webkit-scrollbar { width: 6px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: #3a3a3a; border-radius: 3px; }
+::-webkit-scrollbar-thumb:hover { background: #4a4a4a; }
+
+.text-gradient {
+  background-clip: text;
+  -webkit-background-clip: text;
+  color: transparent;
+  -webkit-text-fill-color: transparent;
+  background-image: linear-gradient(135deg, #04D1FE, #AF27E3, #FB4072);
+}
+
+.bg-gradient-brand {
+  background-image: linear-gradient(135deg, #04D1FE, #AF27E3, #FB4072);
+}
+
+.glow-border {
+  box-shadow: 0 0 0 1px rgba(175, 39, 227, 0.1),
+              0 0 20px -5px rgba(175, 39, 227, 0.15);
+}
+
+.animated-border {
+  position: relative;
+  overflow: hidden;
+}
+.animated-border::before {
+  content: '';
+  position: absolute;
+  inset: -150%;
+  background: conic-gradient(
+    from 0deg,
+    #04D1FE,
+    #AF27E3,
+    #FB4072,
+    #04D1FE
+  );
+  animation: border-spin 3s linear infinite;
+}
+.animated-border > * {
+  position: relative;
+  z-index: 1;
+}
+
+.animated-border-slow::before {
+  animation-duration: 5s;
+}
+
+.input-glow:focus {
+  border-color: rgba(175, 39, 227, 0.4);
+  box-shadow: 0 0 0 1px rgba(175, 39, 227, 0.15),
+              0 0 20px -5px rgba(175, 39, 227, 0.25),
+              0 0 4px -1px rgba(4, 209, 254, 0.1);
+}
+
+@keyframes border-spin {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(360deg); }
+}

package/supervisor/file-saver.ts

@@ -0,0 +1,50 @@
+import fs from 'fs';
+import crypto from 'crypto';
+import { paths } from '../shared/paths.js';
+
+export interface SavedFile {
+  type: 'image' | 'document';
+  name: string;
+  mediaType: string;
+  relPath: string;
+  absPath: string;
+}
+
+export function ensureFileDirs(): void {
+  fs.mkdirSync(paths.filesAudio, { recursive: true });
+  fs.mkdirSync(paths.filesImages, { recursive: true });
+  fs.mkdirSync(paths.filesDocuments, { recursive: true });
+}
+
+export function saveAttachment(att: { type: 'image' | 'file'; name: string; mediaType: string; data: string }): SavedFile {
+  const category = att.type === 'image' ? 'images' : 'documents';
+
+  const now = new Date();
+  const ts = now.toISOString().replace(/[-:T]/g, '').slice(0, 14);
+  const stamp = `${ts.slice(0, 8)}_${ts.slice(8, 14)}`;
+  const rand = crypto.randomBytes(3).toString('hex');
+
+  // Extract extension from original name or mediaType
+  const extFromName = att.name?.includes('.') ? att.name.split('.').pop()! : '';
+  const extFromMime: Record<string, string> = {
+    'image/png': 'png', 'image/jpeg': 'jpg', 'image/gif': 'gif', 'image/webp': 'webp',
+    'application/pdf': 'pdf', 'text/plain': 'txt', 'text/csv': 'csv',
+  };
+  const ext = extFromName || extFromMime[att.mediaType] || 'bin';
+
+  const filename = `${stamp}_${rand}.${ext}`;
+  const relPath = `files/${category}/${filename}`;
+
+  const dir = category === 'images' ? paths.filesImages : paths.filesDocuments;
+  const absPath = `${dir}/${filename}`;
+
+  fs.writeFileSync(absPath, Buffer.from(att.data, 'base64'));
+
+  return {
+    type: att.type === 'image' ? 'image' : 'document',
+    name: att.name,
+    mediaType: att.mediaType,
+    relPath,
+    absPath,
+  };
+}