@mooncompany/uplink-chat 0.5.0

package/public/js/event-bus.js

@@ -0,0 +1,77 @@
+// ============================================
+// EVENT BUS MODULE
+// Observer pattern for cross-module communication
+// Replaces window.* patching pattern
+// ============================================
+
+const listeners = {};
+
+/**
+ * Subscribe to an event
+ * @param {string} event - Event name
+ * @param {Function} callback - Event handler
+ * @returns {Function} Unsubscribe function
+ */
+export function on(event, callback) {
+  if (!listeners[event]) listeners[event] = [];
+  listeners[event].push(callback);
+  
+  // Return unsubscribe function
+  return () => off(event, callback);
+}
+
+/**
+ * Unsubscribe from an event
+ * @param {string} event - Event name
+ * @param {Function} callback - Event handler to remove
+ */
+export function off(event, callback) {
+  if (!listeners[event]) return;
+  listeners[event] = listeners[event].filter(cb => cb !== callback);
+}
+
+/**
+ * Emit an event to all subscribers
+ * @param {string} event - Event name
+ * @param {*} data - Event data
+ */
+export function emit(event, data) {
+  if (!listeners[event]) return;
+  listeners[event].forEach(cb => {
+    try {
+      cb(data);
+    } catch (err) {
+      console.error(`[EventBus] Error in listener for "${event}":`, err);
+    }
+  });
+}
+
+/**
+ * Get count of listeners for an event (for debugging)
+ * @param {string} event - Event name
+ * @returns {number} Number of listeners
+ */
+export function listenerCount(event) {
+  return listeners[event] ? listeners[event].length : 0;
+}
+
+/**
+ * Clear all listeners for an event
+ * @param {string} event - Event name (optional, clears all if omitted)
+ */
+export function clear(event) {
+  if (event) {
+    delete listeners[event];
+  } else {
+    Object.keys(listeners).forEach(key => delete listeners[key]);
+  }
+}
+
+// Export singleton for backwards compatibility
+const EventBus = { on, off, emit, listenerCount, clear };
+export default EventBus;
+
+// Also expose on window for debugging
+if (typeof window !== 'undefined') {
+  window.UplinkEventBus = EventBus;
+}

package/public/js/fetch-utils.js

