aimeat 3.1.0 → 3.3.0

package/dist/public/js/services/chat.js

@@ -0,0 +1,190 @@
+/**
+ * @file chat.js
+ * @description Frontend service for the built-in chat agent: the conversations, and one turn read
+ *   as it arrives.
+ *
+ *   The turn is the reason this is not four `api()` calls. It is `text/event-stream` over a POST, so
+ *   `EventSource` cannot open it — that only does GET, and the message has to go in a body. The
+ *   stream is read with `fetch` and a reader, and the frames are parsed here rather than in the view,
+ *   because a half-frame at a chunk boundary is a protocol detail and not something a component
+ *   should know about.
+ * @structure
+ *   status / listThreads / createThread / getThread / deleteThread / resetThread / streamTurn
+ *   speakToText — a recording becomes text the person can read before they send it
+ * @usage
+ *   import * as chat from '/js/services/chat.js';
+ *   for await (const u of chat.streamTurn(threadId, 'build me pong')) { … }
+ * @version-history
+ *   v1.1.0 — 2026-08-16 — speakToText: a spoken message goes through storage and comes back as text.
+ *   v1.0.0 — 2026-08-16 — Initial.
+ */
+import { api, apiGet } from '/js/api.js';
+import { authHeaders, getNodeUrl } from '/js/services/auth.js';
+
+const enc = encodeURIComponent;
+
+/** Does this node have a chat agent, what is it called, and what is left to spend. */
+export async function status() {
+    return apiGet('/v1/chat/status');
+}
+
+/** Open conversations, newest first, without their turns. */
+export async function listThreads() {
+    return apiGet('/v1/chat/threads');
+}
+
+/** Start one. The title is a placeholder until the first message replaces it. */
+export async function createThread(title) {
+    return api('/v1/chat/threads', { method: 'POST', body: JSON.stringify({ title }) });
+}
+
+/** One conversation with every turn it holds. */
+export async function getThread(id) {
+    return apiGet(`/v1/chat/threads/${enc(id)}`);
+}
+
+export async function deleteThread(id) {
+    return api(`/v1/chat/threads/${enc(id)}`, { method: 'DELETE' });
+}
+
+/**
+ * Forget the agent session, keep the conversation.
+ *
+ * What this is for: the session's credential carries the scopes it was minted with, so changing the
+ * chat agent's permissions in the Agents tab reaches the chat only once the session is replaced.
+ */
+export async function resetThread(id) {
+    return api(`/v1/chat/threads/${enc(id)}/reset`, { method: 'POST' });
+}
+
+/**
+ * Send one message and yield each update as it arrives.
+ *
+ * Yields the server's own events: `text` and `thought` as words are written, `tool_call` as each
+ * call starts and finishes, `done` at the end, and `error` when the turn could not run. A turn that
+ * ends without a verdict yields one `error` of its own rather than stopping silently, because a
+ * conversation that just stops is indistinguishable from one still thinking.
+ *
+ * `signal` aborts the read. The turn keeps running on the node; the connection is what closes.
+ */
+export async function* streamTurn(id, text, signal) {
+    const res = await fetch(`${getNodeUrl()}/v1/chat/threads/${enc(id)}/turn`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'text/event-stream', ...authHeaders() },
+        body: JSON.stringify({ text }),
+        signal,
+    });
+
+    if (!res.ok) {
+        // A refusal arrives as ordinary JSON: the stream never opened, so there is nothing to read.
+        // A refusal that is not JSON leaves the status as the only fact there is, and the status is
+        // what the person is shown. Nothing is hidden by not parsing further.
+        const body = await res.json()
+            // eslint-disable-next-line aimeat/no-silent-catch -- the status below carries the reason
+            .catch(() => null);
+        yield { kind: 'error', message: body?.error?.message || `The node refused the message (${res.status}).` };
+        return;
+    }
+    if (!res.body) {
+        yield { kind: 'error', message: 'This browser cannot read a streamed answer.' };
+        return;
+    }
+
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let sawVerdict = false;
+
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+
+            // Frames are separated by a blank line. Anything after the last one is a partial frame
+            // and stays in the buffer until the rest of it arrives.
+            let cut;
+            while ((cut = buffer.indexOf('\n\n')) !== -1) {
+                const frame = buffer.slice(0, cut);
+                buffer = buffer.slice(cut + 2);
+                for (const line of frame.split('\n')) {
+                    if (!line.startsWith('data:')) continue; // `:open` and `:keepalive` are comments
+                    let update;
+                    try {
+                        update = JSON.parse(line.slice(5).trim());
+                    } catch (err) {
+                        // One malformed frame is not the turn failing. Say so once and keep reading;
+                        // dropping the whole stream over a bad line would lose the answer as well.
+                        console.warn('[chat] skipped an unreadable frame:', err.message);
+                        continue;
+                    }
+                    if (update.kind === 'done' || update.kind === 'error') sawVerdict = true;
+                    yield update;
+                }
+            }
+        }
+    } finally {
+        // eslint-disable-next-line aimeat/no-silent-catch -- cancelling a stream that already ended is the normal case
+        reader.cancel().catch(() => { /* the stream is already gone; nothing to recover */ });
+    }
+
+    if (!sawVerdict) {
+        yield { kind: 'error', message: 'The connection closed before the answer finished.' };
+    }
+}
+
+/**
+ * Turn a recording into text.
+ *
+ * The clip goes to storage first and the node is handed a key, never the bytes: a minute of speech
+ * is megabytes, and base64 in a JSON body inflates it by a third before hitting a body limit that
+ * has nothing to do with the storage quota. The same path the inbox already uses for a voice
+ * message, for the same reason.
+ *
+ * The text comes back to the composer rather than being sent. A person should read what the machine
+ * heard before it becomes something they asked for.
+ */
+export async function speakToText(file) {
+    const rand = Math.random().toString(36).slice(2, 8);
+    const key = `chat-voice/${Date.now()}-${rand}.${(file.type.split('/')[1] || 'webm').split(';')[0]}`;
+    const mime = file.type || 'application/octet-stream';
+
+    const mint = await api('/v1/storage', {
+        method: 'POST',
+        body: JSON.stringify({ key, mime_type: mime, visibility: 'private', mode: 'presigned' }),
+    });
+    const uploadUrl = mint?.data?.upload_url;
+    if (!uploadUrl) throw new Error(mint?.error?.message || 'The node would not accept the recording.');
+
+    // Checked before the token is spent: it is single-use, so an oversized PUT burns it and answers
+    // a bare 413 instead of naming the limit.
+    const maxBytes = Number(mint?.data?.max_size_bytes) || 0;
+    if (maxBytes && file.size > maxBytes) {
+        throw new Error(`That recording is ${(file.size / 1048576).toFixed(1)} MB; this node accepts ${(maxBytes / 1048576).toFixed(0)} MB.`);
+    }
+
+    // Plain fetch, deliberately not api(): the presigned token IS the capability, so no
+    // Authorization header, and a retry on a consumed one-shot token answers 409 TOKEN_USED.
+    const put = await fetch(uploadTarget(uploadUrl), { method: 'PUT', headers: { 'Content-Type': mime }, body: file });
+    if (!put.ok) throw new Error(`The recording could not be stored (${put.status}).`);
+
+    const res = await api('/v1/ai/transcribe', {
+        method: 'POST',
+        body: JSON.stringify({ storage_key: key, mime, app_id: 'chat' }),
+        timeoutMs: 180_000,
+        retries: 0,
+    });
+    if (res?.ok === false) throw new Error(res.error?.message || 'The recording could not be transcribed.');
+    return String(res?.data?.text ?? '').trim();
+}
+
+/** The node mints an absolute upload URL. Collapse it to a path on the same origin so the PUT stays
+ *  a plain request rather than a preflighted one. */
+function uploadTarget(url) {
+    try {
+        const u = new URL(url, window.location.origin);
+        return u.origin === window.location.origin ? u.pathname + u.search : u.href;
+    } catch {
+        return url;   // an unparseable URL is used verbatim; the PUT above reports the failure
+    }
+}

