fluxy-bot 0.8.9 → 0.9.0

package/supervisor/chat/src/hooks/useSpeechRecognition.ts

@@ -2,167 +2,145 @@ import { useRef, useCallback, useMemo } from 'react';
 
 // Extend Window for vendor-prefixed SpeechRecognition
 interface SpeechRecognitionEvent extends Event {
-    results: SpeechRecognitionResultList;
-    resultIndex: number;
+  results: SpeechRecognitionResultList;
+  resultIndex: number;
 }
 
 type SpeechRecognitionConstructor = new () => SpeechRecognitionInstance;
 
 interface SpeechRecognitionInstance extends EventTarget {
-    continuous: boolean;
-    interimResults: boolean;
-    lang: string;
-    start(): void;
-    stop(): void;
-    abort(): void;
-    onresult: ((event: SpeechRecognitionEvent) => void) | null;
-    onend: (() => void) | null;
-    onerror: ((event: Event & { error: string }) => void) | null;
+  continuous: boolean;
+  interimResults: boolean;
+  lang: string;
+  start(): void;
+  stop(): void;
+  abort(): void;
+  onresult: ((event: SpeechRecognitionEvent) => void) | null;
+  onend: (() => void) | null;
+  onerror: ((event: Event & { error: string }) => void) | null;
 }
 
 const getSpeechRecognitionCtor = (): SpeechRecognitionConstructor | null => {
-    if (typeof window === 'undefined') return null;
-    return (
-        (window as unknown as Record<string, SpeechRecognitionConstructor>)
-            .SpeechRecognition ??
-        (window as unknown as Record<string, SpeechRecognitionConstructor>)
-            .webkitSpeechRecognition ??
-        null
-    );
+  if (typeof window === 'undefined') return null;
+  return (
+    (window as unknown as Record<string, SpeechRecognitionConstructor>).SpeechRecognition ??
+    (window as unknown as Record<string, SpeechRecognitionConstructor>).webkitSpeechRecognition ??
+    null
+  );
 };
 
 export const isWebSpeechSupported = getSpeechRecognitionCtor() !== null;
 
 export function useSpeechRecognition() {
-    const instanceRef = useRef<SpeechRecognitionInstance | null>(null);
-    const transcriptRef = useRef('');
-    const resolveRef = useRef<((text: string) => void) | null>(null);
-
-    const isSupported = useMemo(() => isWebSpeechSupported, []);
-
-    const start = useCallback(() => {
-        console.log('[SpeechRecognition] start()');
-        const Ctor = getSpeechRecognitionCtor();
-        if (!Ctor) {
-            console.log('[SpeechRecognition] not available');
-            return;
-        }
-
-        // Clean up any lingering instance
-        if (instanceRef.current) {
-            try {
-                instanceRef.current.abort();
-            } catch {}
-        }
-
-        const recognition = new Ctor();
-        recognition.continuous = false; // single utterance — matches press-hold-release UX
-        recognition.interimResults = true; // get progressive updates while speaking
-        recognition.lang = navigator.language || 'en-US';
-
-        transcriptRef.current = '';
-        instanceRef.current = recognition;
-
-        recognition.onresult = (event: SpeechRecognitionEvent) => {
-            // Grab the latest result — it's always the most complete/accurate
-            const last = event.results[event.results.length - 1];
-            const text = last[0].transcript;
-            console.log(
-                '[SpeechRecognition] onresult:',
-                JSON.stringify(text),
-                'isFinal:',
-                last.isFinal
-            );
-            transcriptRef.current = text;
-        };
-
-        recognition.onend = () => {
-            console.log(
-                '[SpeechRecognition] onend, transcript:',
-                JSON.stringify(transcriptRef.current)
-            );
-            instanceRef.current = null;
-            // If stop() is waiting for a result, resolve it now
-            if (resolveRef.current) {
-                resolveRef.current(transcriptRef.current);
-                resolveRef.current = null;
-            }
-        };
-
-        recognition.onerror = event => {
-            console.error('[SpeechRecognition] error:', event.error);
-            instanceRef.current = null;
-            if (resolveRef.current) {
-                resolveRef.current(transcriptRef.current);
-                resolveRef.current = null;
-            }
-        };
-
-        try {
-            recognition.start();
-            console.log('[SpeechRecognition] started, lang:', recognition.lang);
-        } catch (e) {
-            console.error('[SpeechRecognition] start failed:', e);
-        }
-    }, []);
-
-    const stop = useCallback((): Promise<string> => {
-        console.log(
-            '[SpeechRecognition] stop(), transcript so far:',
-            JSON.stringify(transcriptRef.current)
-        );
-        return new Promise(resolve => {
-            const instance = instanceRef.current;
-            if (!instance) {
-                // Already ended (e.g. short utterance auto-stopped)
-                console.log(
-                    '[SpeechRecognition] no instance, resolving immediately'
-                );
-                resolve(transcriptRef.current);
-                return;
-            }
-
-            // Wait for onend to fire with the final transcript
-            resolveRef.current = resolve;
-
-            try {
-                instance.stop(); // triggers onend after finalizing
-            } catch {
-                instanceRef.current = null;
-                resolve(transcriptRef.current);
-                resolveRef.current = null;
-            }
-
-            // Safety timeout in case onend never fires
-            setTimeout(() => {
-                if (resolveRef.current) {
-                    console.log(
-                        '[SpeechRecognition] safety timeout, resolving with:',
-                        JSON.stringify(transcriptRef.current)
-                    );
-                    resolveRef.current(transcriptRef.current);
-                    resolveRef.current = null;
-                    instanceRef.current = null;
-                }
-            }, 2000);
-        });
-    }, []);
-
-    const abort = useCallback(() => {
-        console.log('[SpeechRecognition] abort()');
-        transcriptRef.current = '';
-        const instance = instanceRef.current;
-        if (instance) {
-            try {
-                instance.abort();
-            } catch {}
-            instanceRef.current = null;
-        }
+  const instanceRef = useRef<SpeechRecognitionInstance | null>(null);
+  const transcriptRef = useRef('');
+  const resolveRef = useRef<((text: string) => void) | null>(null);
+
+  const isSupported = useMemo(() => isWebSpeechSupported, []);
+
+  const start = useCallback(() => {
+    console.log('[SpeechRecognition] start()');
+    const Ctor = getSpeechRecognitionCtor();
+    if (!Ctor) {
+      console.log('[SpeechRecognition] not available');
+      return;
+    }
+
+    // Clean up any lingering instance
+    if (instanceRef.current) {
+      try { instanceRef.current.abort(); } catch {}
+    }
+
+    const recognition = new Ctor();
+    recognition.continuous = false;   // single utterance — matches press-hold-release UX
+    recognition.interimResults = true; // get progressive updates while speaking
+    recognition.lang = navigator.language || 'en-US';
+
+    transcriptRef.current = '';
+    instanceRef.current = recognition;
+
+    recognition.onresult = (event: SpeechRecognitionEvent) => {
+      // Grab the latest result — it's always the most complete/accurate
+      const last = event.results[event.results.length - 1];
+      const text = last[0].transcript;
+      console.log('[SpeechRecognition] onresult:', JSON.stringify(text), 'isFinal:', last.isFinal);
+      transcriptRef.current = text;
+    };
+
+    recognition.onend = () => {
+      console.log('[SpeechRecognition] onend, transcript:', JSON.stringify(transcriptRef.current));
+      instanceRef.current = null;
+      // If stop() is waiting for a result, resolve it now
+      if (resolveRef.current) {
+        resolveRef.current(transcriptRef.current);
+        resolveRef.current = null;
+      }
+    };
+
+    recognition.onerror = (event) => {
+      console.error('[SpeechRecognition] error:', event.error);
+      instanceRef.current = null;
+      if (resolveRef.current) {
+        resolveRef.current(transcriptRef.current);
+        resolveRef.current = null;
+      }
+    };
+
+    try {
+      recognition.start();
+      console.log('[SpeechRecognition] started, lang:', recognition.lang);
+    } catch (e) {
+      console.error('[SpeechRecognition] start failed:', e);
+    }
+  }, []);
+
+  const stop = useCallback((): Promise<string> => {
+    console.log('[SpeechRecognition] stop(), transcript so far:', JSON.stringify(transcriptRef.current));
+    return new Promise((resolve) => {
+      const instance = instanceRef.current;
+      if (!instance) {
+        // Already ended (e.g. short utterance auto-stopped)
+        console.log('[SpeechRecognition] no instance, resolving immediately');
+        resolve(transcriptRef.current);
+        return;
+      }
+
+      // Wait for onend to fire with the final transcript
+      resolveRef.current = resolve;
+
+      try {
+        instance.stop(); // triggers onend after finalizing
+      } catch {
+        instanceRef.current = null;
+        resolve(transcriptRef.current);
+        resolveRef.current = null;
+      }
+
+      // Safety timeout in case onend never fires
+      setTimeout(() => {
         if (resolveRef.current) {
-            resolveRef.current('');
-            resolveRef.current = null;
+          console.log('[SpeechRecognition] safety timeout, resolving with:', JSON.stringify(transcriptRef.current));
+          resolveRef.current(transcriptRef.current);
+          resolveRef.current = null;
+          instanceRef.current = null;
         }
-    }, []);
-
-    return { start, stop, abort, isSupported };
+      }, 2000);
+    });
+  }, []);
+
+  const abort = useCallback(() => {
+    console.log('[SpeechRecognition] abort()');
+    transcriptRef.current = '';
+    const instance = instanceRef.current;
+    if (instance) {
+      try { instance.abort(); } catch {}
+      instanceRef.current = null;
+    }
+    if (resolveRef.current) {
+      resolveRef.current('');
+      resolveRef.current = null;
+    }
+  }, []);
+
+  return { start, stop, abort, isSupported };
 }