@@ -0,0 +1,171 @@
+// ============================================
+// FETCH UTILS MODULE
+// Unified fetch wrapper with hooks for logging, timeouts, and metrics
+// ============================================
+
+import { UplinkLogger } from './logger.js';
+
+// Store original fetch before any interception
+const originalFetch = window.fetch;
+
+// Hook registry
+const hooks = {
+  beforeRequest: [],  // (url, options) => modified options or void
+  afterResponse: [],  // (url, options, response, duration) => void
+  onError: []         // (url, options, error, duration) => void
+};
+
+// Default timeout (30 seconds)
+let defaultTimeout = 30000;
+
+/**
+ * Register a hook
+ * @param {string} type - 'beforeRequest', 'afterResponse', or 'onError'
+ * @param {Function} fn - Hook function
+ * @returns {Function} Unregister function
+ */
+function registerHook(type, fn) {
+  if (!hooks[type]) {
+    UplinkLogger.warn('FetchUtils: Unknown hook type', type);
+    return () => {};
+  }
+  hooks[type].push(fn);
+  return () => {
+    const idx = hooks[type].indexOf(fn);
+    if (idx > -1) hooks[type].splice(idx, 1);
+  };
+}
+
+/**
+ * Set default timeout for all requests
+ * @param {number} ms - Timeout in milliseconds
+ */
+function setFetchTimeout(ms) {
+  defaultTimeout = ms;
+}
+
+/**
+ * Enhanced fetch with timeout and hooks
+ * @param {string|Request} input - URL or Request object
+ * @param {Object} options - Fetch options (plus optional timeout)
+ * @returns {Promise<Response>}
+ */
+async function enhancedFetch(input, options = {}) {
+  const url = typeof input === 'string' ? input : input.url;
+  const startTime = Date.now();
+  
+  // Extract timeout from options or use default
+  const timeout = options.timeout ?? defaultTimeout;
+  const fetchOptions = { ...options };
+  delete fetchOptions.timeout;
+
+  // Run beforeRequest hooks
+  for (const hook of hooks.beforeRequest) {
+    try {
+      const modified = await hook(url, fetchOptions);
+      if (modified) Object.assign(fetchOptions, modified);
+    } catch (e) {
+      UplinkLogger.warn('FetchUtils: beforeRequest hook error', e);
+    }
+  }
+
+  // Create abort controller for timeout
+  const controller = new AbortController();
+  const existingSignal = fetchOptions.signal;
+  fetchOptions.signal = controller.signal;
+
+  // Set up timeout
+  let timeoutId = null;
+  if (timeout > 0) {
+    timeoutId = window.setTimeout(() => controller.abort(), timeout);
+  }
+
+  // Handle existing abort signal
+  if (existingSignal) {
+    existingSignal.addEventListener('abort', () => controller.abort());
+  }
+
+  try {
+    const response = await originalFetch(input, fetchOptions);
+    const duration = Date.now() - startTime;
+
+    // Clear timeout
+    if (timeoutId) window.clearTimeout(timeoutId);
+
+    // Run afterResponse hooks
+    for (const hook of hooks.afterResponse) {
+      try {
+        await hook(url, fetchOptions, response.clone(), duration);
+      } catch (e) {
+        UplinkLogger.warn('FetchUtils: afterResponse hook error', e);
+      }
+    }
+
+    return response;
+  } catch (error) {
+    const duration = Date.now() - startTime;
+
+    // Clear timeout
+    if (timeoutId) window.clearTimeout(timeoutId);
+
+    // Enhance timeout errors
+    if (error.name === 'AbortError' && duration >= timeout - 100) {
+      error.isTimeout = true;
+      error.message = `Request timeout after ${timeout}ms`;
+    }
+
+    // Run onError hooks
+    for (const hook of hooks.onError) {
+      try {
+        await hook(url, fetchOptions, error, duration);
+      } catch (e) {
+        UplinkLogger.warn('FetchUtils: onError hook error', e);
+      }
+    }
+
+    throw error;
+  }
+}
+
+/**
+ * Install the enhanced fetch globally
+ * Call this once after all hooks are registered
+ */
+function install() {
+  window.fetch = enhancedFetch;
+  UplinkLogger.debug('FetchUtils: Installed enhanced fetch');
+}
+
+/**
+ * Restore original fetch
+ */
+function uninstall() {
+  window.fetch = originalFetch;
+  UplinkLogger.debug('FetchUtils: Restored original fetch');
+}
+
+/**
+ * Get the original unmodified fetch
+ */
+function getOriginalFetch() {
+  return originalFetch;
+}
+
+// Export API
+export const UplinkFetch = {
+  registerHook,
+  setTimeout: setFetchTimeout,
+  install,
+  uninstall,
+  getOriginalFetch,
+  fetch: enhancedFetch
+};
+
+export { registerHook, setFetchTimeout, install, uninstall, getOriginalFetch, enhancedFetch };
+
+// Backward compat: assign to window
+window.UplinkFetch = UplinkFetch;
+
+// Auto-install enhanced fetch
+// Hooks can be registered before or after install - they're called dynamically
+install();

package/public/js/file-handler.js