package/dist/public/js/services/organism-roles.js

@@ -0,0 +1,51 @@
+/**
+ * @file organism-roles.js
+ * @description Who holds an organism and who may act in it: owners (add, remove, hand over),
+ *   admins, member removal and bans. Extracted from organisms.js when that file passed 800 lines;
+ *   the calls are unchanged and organisms.js re-exports every one of them.
+ *
+ *   Ownership is PLURAL. addOwner is additive — the caller keeps everything — and the last owner
+ *   cannot be removed, because an organism with no owner is the one state nobody inside it can
+ *   repair. transferOwnership is the two steps in one call, kept for what already used it.
+ * @structure removeMember · unbanMember · transferOwnership · addOwner · removeOwner · addAdmin · removeAdmin
+ * @usage import { addOwner } from '/js/services/organism-roles.js';
+ * @version-history
+ *   v1.0.0 — 2026-08-15 — Pure extraction from organisms.js, plus addOwner/removeOwner.
+ */
+import { apiPost, apiDelete } from '/js/api.js';
+
+/** Remove (revoke) a member's organism access. Creator/admin only. Pass ban=true to block re-join. */
+export async function removeMember(id, memberGhii, ban = false) {
+  const suffix = ban ? '?ban=1' : '';
+  return apiDelete(`/v1/organisms/${encodeURIComponent(id)}/members/${encodeURIComponent(memberGhii)}${suffix}`);
+}
+
+/** Lift a ban on a previously-blocked owner. Creator/admin only. */
+export async function unbanMember(id, memberGhii) {
+  return apiPost(`/v1/organisms/${encodeURIComponent(id)}/members/${encodeURIComponent(memberGhii)}/unban`, {});
+}
+
+/** Transfer ownership to an existing active member. Creator only. */
+export async function transferOwnership(id, toGhii) {
+  return apiPost(`/v1/organisms/${encodeURIComponent(id)}/transfer`, { to: toGhii });
+}
+
+/** Add a co-owner. Additive: the caller keeps everything they had. */
+export async function addOwner(id, ghii) {
+  return apiPost(`/v1/organisms/${encodeURIComponent(id)}/owners`, { ghii });
+}
+
+/** Take an owner off the organism; they stay as an admin. The last owner cannot be removed. */
+export async function removeOwner(id, ghii) {
+  return apiDelete(`/v1/organisms/${encodeURIComponent(id)}/owners/${encodeURIComponent(ghii)}`);
+}
+
+/** Add admin. */
+export async function addAdmin(id, targetGhii) {
+  return apiPost(`/v1/organisms/${encodeURIComponent(id)}/admins`, { target_ghii: targetGhii });
+}
+
+/** Remove admin. */
+export async function removeAdmin(id, ghii) {
+  return apiDelete(`/v1/organisms/${encodeURIComponent(id)}/admins/${encodeURIComponent(ghii)}`);
+}