package/supervisor/chat/src/lib/auth.ts

@@ -3,39 +3,36 @@ const TOKEN_KEY = 'fluxy_token';
 let authFailureCallback: (() => void) | null = null;
 
 export function getAuthToken(): string | null {
-    return localStorage.getItem(TOKEN_KEY);
+  return localStorage.getItem(TOKEN_KEY);
 }
 
 export function setAuthToken(token: string): void {
-    localStorage.setItem(TOKEN_KEY, token);
+  localStorage.setItem(TOKEN_KEY, token);
 }
 
 export function clearAuthToken(): void {
-    localStorage.removeItem(TOKEN_KEY);
+  localStorage.removeItem(TOKEN_KEY);
 }
 
 /** Register a callback for when a 401 is received (token expired mid-session) */
 export function onAuthFailure(cb: () => void): void {
-    authFailureCallback = cb;
+  authFailureCallback = cb;
 }
 
-export async function authFetch(
-    url: string,
-    options: RequestInit = {}
-): Promise<Response> {
-    const token = getAuthToken();
-    const headers = new Headers(options.headers);
-    if (token) {
-        headers.set('Authorization', `Bearer ${token}`);
-    }
-
-    const res = await fetch(url, { ...options, headers });
-
-    if (res.status === 401 && token) {
-        // Token was present but rejected — it expired
-        clearAuthToken();
-        authFailureCallback?.();
-    }
-
-    return res;
+export async function authFetch(url: string, options: RequestInit = {}): Promise<Response> {
+  const token = getAuthToken();
+  const headers = new Headers(options.headers);
+  if (token) {
+    headers.set('Authorization', `Bearer ${token}`);
+  }
+
+  const res = await fetch(url, { ...options, headers });
+
+  if (res.status === 401 && token) {
+    // Token was present but rejected — it expired
+    clearAuthToken();
+    authFailureCallback?.();
+  }
+
+  return res;
 }

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

@@ -2,137 +2,125 @@ type MessageHandler = (msg: any) => void;
 type StatusHandler = (connected: boolean) => void;
 
 interface QueuedMessage {
-    type: string;
-    data: any;
+  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;
+  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}`;
+      }
     }
-
-    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));
+    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);
     }
+  }
 
-    private startHeartbeat(): void {
-        this.stopHeartbeat();
-        this.heartbeatTimer = setInterval(() => {
-            if (this.ws?.readyState === WebSocket.OPEN) {
-                this.ws.send('ping');
-            }
-        }, 25_000);
-    }
+  get connected(): boolean {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
 
-    private stopHeartbeat(): void {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
+  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; }
+  }
 }