@@ -0,0 +1,229 @@
+// ============================================
+// FILE HANDLER MODULE
+// Image and file upload logic with progress tracking
+// ============================================
+
+import { UplinkLogger } from './logger.js';
+import { UplinkSSEParser } from './utils/sse-parser.js';
+import { UplinkErrors } from './errors.js';
+
+// ============================================
+// UPLOAD WITH PROGRESS (XHR)
+// ============================================
+
+export function uploadWithProgress(url, formData, onProgress) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+
+    xhr.upload.addEventListener('progress', (e) => {
+      if (e.lengthComputable && onProgress) {
+        const percentComplete = Math.round((e.loaded / e.total) * 100);
+        onProgress(percentComplete);
+      }
+    });
+
+    xhr.addEventListener('load', () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        resolve({ ok: true, status: xhr.status, blob: xhr.response });
+      } else {
+        reject(new Error(`Upload failed: ${xhr.status}`));
+      }
+    });
+
+    xhr.addEventListener('error', () => reject(new Error('Network error during upload')));
+    xhr.addEventListener('abort', () => reject(new Error('Upload aborted')));
+
+    xhr.open('POST', url);
+    xhr.responseType = 'blob';
+    xhr.send(formData);
+  });
+}
+
+async function blobToStreamResponse(blob) {
+  const text = await blob.text();
+  return {
+    body: new ReadableStream({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode(text));
+        controller.close();
+      }
+    })
+  };
+}
+
+// ============================================
+// IMAGE UPLOAD
+// ============================================
+
+export async function sendImageMessage(imageUrl, caption, chat, skipAddMessage, imageTypingTimeoutMs) {
+  caption = caption || '';
+  imageTypingTimeoutMs = imageTypingTimeoutMs || 300000;
+
+  if (!skipAddMessage) chat.addMessage(caption, 'user', imageUrl);
+
+  const progressMsg = chat.addMessage('Uploading image...', 'system', null, false);
+  chat.showTyping(imageTypingTimeoutMs);
+
+  try {
+    const blobResponse = await fetch(imageUrl);
+    const blob = await blobResponse.blob();
+
+    const form = new FormData();
+    form.append('image', blob, 'image.jpg');
+    if (caption) form.append('caption', caption);
+
+    const uploadBlob = await uploadWithProgress('/api/image', form, (pct) => {
+      if (progressMsg && progressMsg.parentNode) {
+        const progressText = progressMsg.querySelector('.message-content');
+        if (progressText) {
+          progressText.textContent = `Uploading image... ${pct}%`;
+        }
+      }
+    });
+
+    if (progressMsg && progressMsg.parentNode) {
+      progressMsg.remove();
+    }
+
+    const streamResponse = await blobToStreamResponse(uploadBlob.blob);
+
+    let uploadResult = null;
+    await UplinkSSEParser.processStream(streamResponse, {
+      onData: (payload) => { uploadResult = payload; },
+      onError: (err) => {
+        UplinkLogger.warn('[Image Upload] SSE parse error:', err);
+      }
+    });
+
+    chat.hideTyping();
+
+    if (uploadResult?.response) {
+      if (uploadResult.imageUrl) {
+        chat.updateLastUserImageUrl(uploadResult.imageUrl);
+      }
+      chat.addMessage(uploadResult.response, 'assistant');
+      if (window.UplinkConnection?.markMessageSeen) {
+        window.UplinkConnection.markMessageSeen(null, 'assistant', uploadResult.response, Date.now());
+      }
+      const core = window.UplinkCore;
+      if (core?.audioResponses) {
+        const urls = uploadResult.audioUrls?.length
+          ? uploadResult.audioUrls
+          : (uploadResult.audioUrl ? [uploadResult.audioUrl] : []);
+        urls.forEach(url => chat.playAudio(url));
+      }
+    } else if (uploadResult?.error) {
+      const friendlyMsg = UplinkErrors.getFriendlyMessage(uploadResult.error) || uploadResult.error;
+      chat.addMessage(friendlyMsg, 'system', null, false);
+    } else {
+      chat.addMessage('No response received from image analysis', 'system', null, false);
+    }
+  } catch (uploadError) {
+    chat.hideTyping();
+    const friendlyMsg = UplinkErrors.getFriendlyMessage(uploadError) || 'Upload failed';
+    chat.addMessage(friendlyMsg, 'system', null, false);
+  }
+}
+
+// ============================================
+// FILE UPLOAD (non-image)
+// ============================================
+
+export async function sendFileMessage(fileInfo, caption, chat, imageTypingTimeoutMs) {
+  caption = caption || '';
+  imageTypingTimeoutMs = imageTypingTimeoutMs || 300000;
+
+  const icon = window.UplinkFiles?.getFileIcon?.(fileInfo.name) || '📎';
+  chat.addMessage(`${icon} ${fileInfo.name}${caption ? ': ' + caption : ''}`, 'user');
+
+  const progressMsg = chat.addMessage('Uploading file...', 'system', null, false);
+  chat.showTyping(imageTypingTimeoutMs);
+
+  try {
+    const form = new FormData();
+    form.append('file', fileInfo.blob, fileInfo.name);
+    if (caption) form.append('caption', caption);
+
+    const satelliteId = window.UplinkSatellites?.getCurrentSatellite() || 'main';
+    form.append('satelliteId', satelliteId);
+
+    const uploadBlob = await uploadWithProgress('/api/file', form, (pct) => {
+      if (progressMsg?.parentNode) {
+        const progressText = progressMsg.querySelector('.message-content');
+        if (progressText) progressText.textContent = `Uploading file... ${pct}%`;
+      }
+    });
+
+    if (progressMsg?.parentNode) progressMsg.remove();
+
+    const streamResponse = await blobToStreamResponse(uploadBlob.blob);
+
+    let result = null;
+    await UplinkSSEParser.processStream(streamResponse, {
+      onData: (payload) => { result = payload; },
+      onError: (err) => {
+        UplinkLogger.warn('[File Upload] SSE parse error:', err);
+      }
+    });
+
+    chat.hideTyping();
+
+    if (result?.response) {
+      chat.addMessage(result.response, 'assistant');
+      if (window.UplinkConnection?.markMessageSeen) {
+        window.UplinkConnection.markMessageSeen(null, 'assistant', result.response, Date.now());
+      }
+    } else if (result?.error) {
+      const friendlyMsg = UplinkErrors.getFriendlyMessage(result.error) || result.error;
+      chat.addMessage(friendlyMsg, 'system', null, false);
+    } else {
+      chat.addMessage('No response received for file upload', 'system', null, false);
+    }
+  } catch (err) {
+    chat.hideTyping();
+    if (progressMsg?.parentNode) progressMsg.remove();
+    const friendlyMsg = UplinkErrors.getFriendlyMessage(err) || 'File upload failed';
+    chat.addMessage(friendlyMsg, 'system', null, false);
+  }
+}
+
+// ============================================
+// IMAGE URL UPDATE
+// ============================================
+
+export function updateLastUserImageUrl(container, serverUrl) {
+  if (!container) return;
+
+  const userMsgs = container.querySelectorAll('.message.user');
+  for (let i = userMsgs.length - 1; i >= 0; i--) {
+    const img = userMsgs[i].querySelector('img');
+    if (img && (img.src.startsWith('data:') || img.src.includes('__pending_upload__'))) {
+      img.src = serverUrl;
+
+      if (window.UplinkStorage) {
+        window.UplinkStorage.updateLastImageUrl(serverUrl);
+      }
+
+      if (window.UplinkSatellites?.updateLastImageUrl) {
+        window.UplinkSatellites.updateLastImageUrl(serverUrl);
+      }
+      break;
+    }
+  }
+}
+
+// ============================================
+// PUBLIC API
+// ============================================
+
+export const UplinkFileHandler = {
+  sendImageMessage,
+  sendFileMessage,
+  updateLastUserImageUrl,
+  uploadWithProgress
+};
+
+// Backward compat: assign to window
+window.UplinkFileHandler = UplinkFileHandler;
+
+UplinkLogger.debug('FileHandler: Module loaded');