aimeat 1.40.1 → 2.1.0

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

@@ -0,0 +1,300 @@
+// GENERATED FILE — do not edit directly. Source: src/static/sdk-libs/speech/ (+ _core/).
+// Rebuild: pnpm build:sdk  ·  Served at /v1/libs/aimeat-speech.js (with a per-node config prelude).
+"use strict";
+(() => {
+  // src/static/sdk-libs/_core/namespace.js
+  function namespace() {
+    if (!window.AIMEAT) window.AIMEAT = {};
+    return window.AIMEAT;
+  }
+  function attach(key, value) {
+    const ns = namespace();
+    ns[key] = value;
+    return ns;
+  }
+
+  // src/static/sdk-libs/speech/index.js
+  var _listeners = {};
+  function emit(event, data) {
+    (_listeners[event] || []).forEach(function(fn) {
+      fn(data);
+    });
+  }
+  var _supported = {
+    get tts() {
+      return typeof window !== "undefined" && "speechSynthesis" in window;
+    },
+    get stt() {
+      return typeof window !== "undefined" && ("SpeechRecognition" in window || "webkitSpeechRecognition" in window);
+    }
+  };
+  var _ttsProvider = null;
+  var _sttProvider = null;
+  var _speaking = false;
+  var _ttsQueue = [];
+  var _listening = false;
+  var _recognition = null;
+  var _mediaRecorder = null;
+  var _voicesLoaded = false;
+  var _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();
+  }
+  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 !== void 0) utt.rate = opts.rate;
+      if (opts && opts.pitch !== void 0) utt.pitch = opts.pitch;
+      if (opts && opts.volume !== void 0) 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(void 0);
+      };
+      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(void 0);
+      };
+      _speaking = true;
+      speechSynthesis.speak(utt);
+    });
+  }
+  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);
+  }
+  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, final, confidence });
+          if (final && commands) matchCommand(text, commands);
+          if (final && !_recognition.continuous) {
+            resolve({ text, 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.start();
+    });
+  }
+  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) {
+        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, final: true, confidence });
+            resolve({ text, 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 || 5e3);
+        }
+      });
+    });
+  }
+  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);
+      }
+    });
+  }
+  var speech = {
+    say: function(text, opts) {
+      if (_speaking) {
+        _ttsQueue.push({ text, 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 {
+        }
+        _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;
+      });
+    }
+  };
+  attach("speech", speech);
+})();

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

@@ -0,0 +1,210 @@
+// GENERATED FILE — do not edit directly. Source: src/static/sdk-libs/storage/ (+ _core/).
+// Rebuild: pnpm build:sdk  ·  Served at /v1/libs/aimeat-storage.js (with a per-node config prelude).
+"use strict";
+(() => {
+  // src/static/sdk-libs/_core/config.js
+  function cfg() {
+    return window.__AIMEAT_SDK_CFG__ || { nodeId: "", baseUrl: "" };
+  }
+  function resolveNodeUrl() {
+    const meta = document.querySelector('meta[name="aimeat-node"]');
+    if (meta) return (meta.getAttribute("content") || "").replace(/\/$/, "");
+    if (location.protocol === "http:" || location.protocol === "https:") return location.origin;
+    return cfg().baseUrl;
+  }
+  var NODE_URL = resolveNodeUrl();
+  var APEX_URL = cfg().baseUrl;
+  var NODE_ID = cfg().nodeId;
+  var HEARTBEAT_MS = cfg().heartbeatMs || 3e4;
+
+  // src/static/sdk-libs/_core/session.js
+  function getSession(libLabel) {
+    const auth = window.AIMEAT && window.AIMEAT.auth;
+    if (!auth) {
+      throw new Error("AIMEAT.auth is required. Include aimeat-auth.js before " + (libLabel || "this library"));
+    }
+    const s = auth.getSession();
+    if (!s) throw new Error("Not logged in. Call AIMEAT.auth.login() first.");
+    return s;
+  }
+  function authFetch(path, opts, libLabel) {
+    return getSession(libLabel).fetch(path, opts);
+  }
+  function makeSession(libLabel) {
+    return {
+      getSession: () => getSession(libLabel),
+      authFetch: (path, opts) => authFetch(path, opts, libLabel)
+    };
+  }
+
+  // src/static/sdk-libs/_core/namespace.js
+  function namespace() {
+    if (!window.AIMEAT) window.AIMEAT = {};
+    return window.AIMEAT;
+  }
+  function attach(key, value) {
+    const ns = namespace();
+    ns[key] = value;
+    return ns;
+  }
+
+  // src/static/sdk-libs/storage/index.js
+  var { getSession: getSession2, authFetch: authFetch2 } = makeSession("aimeat-storage.js");
+  var 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) {
+        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") {
+        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 authFetch2("/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 = getSession2();
+      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 authFetch2("/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 = getSession2();
+      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 authFetch2("/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;
+      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);
+      const initRes = await authFetch2("/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;
+      const session = getSession2();
+      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) });
+      }
+      const completeRes = await authFetch2("/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 authFetch2("/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);
+          }
+        }
+      });
+    }
+  };
+  attach("storage", storage);
+})();