package/dist/public/js/services/organisms.js

@@ -184,21 +184,11 @@ export async function searchOrganism(id, q, ws) {
   return apiGet(`/v1/organisms/${encodeURIComponent(id)}/search?${params.toString()}`);
 }
 
-/** Remove (revoke) a member's organism access. Creator/admin only. Pass ban=true to block re-join. */
-export async function removeMember(id, memberGhii, ban = false) {
-  const suffix = ban ? '?ban=1' : '';
-  return apiDelete(`/v1/organisms/${encodeURIComponent(id)}/members/${encodeURIComponent(memberGhii)}${suffix}`);
-}
-
-/** Lift a ban on a previously-blocked owner. Creator/admin only. */
-export async function unbanMember(id, memberGhii) {
-  return apiPost(`/v1/organisms/${encodeURIComponent(id)}/members/${encodeURIComponent(memberGhii)}/unban`, {});
-}
-
-/** Transfer ownership to an existing active member. Creator only. */
-export async function transferOwnership(id, toGhii) {
-  return apiPost(`/v1/organisms/${encodeURIComponent(id)}/transfer`, { to: toGhii });
-}
+// Who holds this organism and who may act in it: owners, admins, removal and bans. Pure
+// extraction to a sibling (max-file-lines); re-exported so every caller keeps its import.
+export {
+  removeMember, unbanMember, transferOwnership, addOwner, removeOwner, addAdmin, removeAdmin,
+} from '/js/services/organism-roles.js';
 
 /** Invite an owner by bare name, optionally with an org role + invite-time workspace grants
  *  ({ role: 'member'|'admin', workspaces: [{ws, role: 'viewer'|'contributor'}] }). Creator/admin only. */
@@ -280,16 +270,6 @@ export async function detachAgent(id, agentGaii) {
   return apiDelete(`/v1/organisms/${encodeURIComponent(id)}/agents/${encodeURIComponent(agentGaii)}`);
 }
 
-/** Add admin. */
-export async function addAdmin(id, targetGhii) {
-  return apiPost(`/v1/organisms/${encodeURIComponent(id)}/admins`, { target_ghii: targetGhii });
-}
-
-/** Remove admin. */
-export async function removeAdmin(id, ghii) {
-  return apiDelete(`/v1/organisms/${encodeURIComponent(id)}/admins/${encodeURIComponent(ghii)}`);
-}
-
 /** Archive / unarchive organism content (creator/admin). `target` = { level, ws?, namespace?, key? }.
  *  Archived content is read-only and hidden from AI materials (overview/read/search) but stays in the
  *  archive search; archiving a container cascades, unarchiving uses smart restore. */

