aimeat 1.40.1 → 2.1.0

package/dist/static/sdk-libs/speech/index.js

@@ -0,0 +1,321 @@
+/**
+ * @file speech/index.js
+ * @description Pilot migration of the aimeat-speech library (SDK-libs migration Phase 0). Exposes
+ *   `AIMEAT.speech` — text-to-speech, speech-to-text, voice-command matching, and a pluggable
+ *   provider architecture for cloud TTS/STT (ElevenLabs, Whisper, …). This is the real, JSDoc-typed
+ *   ESM source that esbuild bundles to the classic IIFE served, unchanged, at /v1/libs/aimeat-speech.js.
+ *   Behavior is identical to the former `aimeatSpeechLib()` string generator — the only differences
+ *   are: (1) the non-deterministic `Generated:` timestamp comment is gone, and (2) the global attach
+ *   goes through the shared `_core/namespace` helper instead of an inline `global.AIMEAT` block.
+ * @structure emit() · capability detection · TTS (native + cloud) · STT (native + cloud) · voice
+ *   command matching · the `speech` public API · attach('speech', …).
+ * @usage <script src="/v1/libs/aimeat-speech.js"></script>
+ *   AIMEAT.speech.say('Hello'); await AIMEAT.speech.listen();
+ * @version-history
+ *   v1.0.0 — 2026-07-19 — Migrated verbatim from src/routes/lib-speech.ts (SDK-libs migration Phase 0).
+ */
+import { attach } from '../_core/namespace.js';
+
+// ══════════════════════════════════════════════════════
+// Event system
+// ══════════════════════════════════════════════════════
+
+/** @type {Record<string, Array<(data: any) => void>>} */
+const _listeners = {};
+function emit(event, data) { (_listeners[event] || []).forEach(function (fn) { fn(data); }); }
+
+// ══════════════════════════════════════════════════════
+// Capability detection
+// ══════════════════════════════════════════════════════
+
+const _supported = {
+  get tts() { return typeof window !== 'undefined' && 'speechSynthesis' in window; },
+  get stt() { return typeof window !== 'undefined' && ('SpeechRecognition' in window || 'webkitSpeechRecognition' in window); },
+};
+
+// ══════════════════════════════════════════════════════
+// Provider slots
+// ══════════════════════════════════════════════════════
+
+/** @type {any} */
+let _ttsProvider = null;
+/** @type {any} */
+let _sttProvider = null;
+
+// ══════════════════════════════════════════════════════
+// TTS state
+// ══════════════════════════════════════════════════════
+
+let _speaking = false;
+/** @type {Array<{ text: string, opts: any }>} */
+let _ttsQueue = [];
+
+// ══════════════════════════════════════════════════════
+// STT state
+// ══════════════════════════════════════════════════════
+
+let _listening = false;
+/** @type {any} */
+let _recognition = null;
+/** @type {MediaRecorder | null} */
+let _mediaRecorder = null;
+
+// ══════════════════════════════════════════════════════
+// Voices
+// ══════════════════════════════════════════════════════
+
+let _voicesLoaded = false;
+/** @type {Array<{ name: string, lang: string }>} */
+let _voicesList = [];
+
+function loadVoices() {
+  if (!_supported.tts) return [];
+  _voicesList = speechSynthesis.getVoices().map(function (v) {
+    return { name: v.name, lang: v.lang };
+  });
+  _voicesLoaded = _voicesList.length > 0;
+  return _voicesList;
+}
+if (typeof window !== 'undefined' && _supported.tts) {
+  speechSynthesis.addEventListener('voiceschanged', loadVoices);
+  loadVoices();
+}
+
+// ══════════════════════════════════════════════════════
+// TTS: Native implementation
+// ══════════════════════════════════════════════════════
+
+function nativeSay(text, opts) {
+  return new Promise(function (resolve) {
+    const utt = new SpeechSynthesisUtterance(text);
+    if (opts && opts.lang) utt.lang = opts.lang;
+    if (opts && opts.rate !== undefined) utt.rate = opts.rate;
+    if (opts && opts.pitch !== undefined) utt.pitch = opts.pitch;
+    if (opts && opts.volume !== undefined) utt.volume = opts.volume;
+    if (opts && opts.voice) {
+      const voices = speechSynthesis.getVoices();
+      const match = voices.find(function (v) {
+        return v.name === opts.voice || v.name.indexOf(opts.voice) >= 0;
+      });
+      if (match) utt.voice = match;
+    }
+    utt.onstart = function () { emit('start', {}); };
+    utt.onend = function () { _speaking = false; processQueue(); emit('end', {}); resolve(undefined); };
+    utt.onboundary = function (e) {
+      if (e.name === 'word') emit('word', { word: text.substr(e.charIndex, e.charLength || 10).split(/\s/)[0], index: e.charIndex });
+    };
+    utt.onerror = function (e) { _speaking = false; processQueue(); emit('error', { error: e.error }); resolve(undefined); };
+    _speaking = true;
+    speechSynthesis.speak(utt);
+  });
+}
+
+// ══════════════════════════════════════════════════════
+// TTS: Cloud provider playback
+// ══════════════════════════════════════════════════════
+
+function cloudSay(text, opts) {
+  if (!_ttsProvider || !_ttsProvider.say) return Promise.resolve();
+  _speaking = true;
+  emit('start', {});
+  return _ttsProvider.say(text, opts || {}).then(function (blob) {
+    if (!blob) { _speaking = false; processQueue(); emit('end', {}); return; }
+    const ac = new (window.AudioContext || window.webkitAudioContext)();
+    return blob.arrayBuffer().then(function (ab) { return ac.decodeAudioData(ab); }).then(function (buf) {
+      const source = ac.createBufferSource();
+      source.buffer = buf;
+      source.connect(ac.destination);
+      source.onended = function () { _speaking = false; processQueue(); emit('end', {}); };
+      source.start();
+    });
+  }).catch(function (e) {
+    _speaking = false; processQueue();
+    emit('error', { error: e.message });
+  });
+}
+
+function processQueue() {
+  if (_ttsQueue.length > 0 && !_speaking) {
+    const next = _ttsQueue.shift();
+    if (next) doSay(next.text, next.opts);
+  }
+}
+
+function doSay(text, opts) {
+  if (_ttsProvider) return cloudSay(text, opts);
+  if (!_supported.tts) { console.warn('[aimeat-speech] TTS not supported in this browser'); return Promise.resolve(); }
+  return nativeSay(text, opts);
+}
+
+// ══════════════════════════════════════════════════════
+// STT: Native implementation
+// ══════════════════════════════════════════════════════
+
+function nativeListen(opts) {
+  return new Promise(function (resolve, reject) {
+    const SpeechRecog = window.SpeechRecognition || window.webkitSpeechRecognition;
+    if (!SpeechRecog) { reject(new Error('SpeechRecognition not supported')); return; }
+
+    _recognition = new SpeechRecog();
+    _recognition.lang = (opts && opts.lang) || 'en-US';
+    _recognition.continuous = (opts && opts.continuous) || false;
+    _recognition.interimResults = (opts && opts.interimResults) || false;
+
+    const commands = (opts && opts.commands) || null;
+
+    _recognition.onstart = function () { _listening = true; emit('listening', {}); };
+    _recognition.onresult = function (e) {
+      for (let i = e.resultIndex; i < e.results.length; i++) {
+        const result = e.results[i];
+        const text = result[0].transcript.trim();
+        const final = result.isFinal;
+        const confidence = result[0].confidence;
+        emit('result', { text: text, final: final, confidence: confidence });
+        if (final && commands) matchCommand(text, commands);
+        if (final && !_recognition.continuous) {
+          resolve({ text: text, confidence: confidence, lang: _recognition.lang });
+        }
+      }
+    };
+    _recognition.onerror = function (e) {
+      _listening = false;
+      emit('error', { error: e.error });
+      if (!_recognition.continuous) reject(new Error(e.error));
+    };
+    _recognition.onend = function () {
+      _listening = false;
+      emit('stopped', {});
+      if (opts && opts.continuous && _recognition) {
+        try { _recognition.start(); } catch { /* recognition already stopped */ }
+      }
+    };
+
+    _recognition.start();
+  });
+}
+
+// ══════════════════════════════════════════════════════
+// STT: Cloud provider (MediaRecorder -> blob -> provider)
+// ══════════════════════════════════════════════════════
+
+function cloudListen(opts) {
+  if (!_sttProvider || !_sttProvider.listen) return Promise.reject(new Error('No STT provider configured'));
+
+  return navigator.mediaDevices.getUserMedia({ audio: true }).then(function (stream) {
+    return new Promise(function (resolve, reject) {
+      /** @type {Blob[]} */
+      const chunks = [];
+      _mediaRecorder = new MediaRecorder(stream, { mimeType: 'audio/webm' });
+      _listening = true;
+      emit('listening', {});
+
+      _mediaRecorder.ondataavailable = function (e) { if (e.data.size > 0) chunks.push(e.data); };
+      _mediaRecorder.onstop = function () {
+        _listening = false;
+        stream.getTracks().forEach(function (t) { t.stop(); });
+        emit('stopped', {});
+        const blob = new Blob(chunks, { type: 'audio/webm' });
+        _sttProvider.listen(blob, opts || {}).then(function (result) {
+          const text = typeof result === 'string' ? result : (result.text || result.transcript || '');
+          const confidence = typeof result === 'object' ? (result.confidence || 1) : 1;
+          emit('result', { text: text, final: true, confidence: confidence });
+          resolve({ text: text, confidence: confidence, lang: (opts && opts.lang) || 'en-US' });
+        }).catch(function (e) {
+          emit('error', { error: e.message }); reject(e);
+        });
+      };
+
+      _mediaRecorder.start();
+      if (!(opts && opts.continuous)) {
+        setTimeout(function () {
+          if (_mediaRecorder && _mediaRecorder.state === 'recording') _mediaRecorder.stop();
+        }, (opts && opts.timeout) || 5000);
+      }
+    });
+  });
+}
+
+// ══════════════════════════════════════════════════════
+// Voice Command matching
+// ══════════════════════════════════════════════════════
+
+function matchCommand(text, commands) {
+  const lower = text.toLowerCase();
+  Object.keys(commands).forEach(function (pattern) {
+    const parts = pattern.toLowerCase().split(/\s+/);
+    const regex = '^' + parts.map(function (p) {
+      if (p.startsWith('*')) return '(.+)';
+      return p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }).join('\\s+') + '$';
+    const match = lower.match(new RegExp(regex));
+    if (match) {
+      const captures = match.slice(1);
+      commands[pattern].apply(null, captures);
+    }
+  });
+}
+
+// ══════════════════════════════════════════════════════
+// Public API
+// ══════════════════════════════════════════════════════
+
+const speech = {
+  say: function (text, opts) {
+    if (_speaking) {
+      _ttsQueue.push({ text: text, opts: opts });
+      return;
+    }
+    return doSay(text, opts);
+  },
+
+  stop: function () {
+    if (_supported.tts) speechSynthesis.cancel();
+    _speaking = false;
+    _ttsQueue = [];
+  },
+
+  get speaking() { return _speaking; },
+
+  voices: function (opts) {
+    if (!_voicesLoaded) loadVoices();
+    if (opts && opts.lang) {
+      const lang = opts.lang.toLowerCase();
+      return _voicesList.filter(function (v) { return v.lang.toLowerCase().startsWith(lang); });
+    }
+    return _voicesList;
+  },
+
+  listen: function (opts) {
+    if (_sttProvider) return cloudListen(opts);
+    return nativeListen(opts);
+  },
+
+  stopListening: function () {
+    if (_recognition) { _recognition.continuous = false; try { _recognition.stop(); } catch { /* already stopped */ } _recognition = null; }
+    if (_mediaRecorder && _mediaRecorder.state === 'recording') { _mediaRecorder.stop(); _mediaRecorder = null; }
+    _listening = false;
+  },
+
+  get listening() { return _listening; },
+
+  get supported() { return _supported; },
+
+  use: function (type, provider) {
+    if (type === 'tts') _ttsProvider = provider;
+    else if (type === 'stt') _sttProvider = provider;
+    else console.warn('[aimeat-speech] Unknown provider type:', type);
+  },
+
+  on: function (event, fn) {
+    if (!_listeners[event]) _listeners[event] = [];
+    _listeners[event].push(fn);
+  },
+
+  off: function (event, fn) {
+    if (!_listeners[event]) return;
+    _listeners[event] = _listeners[event].filter(function (f) { return f !== fn; });
+  },
+};
+
+// ── Expose globally ──
+attach('speech', speech);

