aimeat 3.2.0 → 3.3.1

package/dist/public/css/views/chat.css

@@ -0,0 +1,388 @@
+/**
+ * @file chat.css
+ * @description Styles for the chat page: the conversation list, the turns, the work log under each
+ *   one, and the composer. Two panes on a desktop, one at a time on a phone.
+ *
+ *   The work log is styled to be read, not hidden. It is the evidence that what the agent said it
+ *   did, it did, and folding it away by default would turn the page back into something a person has
+ *   to take on trust. All colours and spacing come from theme.css so it flips with the theme.
+ *
+ *   NOTE: this file must be linked in spa.html (useViewCSS is a no-op).
+ * @version-history
+ *   v1.1.0 — 2026-08-16 — The recorder beside the send button, and the read-aloud control on a turn.
+ *   v1.0.0 — 2026-08-16 — Initial.
+ */
+
+/* ── Layout ── */
+.chat-view {
+  display: grid;
+  grid-template-columns: 260px 1fr;
+  gap: 16px;
+  max-width: 1100px;
+  margin: 0 auto;
+  padding: 16px;
+  height: calc(100dvh - 120px);
+  /* Low enough that a short window (a laptop with a docked terminal, 1280x460) still puts the
+     composer on screen. A taller floor pushed it 70px below the fold, and the composer is the one
+     control the page exists for. */
+  min-height: 320px;
+}
+
+.chat-view--signin {
+  display: block;
+  height: auto;
+}
+
+/* ── The conversation list ── */
+.chat-threads {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  min-height: 0;
+  overflow-y: auto;
+  padding-right: 4px;
+}
+
+.chat-new { width: 100%; }
+
+/* The way back out of the list. Only a phone needs it: on a desktop the list and the conversation
+   are both on screen, so there is nothing to go back from. */
+.chat-threads-close { display: none; }
+
+.chat-threads-empty {
+  color: var(--text-muted);
+  font-size: 0.85rem;
+  line-height: 1.5;
+  margin: 0;
+}
+
+.chat-thread-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.chat-thread {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  border-radius: var(--radius-sm);
+}
+
+.chat-thread--active { background: var(--bg-surface); }
+
+.chat-thread-open {
+  flex: 1 1 auto;
+  min-width: 0;
+  text-align: left;
+  background: none;
+  border: none;
+  cursor: pointer;
+  padding: 8px 10px;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  color: inherit;
+  font: inherit;
+}
+
+.chat-thread-title {
+  font-size: 0.9rem;
+  font-weight: 600;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.chat-thread-sub {
+  font-size: 0.75rem;
+  color: var(--text-muted);
+}
+
+.chat-thread-del {
+  flex: 0 0 auto;
+  padding: 4px 8px;
+  opacity: 0;
+  transition: opacity 0.15s;
+}
+
+.chat-thread:hover .chat-thread-del,
+.chat-thread--active .chat-thread-del { opacity: 1; }
+
+/* ── The conversation ── */
+.chat-main {
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  overflow: hidden;
+}
+
+.chat-head {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.chat-title {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 600;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+/* The list is always visible on a desktop, so its toggle would be a button that does nothing. */
+.chat-list-toggle { display: none; }
+
+.chat-status {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-wrap: wrap;
+  padding: 6px 16px;
+  font-size: 0.75rem;
+  color: var(--text-muted);
+  border-bottom: 1px solid var(--border-subtle);
+  background: var(--bg-surface);
+}
+
+.chat-status-agent { font-family: var(--font-mono); }
+.chat-status-reset { margin-left: auto; font-size: 0.75rem; padding: 2px 8px; }
+
+.chat-scroll {
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow-y: auto;
+  padding: 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+
+.chat-welcome {
+  color: var(--text-muted);
+  max-width: 46ch;
+  margin: auto;
+  text-align: center;
+}
+
+.chat-welcome h2 {
+  font-size: 1.1rem;
+  margin: 0 0 6px;
+  color: var(--text-primary);
+}
+
+.chat-welcome p { margin: 0; line-height: 1.6; font-size: 0.9rem; }
+
+/* ── One turn ── */
+.chat-turn {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  max-width: 85%;
+}
+
+.chat-turn--user { align-self: flex-end; align-items: flex-end; }
+.chat-turn--agent { align-self: flex-start; }
+
+.chat-bubble {
+  padding: 10px 14px;
+  border-radius: var(--radius);
+  background: var(--bg-surface);
+  line-height: 1.6;
+  font-size: 0.92rem;
+  overflow-wrap: anywhere;
+}
+
+.chat-turn--user .chat-bubble {
+  background: var(--accent-subtle);
+  border: 1px solid var(--accent-border);
+}
+
+.chat-said { margin: 0; white-space: pre-wrap; }
+
+.chat-thinking {
+  margin: 0;
+  color: var(--text-muted);
+  font-style: italic;
+}
+
+.chat-meta {
+  display: flex;
+  gap: 8px;
+  font-size: 0.7rem;
+  color: var(--text-muted);
+  padding: 0 4px;
+}
+
+.chat-model { font-family: var(--font-mono); }
+
+/* ── The work log ── */
+.chat-work {
+  margin-top: 10px;
+  border-top: 1px solid var(--border-subtle);
+  padding-top: 8px;
+}
+
+.chat-work-head {
+  font-size: 0.7rem;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--text-muted);
+  margin-bottom: 4px;
+}
+
+.chat-work-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.chat-work-line {
+  display: flex;
+  gap: 8px;
+  align-items: baseline;
+  font-size: 0.78rem;
+  font-family: var(--font-mono);
+}
+
+.chat-work-status {
+  flex: 0 0 auto;
+  min-width: 68px;
+  color: var(--text-muted);
+}
+
+.chat-work-line--completed .chat-work-status { color: var(--success, var(--text-secondary)); }
+.chat-work-line--failed .chat-work-status { color: var(--accent); }
+
+.chat-work-title {
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+/* ── A turn that could not run ── */
+.chat-error {
+  align-self: stretch;
+  border: 1px solid var(--accent-border);
+  background: var(--accent-subtle);
+  border-radius: var(--radius-sm);
+  padding: 10px 14px;
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.chat-error-msg {
+  margin: 0;
+  flex: 1 1 240px;
+  font-size: 0.85rem;
+  line-height: 1.5;
+}
+
+/* ── The composer ── */
+.chat-composer {
+  border-top: 1px solid var(--border-subtle);
+  padding: 10px 16px;
+  background: var(--bg-card);
+}
+
+.chat-composer-note {
+  margin: 0 0 6px;
+  font-size: 0.78rem;
+  color: var(--text-muted);
+  line-height: 1.5;
+}
+
+.chat-composer-row {
+  display: flex;
+  gap: 8px;
+  align-items: flex-end;
+}
+
+.chat-input {
+  flex: 1 1 auto;
+  min-width: 0;
+  resize: none;
+  max-height: 200px;
+  padding: 10px 12px;
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  background: var(--bg-input);
+  color: inherit;
+  font: inherit;
+  font-size: 0.92rem;
+  line-height: 1.5;
+}
+
+.chat-input:focus {
+  outline: none;
+  border-color: var(--border-focus);
+  background: var(--bg-input-focus);
+}
+
+.chat-send { flex: 0 0 auto; }
+.chat-voice { flex: 0 0 auto; }
+
+/* The read-aloud control sits with the timestamp rather than on the bubble: it is about the turn,
+   not part of what was said. */
+.chat-listen { font-size: 0.7rem; padding: 0 6px; }
+
+/* ── Phones ──
+   One pane at a time. The page takes the whole viewport, the shell's sticky nav is hidden (it lives
+   in a higher stacking context, so a z-index here cannot cover it), and the composer sits on the
+   keyboard: --chat-avail is the measured visual-viewport height, with 100dvh as the fallback the
+   viewport meta's interactive-widget=resizes-content already provides. Same pattern as the inbox,
+   which is the surface this one is modelled on. */
+@media (max-width: 760px) {
+  .chat-view {
+    position: fixed;
+    inset: 0;
+    z-index: 1000;
+    grid-template-columns: 1fr;
+    gap: 0;
+    padding: 0;
+    max-width: none;
+    height: var(--chat-avail, 100dvh);
+    background: var(--bg);
+  }
+
+  body:has(.chat-view) { overflow: hidden; }
+  body:has(.chat-view) .topnav { display: none; }
+
+  /* The list is a place you go to, not a column that would leave neither pane readable. */
+  .chat-threads { display: none; }
+  .chat-view--list .chat-threads {
+    display: flex;
+    padding: 12px;
+    background: var(--bg-card);
+  }
+  .chat-view--list .chat-main { display: none; }
+
+  .chat-list-toggle { display: inline-flex; }
+  .chat-threads-close { display: inline-flex; align-self: flex-start; }
+
+  .chat-main {
+    border: none;
+    border-radius: 0;
+    height: 100%;
+  }
+
+  .chat-turn { max-width: 92%; }
+  .chat-scroll { padding: 12px 10px; }
+  .chat-composer {
+    padding: 8px 10px calc(8px + env(safe-area-inset-bottom, 0px));
+  }
+}

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/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 |