package/dist/public/js/services/speech-reader.js

@@ -19,6 +19,9 @@
  * @usage import { speak, stop, subscribeSpeech } from '/js/services/speech-reader.js';
  *   speak('msg-42', textToParagraphs(msg.body));
  * @version-history
+ *   v1.1.0 — 2026-08-16 — primeSpeech(): one silent utterance inside a user gesture, so automatic
+ *     read-aloud is not a no-op on iOS. It refuses without a gesture and refuses SILENTLY, which is
+ *     the hardest kind of missing sound to chase.
  *   v1.0.0 — 2026-07-31 — Initial version: extracted the Sanomat read-aloud pacing into a shared SPA
  *     service so the Inbox thread (and any later view) can speak its content.
  */
@@ -212,6 +215,29 @@ function speakNext(lang, voice) {
   speechSynthesis.speak(utt);
 }
 
+/**
+ * Wake the speech engine inside a user gesture.
+ *
+ * iOS refuses `speechSynthesis.speak()` unless the page has spoken at least once from a real tap,
+ * and it refuses SILENTLY: automatic read-aloud simply never makes a sound, with no error to find.
+ * Speaking one empty utterance in the same click that starts the work removes that, costs nothing
+ * audible, and is a no-op on every other platform.
+ */
+let _primed = false;
+export function primeSpeech() {
+  if (_primed || !isSpeechSupported()) return;
+  _primed = true;
+  try {
+    const utt = new SpeechSynthesisUtterance('');
+    utt.volume = 0;
+    speechSynthesis.speak(utt);
+  } catch (err) {
+    // A browser refusing here IS the answer: it will refuse the real utterance too, and there is
+    // nothing to recover. Said out loud so a silent reader has a trace to find.
+    console.warn('[speech] the engine refused to prime:', err.message);
+  }
+}
+
 /** Start reading `paragraphs` under `id`. Any reading already in progress is cancelled first — one
  *  reader at a time. Returns false when there is nothing speakable (or no speech support). */
 export function speak(id, paragraphs, opts) {

package/dist/public/lib/VENDORED.md

@@ -27,6 +27,7 @@ with per-lib AI docs + changelogs) — keep this table and the registry in sync.
 | `toastui/toastui-editor-all.min.js` + `.min.css` | TOAST UI Editor | (SPA-internal) | — | `https://uicdn.toast.com` | MIT |
 | `pdfjs@6/pdf.min.mjs` + `pdf.worker.min.mjs` | `pdfjs-dist` (ESM + worker) | 6.1.200 | `pdfjs` | `https://cdn.jsdelivr.net/npm/pdfjs-dist@6.1.200/build/` | Apache-2.0 |
 | `ffmpeg-core@0.12.6/ffmpeg-core.js` + `.umd.js` + `ffmpeg-core.wasm` | `@ffmpeg/core` (ffmpeg 5.1.4, single-threaded) | 0.12.6 | `ffmpeg-core` | `https://unpkg.com/@ffmpeg/core@0.12.6/dist/esm/` (UMD loader from `dist/umd/`) | GPL-2.0-or-later (the compiled ffmpeg: `--enable-gpl --enable-libx264 --enable-libx265`; the npm `license: MIT` covers only the packaging) |
+| `duckdb-wasm@1.32.0/duckdb-browser.js` + `duckdb-browser-eh.worker.js` + `duckdb-eh.wasm` + `extensions/v1.4.3/wasm_eh/parquet.duckdb_extension.wasm` | `@duckdb/duckdb-wasm` (eh = single-threaded) + `apache-arrow` bundled in | 1.32.0 (arrow 17.0.0) | `duckdb-wasm` | built by `aimeat/scripts/vendor-duckdb-wasm.mjs`; the two .wasm files fetched by `pnpm vendor:libs` | MIT (arrow: Apache-2.0) |
 | `yaml.mjs` | `yaml` (ESM) | 2.x | `yaml` | jsdelivr | ISC |
 | `preact.mjs`, `preact-hooks.mjs`, `htm.mjs`, `minidenticons.min.js` | preact / htm / minidenticons (ESM) | (SPA-internal, importmap) | — | jsdelivr | MIT |
 | `live-updates.js` | AIMEAT-local (SSE ESM wrapper) | (SPA-internal) | — | this repo | MIT |