package/dist/static/sdk-libs/storage/index.js

@@ -0,0 +1,189 @@
+/**
+ * @file storage/index.js
+ * @description The aimeat-storage library (SDK-libs migration Phase 2). Exposes AIMEAT.storage — the
+ *   file upload/download SDK: upload (File/Blob/base64, chunked for large files), download/metadata,
+ *   list/delete, publicUrl, and an enableDropZone() drag-&-drop helper. Over the AIMEAT.auth session,
+ *   with direct NODE_URL fetches for binary GET/HEAD/chunk PUT. Componentized ESM source esbuild
+ *   bundles to the IIFE served, unchanged, at /v1/libs/aimeat-storage.js. Ported verbatim from
+ *   lib-storage.ts; NODE_URL now comes from _core/config.
+ * @structure imports NODE_URL (config) + getSession/authFetch (session) + attach (namespace); the
+ *   `storage` object incl. uploadChunked + enableDropZone; attach('storage', …).
+ * @usage <script src="/v1/libs/aimeat-auth.js"></script><script src="/v1/libs/aimeat-storage.js"></script>
+ *   await AIMEAT.storage.upload(file); await AIMEAT.storage.download('key');
+ * @version-history
+ *   v1.0.0 — 2026-07-19 — Migrated from src/routes/lib-storage.ts (SDK-libs migration Phase 2).
+ */
+import { NODE_URL } from '../_core/config.js';
+import { makeSession } from '../_core/session.js';
+const { getSession, authFetch } = makeSession('aimeat-storage.js');
+import { attach } from '../_core/namespace.js';
+
+const storage = {
+  // Upload a file (File object, Blob, or base64 string)
+  async upload(fileOrData, opts) {
+    let key, data, mime_type, visibility;
+
+    if (fileOrData instanceof File || fileOrData instanceof Blob) {
+      // A bare Blob has no .name (only File does) — reading it yields undefined → the fallback.
+      const file = /** @type {File} */ (fileOrData);
+      key = opts?.key || file.name || ('file-' + Date.now());
+      mime_type = opts?.mime_type || file.type || 'application/octet-stream';
+      visibility = opts?.visibility || 'private';
+      const buf = await file.arrayBuffer();
+      const bytes = new Uint8Array(buf);
+      let binary = '';
+      for (let i = 0; i < bytes.length; i += 8192) {
+        binary += String.fromCharCode.apply(null, bytes.subarray(i, i + 8192));
+      }
+      data = btoa(binary);
+    } else if (typeof fileOrData === 'string') {
+      // Assume base64
+      key = opts?.key || ('file-' + Date.now());
+      data = fileOrData;
+      mime_type = opts?.mime_type || 'application/octet-stream';
+      visibility = opts?.visibility || 'private';
+    } else {
+      throw new Error('upload() expects a File, Blob, or base64 string');
+    }
+
+    const res = await authFetch('/v1/storage', {
+      method: 'POST',
+      body: JSON.stringify({ key, data, mime_type, visibility }),
+    });
+    if (!res.ok) throw new Error(res.error?.message || 'Upload failed');
+    return res.data;
+  },
+
+  // Download a file as Blob
+  async download(key) {
+    const session = getSession();
+    const jwt = session.jwt;
+    const r = await fetch(NODE_URL + '/v1/storage/' + encodeURIComponent(key), {
+      headers: { 'Authorization': 'Bearer ' + jwt },
+    });
+    if (!r.ok) throw new Error('Download failed: ' + r.status);
+    return r.blob();
+  },
+
+  // Get a direct URL for embedding (e.g. in <img src="">)
+  // Note: requires auth header, so only works with public files or session.fetch
+  publicUrl(key) {
+    return NODE_URL + '/v1/storage/' + encodeURIComponent(key);
+  },
+
+  // List all files
+  async list() {
+    const res = await authFetch('/v1/storage');
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to list files');
+    return res.data;
+  },
+
+  // Get file metadata (HEAD request)
+  async metadata(key) {
+    const session = getSession();
+    const jwt = session.jwt;
+    const r = await fetch(NODE_URL + '/v1/storage/' + encodeURIComponent(key), {
+      method: 'HEAD',
+      headers: { 'Authorization': 'Bearer ' + jwt },
+    });
+    if (!r.ok) throw new Error('Metadata fetch failed: ' + r.status);
+    return {
+      contentType: r.headers.get('Content-Type'),
+      contentLength: parseInt(r.headers.get('Content-Length') || '0'),
+      visibility: r.headers.get('X-AIMEAT-Visibility'),
+      createdAt: r.headers.get('X-AIMEAT-Created'),
+    };
+  },
+
+  // Delete a file
+  async delete(key) {
+    const res = await authFetch('/v1/storage/' + encodeURIComponent(key), { method: 'DELETE' });
+    if (!res.ok) throw new Error(res.error?.message || 'Delete failed');
+    return res.data;
+  },
+
+  // ── Chunked upload for large files ──
+  async uploadChunked(file, opts) {
+    const chunkSize = opts?.chunkSize || (1024 * 1024); // 1MB default
+    const key = opts?.key || file.name || ('file-' + Date.now());
+    const mime_type = opts?.mime_type || file.type || 'application/octet-stream';
+    const visibility = opts?.visibility || 'private';
+    const totalChunks = Math.ceil(file.size / chunkSize);
+
+    // Init
+    const initRes = await authFetch('/v1/storage/upload/init', {
+      method: 'POST',
+      body: JSON.stringify({ key, mime_type, visibility, chunk_size: chunkSize, total_chunks: totalChunks }),
+    });
+    if (!initRes.ok) throw new Error(initRes.error?.message || 'Chunked upload init failed');
+    const uploadId = initRes.data.upload_id;
+
+    // Upload chunks
+    const session = getSession();
+    for (let i = 0; i < totalChunks; i++) {
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, file.size);
+      const chunk = file.slice(start, end);
+      const buf = await chunk.arrayBuffer();
+
+      const r = await fetch(NODE_URL + '/v1/storage/upload/' + uploadId + '/' + i, {
+        method: 'PUT',
+        headers: {
+          'Authorization': 'Bearer ' + session.jwt,
+          'Content-Type': 'application/octet-stream',
+        },
+        body: buf,
+      });
+      if (!r.ok) throw new Error('Chunk ' + i + ' upload failed: ' + r.status);
+      if (opts?.onProgress) opts.onProgress({ chunk: i, total: totalChunks, percent: Math.round(((i + 1) / totalChunks) * 100) });
+    }
+
+    // Complete
+    const completeRes = await authFetch('/v1/storage/upload/' + uploadId + '/complete', { method: 'POST' });
+    if (!completeRes.ok) throw new Error(completeRes.error?.message || 'Chunked upload complete failed');
+    return completeRes.data;
+  },
+
+  // Abort a chunked upload
+  async abortUpload(uploadId) {
+    const res = await authFetch('/v1/storage/upload/' + uploadId, { method: 'DELETE' });
+    if (!res.ok) throw new Error(res.error?.message || 'Abort failed');
+    return res.data;
+  },
+
+  // ── Drag & Drop helper ──
+  enableDropZone(selector, opts) {
+    const el = /** @type {HTMLElement} */ (typeof selector === 'string' ? document.querySelector(selector) : selector);
+    if (!el) throw new Error('Drop zone element not found: ' + selector);
+
+    const accept = opts?.accept || '*/*';
+    const maxSize = opts?.maxSize || (10 * 1024 * 1024);
+
+    el.addEventListener('dragover', (e) => { e.preventDefault(); el.style.outline = '2px dashed #38bdf8'; });
+    el.addEventListener('dragleave', () => { el.style.outline = ''; });
+    el.addEventListener('drop', async (e) => {
+      e.preventDefault();
+      el.style.outline = '';
+      const files = Array.from(e.dataTransfer.files);
+      for (const file of files) {
+        if (accept !== '*/*' && !file.type.match(accept.replace('*', '.*'))) {
+          if (opts?.onError) opts.onError(new Error('File type not accepted: ' + file.type));
+          continue;
+        }
+        if (file.size > maxSize) {
+          if (opts?.onError) opts.onError(new Error('File too large: ' + file.name + ' (' + file.size + ' bytes)'));
+          continue;
+        }
+        try {
+          const ref = await storage.upload(file, opts);
+          if (opts?.onUpload) opts.onUpload(ref, file);
+        } catch (err) {
+          if (opts?.onError) opts.onError(err);
+        }
+      }
+    });
+  },
+};
+
+// ── Expose globally ──
+attach('storage', storage);