clavarium 0.2.0-next.10 → 0.2.0-next.11

package/README.md

@@ -30,8 +30,9 @@ Built slice by slice; the plan is in `blueprint/architecture.html`, tab
 
 - **5 - hands**: one-click shortcuts (sent, or left to complete), and
   dictation: the microphone stays open and each phrase is typed into the
-  terminal; "auto" presses Enter once the person has stopped. Dictation needs
-  `CLAVARIUM_TRANSCRIPTION_URL` (and `_KEY`) in the environment.
+  terminal; "auto" presses Enter once the person has stopped. Its engine is chosen
+  in Settings, Dictation (a provider, its key one of the secrets);
+  `CLAVARIUM_TRANSCRIPTION_URL` (and `_KEY`) in the environment is the fallback.
 
 - **6 - the app and sharing**: the page is installable; a conversation is
   shared with a one-use QR code; the device that scans it makes its own key,

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "clavarium",
-  "version": "0.2.0-next.10",
+  "version": "0.2.0-next.11",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "clavarium",
-      "version": "0.2.0-next.10",
+      "version": "0.2.0-next.11",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clavarium",
-  "version": "0.2.0-next.10",
+  "version": "0.2.0-next.11",
   "license": "MIT",
   "type": "module",
   "description": "A conversation is a VM with a terminal in it. Everything else is a folder.",

package/server/api.mjs

@@ -71,6 +71,10 @@
  *   POST /api/shortcuts/<id>/remove
  *   GET  /api/voice                         is dictation available?
  *   POST /api/voice                         the body IS a WAV recording -> {text}
+ *   GET  /api/dictation                     the engine chosen in Settings (never a key: a secret's name)
+ *   POST /api/dictation                     {provider, url, model, secret, language}: chosen, at once
+ *   POST /api/dictation/off                 the environment's engine, if any, again
+ *   POST /api/dictation/try?provider=&url=&model=&secret=&language=   a WAV -> {text}, nothing saved
  *   GET  /api/files?c=<conversation>&r=<resource>&p=<path>          a listing
  *   GET  /api/flows                         who gets what: devices, conversations, assets, the rights between them, the flows
  *   POST /api/flows/name                    {around, name}: a flow named by the owner ('' gives it back its own)
@@ -139,14 +143,18 @@ export async function handleApi(request, response, conversations, headers, resou
         return resources.folder(any.name);
     };
     try {
-        if (request.method === 'GET' && pathname === '/api/voice') return send(200, { available: voice !== undefined, engine: voice?.model ?? null }), true;
-        if (request.method === 'POST' && pathname === '/api/voice') {
+        if (request.method === 'GET' && pathname === '/api/voice') return send(200, { available: voice?.current() !== undefined, engine: voice?.model ?? null }), true;
+        if (request.method === 'GET' && pathname === '/api/dictation' && voice) return send(200, voice.about()), true;
+        if (request.method === 'POST' && (pathname === '/api/voice' || (pathname === '/api/dictation/try' && voice))) {
             if (!originOk(request.headers) || request.headers['content-type'] !== 'audio/wav') {
                 return send(403, { error: 'This request does not come from this site.' }), true;
             }
             const parts = []; let size = 0;
             for await (const chunk of request) { size += chunk.length; if (size > AUDIO_MAX) throw new Refusal(413, 'The recording is too long.'); parts.push(chunk); }
-            return send(200, { text: await transcribe(voice, Buffer.concat(parts)) }), true;
+            const audio = Buffer.concat(parts);
+            /* "Try it": the choice in the form, in the address's parameters (no key in it: a secret's name). */
+            if (pathname === '/api/dictation/try') return send(200, { text: await voice.try(Object.fromEntries(query), audio) }), true;
+            return send(200, { text: voice ? await voice.transcribe(audio) : await transcribe(undefined, audio) }), true;
         }
         if (request.method === 'GET' && pathname === '/api/files') return send(200, await list(attached(), query.get('p') ?? '')), true;
         if (request.method === 'GET' && pathname === '/api/files/machine') {
@@ -438,6 +446,8 @@ export async function handleApi(request, response, conversations, headers, resou
         if (naming) return send(200, conversations.setChatName(decodeURIComponent(naming[1]), body.name)), true;
         /* The list: folders and order, the same on every device (conversations.mjs). */
         if (pathname === '/api/instance' && instance) return send(200, instance.setName(body.name)), true;
+        if (pathname === '/api/dictation' && voice) return send(200, voice.set(body)), true;
+        if (pathname === '/api/dictation/off' && voice) return send(200, voice.off()), true;
         if (pathname === '/api/order') return send(200, conversations.setOrder({ order: body.order, groups: body.groups })), true;
         if (pathname === '/api/groups/rename') return send(200, conversations.renameGroup(body.from, body.to)), true;
         if (pathname === '/api/groups/move') return send(200, conversations.moveGroup(body.group, body.to)), true;

package/server/bridge.mjs

@@ -142,9 +142,10 @@ export function attachBridge(server, { spawn, onLeft = () => {}, onEnded = () =>
         const terminal = await spawn(name, cols, rows, say);
         /* While it was being opened another one may have been: the newest wins. */
         if (live.has(name)) close(name);
-        const kept = { terminal, sink, cols, rows };
+        const kept = { terminal, sink, cols, rows, openedAt: Date.now(), outputAt: Date.now() };
         live.set(name, kept);
         terminal.onData((bytes) => {
+            kept.outputAt = Date.now();
             if (kept.sink?.readyState === 1) { kept.sink.send(bytes, { binary: true }); return; }
             if (!kept.sink) { const answer = answerForAbsentScreen(bytes); if (answer) terminal.write(answer); }
         });
@@ -267,5 +268,9 @@ export function attachBridge(server, { spawn, onLeft = () => {}, onEnded = () =>
     /* `type(name, line, ms)`: see above. `droppedAt(name)`: when it was last
        closed for its machine's sake, or undefined. */
     const drop = (name) => { dropped.set(name, Date.now()); close(name); };
-    return { seats, drop, warm, type, open: (name) => live.has(name), droppedAt: (name) => dropped.get(name) };
+    /* `settled(name)`: how long its terminal has been open, and how long
+       since anything came out of it -- THAT something came, never what: a
+       tool still drawing its first screen is not reading its keyboard yet. */
+    const settled = (name) => { const kept = live.get(name); return kept ? { openFor: Date.now() - kept.openedAt, quietFor: Date.now() - kept.outputAt } : null; };
+    return { seats, drop, warm, type, settled, open: (name) => live.has(name), droppedAt: (name) => dropped.get(name) };
 }

package/server/door.mjs

@@ -158,13 +158,13 @@ export async function handleDoor(request, response, { devices, conversations, re
         if (request.method === 'GET' && route === '/shortcuts') { need(part.terminal || part.chat === 'write', 'the terminal or the chat'); return send(200, shortcuts.list()); }
         /* What is dictated goes into the terminal, or into the chat's box: one of the two must be its to write in. */
         const speaks = part.terminal || part.chat === 'write';
-        if (request.method === 'GET' && route === '/voice') return send(200, { available: voice !== undefined && speaks, engine: speaks ? voice?.model ?? null : null });
+        if (request.method === 'GET' && route === '/voice') return send(200, { available: voice?.current() !== undefined && speaks, engine: speaks ? voice?.model ?? null : null });
         if (request.method === 'POST' && route === '/voice') {
             need(speaks, 'the terminal or the chat');
             if (request.headers['content-type'] !== 'audio/wav') return send(400, { error: 'A recording is a WAV file.' });
             const parts = []; let size = 0;
             for await (const chunk of request) { size += chunk.length; if (size > AUDIO_MAX) throw new Refusal(413, 'The recording is too long.'); parts.push(chunk); }
-            return send(200, { text: await transcribe(voice, Buffer.concat(parts)) });
+            return send(200, { text: voice ? await voice.transcribe(Buffer.concat(parts)) : await transcribe(undefined, Buffer.concat(parts)) });
         }
         /* Its conversation's chat, whatever conversation the address names: the device's own. */
         /* Only for a pairing given its chat: to read it, or to write there too. */

package/server/main.mjs

@@ -28,7 +28,7 @@ import { Vms, runner } from './vm.mjs';
 import { Resources } from './resources.mjs';
 import { makeGate, makeOriginCheck, readOperators } from './gate.mjs';
 import { Shortcuts } from './shortcuts.mjs';
-import { voiceConfig } from './voice.mjs';
+import { Dictation } from './voice.mjs';
 import QRCode from 'qrcode';
 import { Devices } from './devices.mjs';
 import { handleDoor, deviceTerminal } from './door.mjs';
@@ -221,7 +221,8 @@ export async function startHome({ port, host, dataDir, mntDir = dataDir, gitRese
     await toolbox.prepare().catch((error) => console.error(error.message));
     await all.ensureWork?.();
     const shortcuts = new Shortcuts(new Store(`${dataDir}/shortcuts.json`));
-    const voice = voiceConfig(env);
+    /* The engine of dictation: chosen in Settings, else the environment's (voice.mjs). */
+    const voice = new Dictation({ file: new JsonFile(`${dataDir}/dictation.json`, {}), env, secret: (name) => secrets.reveal(name) });
     /* Read here already: a device paired before a conversation was shared in
        two parts keeps the chat it reached then (see devices.mjs). */
     const talkStore = new Store(`${dataDir}/talk.json`);
@@ -342,7 +343,7 @@ export async function startHome({ port, host, dataDir, mntDir = dataDir, gitRese
     /* What the VM manager says each machine has is what is recorded (a record
        may say otherwise: set by hand, or by an earlier version). Not waited for. */
     void all.reconcileAll?.().catch(() => {});
-    const platform = { answerer: answerer.about(), operators: [...operators], address: publicOrigin ?? null, version: JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version, dictation: voice ? (voice.model ?? 'set') : null };
+    const platform = { answerer: answerer.about(), operators: [...operators], address: publicOrigin ?? null, version: JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version, get dictation() { return voice.current() ? (voice.model ?? 'set') : null; } };
     /* Who gets what, and a whole setup in one file: see setup.mjs. */
     /* Settings, Updates: what the updater (deploy/updater.mjs, as root) wrote, and how to ask it. */
     const updates = new Updates({ host: asHost, version: platform.version, store: new Store(`${dataDir}/updates.json`), alerts, ...(updateState ? { stateFile: updateState } : {}), ...(updateConf ? { confFile: updateConf } : {}) });

package/server/secrets.mjs

@@ -66,6 +66,10 @@ export class Secrets {
     list() { return this.#store.all().map(({ name, createdAt }) => ({ name, conversations: this.#grants.on(`secret:${name}`).map((g) => g.subject.slice('conversation:'.length)), createdAt })); }
     of(conversation) { return this.#store.all().filter((s) => this.#handed(conversation, s.name)).map((s) => s.name); }
 
+    /* The value, for this server's own use only (the key of the dictation
+       engine, put in a request's header): never returned by any route. */
+    reveal(name) { const s = this.#store.get(name); return s ? this.#vault.open(s.sealed) : undefined; }
+
     /* Creates, or replaces the value of, a secret. */
     set({ name, value }) {
         if (!isSecretName(name)) throw new Refusal(400, 'A secret is named like a variable: capitals, digits and underscores, starting with a letter.');

package/server/talk.mjs

@@ -96,6 +96,16 @@ export function typeCommand(line) {
 export const BRANCHES = 'Check out your branches in the main folder of the repository or under /work, never in /tmp: a branch can be checked out in one folder only, and /tmp is emptied when the machine restarts.';
 /* After a restart, the tool is given this long to start before REREAD is typed. */
 export const REREAD_AFTER_MS = 10_000;
+/* READY, NOT JUST STARTED. The tool starts when its terminal is opened, which
+   may be well after the restart was said; and a tool still starting does not
+   read its keyboard yet: the line and its Enter then wait together, and are
+   read at once as a paste -- the Enter becomes a new line in its input box,
+   never sent (seen on a real deployment). REREAD is typed once its terminal
+   has been open REREAD_AFTER_MS and nothing has come out of it for
+   SETTLED_MS; after READY_MAX_MS open, typed anyway (a tool that never stops
+   drawing). */
+export const SETTLED_MS = 2_000;
+export const READY_MAX_MS = 60_000;
 /* Lines of the machine kept for one conversation, at most. */
 export const SYSTEM_MAX = 50;
 /* THE THREAD'S OWN LINES, by kind of event, and how much each matters --
@@ -447,6 +457,14 @@ export class Talk {
         const quiet = this.#now() - (this.#typedAt.get(name) ?? 0);
         if (quiet < TYPING_QUIET_MS) return later(TYPING_QUIET_MS - quiet + 100);
         if (!(await this.#runs(name))) return later(RETRY_MS);
+        if (this.#terminal?.settled) {
+            await this.#warm(name);
+            const s = this.#terminal.settled(name);
+            if (s) {
+                const wait = Math.max(this.#rereadAfter - s.openFor, s.openFor < READY_MAX_MS ? SETTLED_MS - s.quietFor : 0);
+                if (wait > 0) return later(wait + 100);
+            }
+        }
         if (!(await this.#type(name, REREAD).catch(() => false))) return later(RETRY_MS);
         /* Reading the whole thread, it reads what waits too: that line is not typed after it. */
         const waits = this.#parley(name).unread() > 0;

package/server/voice.mjs

@@ -10,7 +10,11 @@
  * (a line break is Enter), direction marks, zero-width characters -- and the
  * length is bounded: a dictation is a sentence, not a file.
  */
+import { lookup as dnsLookup } from 'node:dns/promises';
+import { isIP } from 'node:net';
 import { Refusal } from './conversations.mjs';
+import { JsonFile } from './store.mjs';
+import { isSecretName } from './secrets.mjs';
 
 export const AUDIO_MAX = 512 * 1024;
 export const TEXT_MAX = 2000;
@@ -77,7 +81,7 @@ export async function transcribe(config, audio, fetcher = fetch) {
     form.append('response_format', 'json');
     let response;
     try {
-        response = await fetcher(config.url, { method: 'POST', headers: config.key ? { authorization: `Bearer ${config.key}` } : {}, body: form, signal: AbortSignal.timeout(TIMEOUT_MS) });
+        response = await fetcher(config.url, { method: 'POST', redirect: 'error', headers: config.key ? { authorization: `Bearer ${config.key}` } : {}, body: form, signal: AbortSignal.timeout(TIMEOUT_MS) });
     } catch {
         /* The error of a failed request repeats the address it was sent to:
            it is not passed on. */
@@ -88,3 +92,118 @@ export async function transcribe(config, audio, fetcher = fetch) {
     if (typeof body?.text !== 'string') throw new Refusal(502, 'The speech-to-text engine gave no text.');
     return cleanDictation(body.text);
 }
+
+/* ---------- THE ENGINE CHOSEN IN SETTINGS ----------
+ * Settings > Dictation: a provider fills in the address and the model (both
+ * may be changed); the key is one of the SECRETS already kept (Assets >
+ * Secrets), named, never shown, never sent to a page: it is opened here, at
+ * the moment of transcribing, and goes nowhere but in the request's header.
+ * What is set there wins; the CLAVARIUM_TRANSCRIPTION_* environment stays
+ * the fallback. Applied at once, without a restart.
+ *
+ * WHERE IT MAY SEND: the address is chosen in a page, and this server would
+ * then post to it -- with a key. So: HTTPS only, and never an address of the
+ * server's own network (loopback, private, link-local), checked again on what
+ * the name resolves to at each use; except with "Other (compatible)", made
+ * for an engine of one's own, where a local or private address is allowed,
+ * plain HTTP included. */
+export const PROVIDERS = {
+    ovh: { label: 'OVH AI Endpoints', url: 'https://oai.endpoints.kepler.ai.cloud.ovh.net/v1/audio/transcriptions', model: 'whisper-large-v3-turbo' },
+    openai: { label: 'OpenAI', url: 'https://api.openai.com/v1/audio/transcriptions', model: 'whisper-1' },
+    groq: { label: 'Groq', url: 'https://api.groq.com/openai/v1/audio/transcriptions', model: 'whisper-large-v3-turbo' },
+    mistral: { label: 'Mistral', url: 'https://api.mistral.ai/v1/audio/transcriptions', model: 'voxtral-mini-latest' },
+    other: { label: 'Other (compatible)', url: '', model: '' },
+};
+const LANGUAGE = /^[a-z]{2,3}(-[A-Za-z]{2,4})?$/;
+const MODEL = /^[A-Za-z0-9._:/-]{1,100}$/;
+
+/* An address of this server's own network, written as such. */
+export function isPrivateHost(host) {
+    const h = String(host).toLowerCase().replace(/^\[|\]$/g, '').replace(/\.$/, '');
+    if (h === 'localhost' || h.endsWith('.localhost') || h.endsWith('.local') || h.endsWith('.internal') || h.endsWith('.lan') || h.endsWith('.home.arpa')) return true;
+    const kind = isIP(h);
+    if (kind === 0) return !h.includes('.');
+    if (kind === 6) {
+        const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(h);
+        if (mapped) return isPrivateHost(mapped[1]);
+        return h === '::' || h === '::1' || /^f[cd]/.test(h) || /^fe[89ab]/.test(h);
+    }
+    const [a, b] = h.split('.').map(Number);
+    return a === 0 || a === 10 || a === 127 || (a === 169 && b === 254) || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || (a === 100 && b >= 64 && b <= 127) || a >= 224;
+}
+
+/* What is wrong with a choice, in a sentence; undefined when it is fine. */
+export function dictationProblem(c) {
+    if (!c || typeof c !== 'object') return 'Choose an engine.';
+    if (!Object.hasOwn(PROVIDERS, c.provider)) return 'Choose a provider among those offered.';
+    let url;
+    try { url = new URL(String(c.url ?? '')); } catch { return 'The address is not a web address.'; }
+    if (url.username || url.password) return 'The address cannot carry a name or a password: the key is a secret.';
+    const own = isPrivateHost(url.hostname);
+    if (own && c.provider !== 'other') return 'An address of this server\'s own network is allowed only with "Other (compatible)", for an engine of your own.';
+    if (url.protocol !== 'https:' && !(url.protocol === 'http:' && own)) return 'The address must start with https:// (plain http only for an engine on this server\'s own network).';
+    if (!MODEL.test(String(c.model ?? ''))) return 'Give the name of a model.';
+    if (c.secret !== undefined && c.secret !== '' && !isSecretName(c.secret)) return 'The key is the name of a secret.';
+    if (c.language !== undefined && c.language !== '' && !LANGUAGE.test(String(c.language))) return 'The language is a code such as en or fr, or automatic.';
+    return undefined;
+}
+
+export class Dictation {
+    #file; #env; #secret; #lookup; #fetcher;
+    /* `secret(name)`: the value of a secret, or undefined. `lookup(host)`: the addresses a name resolves to. */
+    constructor({ file = new JsonFile(undefined, {}), env = process.env, secret = () => undefined, lookup = (host) => dnsLookup(host, { all: true }), fetcher = fetch } = {}) {
+        this.#file = file; this.#env = env; this.#secret = secret; this.#lookup = lookup; this.#fetcher = fetcher;
+    }
+    #saved() { const kept = this.#file.get(); return kept?.on === true && !dictationProblem(kept) ? kept : undefined; }
+    #configOf(c) {
+        return { url: c.url, model: c.model, language: c.language || undefined, key: c.secret ? this.#secret(c.secret) : undefined, provider: c.provider };
+    }
+    /* What transcribes now: the one set in Settings, else the environment's. */
+    current() {
+        const saved = this.#saved();
+        return saved ? this.#configOf(saved) : voiceConfig(this.#env);
+    }
+    get model() { return this.current()?.model; }
+    /* For the page: never a key, nor the environment's address (it may carry one). */
+    about() {
+        const saved = this.#file.get() ?? {};
+        const env = voiceConfig(this.#env);
+        return {
+            on: this.#saved() !== undefined,
+            provider: saved.provider ?? null, url: saved.url ?? '', model: saved.model ?? '', secret: saved.secret ?? '', language: saved.language ?? '',
+            secretMissing: Boolean(saved.secret) && this.#secret(saved.secret) === undefined,
+            env: env ? { model: env.model } : null,
+            source: this.#saved() ? 'settings' : env ? 'env' : null,
+            providers: Object.entries(PROVIDERS).map(([id, p]) => ({ id, ...p })),
+        };
+    }
+    #checked(body) {
+        const c = { provider: body?.provider, url: String(body?.url ?? '').trim(), model: String(body?.model ?? '').trim(), secret: String(body?.secret ?? '').trim(), language: String(body?.language ?? '').trim() };
+        const problem = dictationProblem(c);
+        if (problem) throw new Refusal(400, problem);
+        if (c.secret && this.#secret(c.secret) === undefined) throw new Refusal(400, 'No secret has this name: add it in Assets, Secrets.');
+        return c;
+    }
+    set(body) { this.#file.set({ ...this.#checked(body), on: true }); return this.about(); }
+    /* Turned off: the environment's engine, if any, takes over again. The choice is kept, to be turned on again. */
+    off() { const kept = this.#file.get() ?? {}; this.#file.set({ ...kept, on: false }); return this.about(); }
+    /* A name resolving to this server's own network is refused unless "Other" was chosen. */
+    async #guard(config) {
+        if (!config.provider || config.provider === 'other') return;
+        const host = new URL(config.url).hostname;
+        let addresses;
+        try { addresses = isIP(host.replace(/^\[|\]$/g, '')) ? [{ address: host }] : await this.#lookup(host); } catch { throw new Refusal(502, 'The speech-to-text engine cannot be reached.'); }
+        if (addresses.some((a) => isPrivateHost(a.address))) throw new Refusal(400, 'This address leads into this server\'s own network: only "Other (compatible)" may.');
+    }
+    async transcribe(audio) {
+        const config = this.current();
+        if (config) await this.#guard(config);
+        return transcribe(config, audio, this.#fetcher);
+    }
+    /* "Try it": what is in the form, not saved, on one short recording. */
+    async try(body, audio) {
+        const config = this.#configOf(this.#checked(body));
+        await this.#guard(config);
+        return transcribe(config, audio, this.#fetcher);
+    }
+}

package/web/app.js

@@ -2515,7 +2515,6 @@
        opened shows its files (the Files sheet, moved in), a repository its
        branches. On a phone, the list, then one asset with "All assets". */
     const ASSET_KINDS = [['git', 'Git repositories', 'git-branch'], ['folder', 'Folders', 'folder'], ['mailbox', 'Mailboxes', 'mail'], ['secret', 'Secrets', 'key-round']];
-    const byKind = (items) => ASSET_KINDS.flatMap(([k]) => items.filter((i) => i.kind === k));
     const getJson = (path, fallback) => fetch(`${API}${path}`).then((r) => (r.ok ? r.json() : fallback)).catch(() => fallback);
     const el = (tag, cls, text) => { const e = document.createElement(tag); if (cls) e.className = cls; if (text !== undefined) e.textContent = text; return e; };
     const kindIcon = (kind) => { const name = ASSET_KINDS.find((k) => k[0] === kind)?.[2]; const holder = el('span', 'as-ic'); holder.dataset.kind = kind; const svg = name ? window.clavariumIcons?.icon(name) : null; if (svg) holder.append(svg); return holder; };
@@ -2644,6 +2643,9 @@
         filesHome.parent.insertBefore(f, filesHome.next);
     }
 
+    /* Nothing is opened by itself: the wide detail says what it is for. */
+    const noAssetChosen = () => el('p', 'hint as-none', 'Select an asset to see its detail.');
+
     /* ---- a conversation's own ---- */
     async function paintRoomAssets() {
         if (!assetsShown) return;
@@ -2660,7 +2662,7 @@
                 sub: kind === 'git' ? gitSub(r) : kind === 'mailbox' ? boxSub(box) : 'folder', tone: box?.failure ? 'bad' : '' });
         }
         for (const s2 of secrets.filter((x) => x.conversations.includes(current))) items.push({ key: `secret:${s2.name}`, kind: 'secret', name: s2.name, secret: s2, sub: 'name only · used by its agent' });
-        const chosen = items.find((i) => i.key === roomPick) ?? (narrow() ? null : byKind(items)[0] ?? null);
+        const chosen = items.find((i) => i.key === roomPick) ?? null;
         const as = $('cassets-as');
         as.dataset.open = chosen ? 'detail' : 'list';
         paintAsList($('cassets-rows'), items, { chosen: chosen?.key, choose: (key) => pickRoomAsset(key), empty: 'Nothing is given to it yet.' });
@@ -2668,7 +2670,7 @@
         $('cassets-rows').prepend(top);
         if (c?.work === 'disk') $('cassets-rows').append(el('p', 'hint as-disk', 'Its work is on the disk of its machine: nothing of it is kept here.'));
         const detail = $('cassets-detail');
-        if (!chosen) { unembedFiles(); detail.replaceChildren(); return; }
+        if (!chosen) { unembedFiles(); detail.replaceChildren(); if (items.length) detail.append(noAssetChosen()); return; }
         const keepFiles = (chosen.kind === 'folder' || chosen.kind === 'mailbox') && $('files').classList.contains('embedded') && detail.contains($('files')) && detail.dataset.asset === chosen.key;
         if (!keepFiles) { unembedFiles(); detail.replaceChildren(); }
         detail.dataset.asset = chosen.key;
@@ -2730,7 +2732,7 @@
         }
         for (const s2 of secrets) items.push({ key: `secret:${s2.name}`, kind: 'secret', name: s2.name, secret: s2, badge: String(s2.conversations.length), badgeTitle: `Used by ${s2.conversations.length} conversation${s2.conversations.length === 1 ? '' : 's'}`, badgeTone: 'count', sub: 'name only' });
         const shown = assetsQuery ? items.filter((i) => i.name.includes(assetsQuery.toLowerCase()) || i.name.toLowerCase().includes(assetsQuery.toLowerCase())) : items;
-        const chosen = assetsAdding ? null : items.find((i) => i.key === assetOpen) ?? (narrow() ? null : byKind(shown)[0] ?? null);
+        const chosen = assetsAdding ? null : items.find((i) => i.key === assetOpen) ?? null;
         $('assets-as').dataset.open = chosen || assetsAdding ? 'detail' : 'list';
         paintAsList($('assets-rows'), shown, { chosen: chosen?.key, choose: (key) => { placeAssetStep(); assetOpen = key; assetsAdding = ''; remoteEditing = false; remember(); void paintAssets(); }, add: (kind) => { placeAssetStep(); assetsAdding = kind; void paintAssets(); }, empty: assetsQuery ? 'Nothing by that name.' : '' });
         const detail = $('assets-detail');
@@ -2767,7 +2769,7 @@
             focusField(form.querySelector('input:not([type=radio])'));
             return;
         }
-        if (!chosen) return;
+        if (!chosen) { if (items.length) detail.append(noAssetChosen()); return; }
         detail.append(asTitle(chosen, back));
         const ready = conversations.filter((c) => c.phase === 'ready');
         const r = chosen.resource;
@@ -3166,15 +3168,96 @@
             remove.addEventListener('click', async () => { await post(`${API}/shortcuts/${shortcut.id}/remove`).catch(() => {}); await openSettings(); void paintShortcuts(); });
             row.append(label, remove); list.append(row);
         }
-        $('settings-dictation').textContent = platform.dictation ? `Speech is turned into text by "${platform.dictation}". It is set on the server (CLAVARIUM_TRANSCRIPTION_URL).` : 'No speech-to-text engine is set on the server: Dictate is not offered.';
+        void paintDictation();
+        /* With no shortcut, one line: how to add one (this is the only place to remove them). */
+        $('settings-shortcuts-hint').textContent = saved.length ? 'The ready-made answers under the terminal. They are added there ("+ Shortcut"); they are removed here.' : 'No shortcut yet: add one under the terminal, with "+ Shortcut".';
         $('settings-people').textContent = (platform.operators ?? []).length
-            ? `Who may sign in: ${platform.operators.join(', ')}. Address: ${platform.address ?? 'not declared'}. Both were set when this was installed.`
+            ? `Who may sign in: ${platform.operators.join(', ')} (set when this was installed).`
             : 'Development mode: anyone on this machine is the operator.';
+        $('settings-address').textContent = `Address: ${platform.address ?? 'not declared'}.`;
         $('settings-about').textContent = `Clavarium ${platform.version ?? ''}`;
         void paintInstance();
         await Promise.all([paintHosts(), paintShelf(), paintServer(), paintUpdates()]);
     }
 
+    /* ---------- Dictation, in Settings: the engine, chosen here (server/voice.mjs) ---------- */
+    let dictationProviders = [];
+    const dictationChoice = () => {
+        const lang = $('dictation-language').value;
+        return { provider: $('dictation-provider').value, url: $('dictation-url').value.trim(), model: $('dictation-model').value.trim(), secret: $('dictation-secret').value,
+            language: lang === 'other' ? $('dictation-language-code').value.trim() : lang };
+    };
+    const dictationSay = (error, saved = '') => {
+        $('dictation-error').textContent = error ?? ''; $('dictation-error').hidden = !error;
+        $('dictation-saved').textContent = saved;
+    };
+    const showLanguage = (code) => {
+        const known = [...$('dictation-language').options].some((o) => o.value === code && code !== 'other');
+        $('dictation-language').value = known ? code : 'other';
+        $('dictation-language-code').value = known ? '' : code;
+        $('dictation-language-code').hidden = known;
+    };
+    async function paintDictation() {
+        const [about, secrets] = await Promise.all([getJson('/dictation', null), getJson('/secrets', [])]);
+        if (!about) { $('settings-dictation').textContent = 'Dictation cannot be set from here.'; $('dictation-form').hidden = true; return; }
+        $('settings-dictation').textContent = about.source === 'settings'
+            ? `On: speech is turned into text by "${about.model}", chosen here.${about.env ? ' The engine set on the server (CLAVARIUM_TRANSCRIPTION_URL) is the fallback when this is turned off.' : ''}`
+            : about.source === 'env'
+                ? `On: speech is turned into text by "${about.env.model}", set on the server (CLAVARIUM_TRANSCRIPTION_URL). An engine chosen here takes its place.`
+                : 'Off: no speech-to-text engine, so Dictate is not offered. Choose one below.';
+        if (about.secretMissing) dictationSay(`The secret "${about.secret}" is gone: choose another key.`);
+        dictationProviders = about.providers;
+        const provider = $('dictation-provider');
+        if (provider.options.length === 0) for (const p of about.providers) { const o = document.createElement('option'); o.value = p.id; o.textContent = p.label; provider.append(o); }
+        const secret = $('dictation-secret');
+        secret.replaceChildren(secret.options[0] ?? Object.assign(document.createElement('option'), { value: '', textContent: 'No key' }));
+        for (const s2 of secrets) { const o = document.createElement('option'); o.value = s2.name; o.textContent = s2.name; secret.append(o); }
+        if ($('dictation-form').contains(document.activeElement)) return;
+        provider.value = about.provider ?? 'ovh';
+        const first = dictationProviders.find((p) => p.id === provider.value);
+        $('dictation-url').value = about.provider ? about.url : first?.url ?? '';
+        $('dictation-model').value = about.provider ? about.model : first?.model ?? '';
+        secret.value = [...secret.options].some((o) => o.value === about.secret) ? about.secret : '';
+        showLanguage(about.language ?? '');
+        $('dictation-other-hint').hidden = provider.value !== 'other';
+        $('dictation-off').hidden = about.source !== 'settings';
+    }
+    $('dictation-provider').addEventListener('change', () => {
+        const p = dictationProviders.find((x) => x.id === $('dictation-provider').value);
+        if (p) { $('dictation-url').value = p.url; $('dictation-model').value = p.model; }
+        $('dictation-other-hint').hidden = $('dictation-provider').value !== 'other';
+    });
+    $('dictation-language').addEventListener('change', () => { $('dictation-language-code').hidden = $('dictation-language').value !== 'other'; });
+    $('dictation-form').addEventListener('submit', async (event) => {
+        event.preventDefault();
+        try { await post(`${API}/dictation`, dictationChoice()); document.activeElement?.blur(); dictationSay(null, 'Saved: in use now.'); void paintDictation(); }
+        catch (error) { dictationSay(error.message); }
+    });
+    $('dictation-off').addEventListener('click', async () => {
+        try { await post(`${API}/dictation/off`); dictationSay(null, 'Turned off.'); void paintDictation(); } catch (error) { dictationSay(error.message); }
+    });
+    /* "Try it": a few seconds from this microphone, sent to the engine in the form (nothing saved), its text shown. */
+    let stopTrying = null;
+    const endTry = () => { stopTrying?.(); stopTrying = null; $('dictation-try').textContent = 'Try it'; };
+    $('dictation-try').addEventListener('click', async () => {
+        if (stopTrying) { endTry(); return; }
+        dictationSay(null);
+        const heard = $('dictation-heard');
+        if (!window.clavariumVoice) { dictationSay('The microphone cannot be used on this page.'); return; }
+        const to = `${API}/dictation/try?${new URLSearchParams(dictationChoice())}`;
+        const words = { calibrating: 'Listening to the room...', listening: 'Speak now: a short sentence.', hearing: 'Hearing...', transcribing: 'Writing...' };
+        try {
+            heard.hidden = false; heard.textContent = 'Opening the microphone...';
+            const stop = await window.clavariumVoice.listen({
+                state: (w) => { if (stopTrying) heard.textContent = words[w] ?? w; },
+                phrase: (text) => { endTry(); heard.textContent = `Heard: ${text}`; },
+                error: (message) => { endTry(); heard.hidden = true; dictationSay(message); },
+            }, { to });
+            stopTrying = stop; $('dictation-try').textContent = 'Stop';
+            setTimeout(() => { if (stopTrying === stop) { endTry(); if (!heard.textContent.startsWith('Heard')) heard.textContent = 'Nothing was heard.'; } }, 15_000);
+        } catch { heard.hidden = true; dictationSay('The microphone could not be opened.'); }
+    });
+
     /* ---------- the name of this Clavarium, in Settings ---------- */
     async function paintInstance() {
         const about = await fetch(`${API}/instance`).then((r) => r.json()).catch(() => null);

package/web/index.html

@@ -570,7 +570,7 @@
         <details class="chapter" id="settings-ch-shortcuts" data-chapter="s-shortcuts">
           <summary><span class="chapter-title">Shortcuts</span><span class="chapter-about">The ready-made answers under the terminal.</span></summary>
           <div class="chapter-body">
-        <p class="hint">The ready-made answers under the terminal. They are added there ("+ Shortcut"); they are removed here.</p>
+        <p class="hint" id="settings-shortcuts-hint">The ready-made answers under the terminal. They are added there ("+ Shortcut"); they are removed here.</p>
         <div id="settings-shortcuts"></div>
           </div>
         </details>
@@ -603,16 +603,22 @@
           <summary><span class="chapter-title">Dictation</span><span class="chapter-about">Speech to text, on this server.</span></summary>
           <div class="chapter-body">
         <p id="settings-dictation" class="hint"></p>
+        <form id="dictation-form" autocomplete="off">
+          <div class="row"><label for="dictation-provider">Provider</label><select id="dictation-provider"></select></div>
+          <div class="row"><label for="dictation-url">Address</label><input id="dictation-url" type="url" spellcheck="false" placeholder="https://.../v1/audio/transcriptions"></div>
+          <div class="row"><label for="dictation-model">Model</label><input id="dictation-model" spellcheck="false" maxlength="100"></div>
+          <div class="row"><label for="dictation-secret">Key</label><select id="dictation-secret"><option value="">No key</option></select></div>
+          <div class="row"><label for="dictation-language">Language</label><select id="dictation-language"><option value="">Automatic</option><option value="en">English (en)</option><option value="fr">French (fr)</option><option value="de">German (de)</option><option value="es">Spanish (es)</option><option value="it">Italian (it)</option><option value="nl">Dutch (nl)</option><option value="pt">Portuguese (pt)</option><option value="other">Another code...</option></select><input id="dictation-language-code" maxlength="8" spellcheck="false" placeholder="code, such as pl" aria-label="Language code" hidden></div>
+          <p class="hint" id="dictation-key-hint">The key is one of your secrets (Assets, Secrets), chosen by its name: it is never shown, and only this server uses it, when it transcribes.</p>
+          <p class="hint" id="dictation-other-hint" hidden>"Other (compatible)": any engine with the same interface (<code>/v1/audio/transcriptions</code>). Only with it may the address be on this server's own network (localhost, a private address, plain http), for an engine of your own: the others must be public HTTPS addresses.</p>
+          <div class="row"><button type="submit" class="primary" id="dictation-save">Save</button><button type="button" id="dictation-try">Try it</button><button type="button" id="dictation-off">Turn off</button><span class="hint" id="dictation-saved" role="status"></span></div>
+          <p class="hint" id="dictation-heard" role="status" hidden></p>
+          <p class="error" id="dictation-error" role="alert" hidden></p>
+        </form>
           </div>
         </details>
-        <details class="chapter" id="settings-ch-people" data-chapter="s-people">
-          <summary><span class="chapter-title">People &amp; address</span><span class="chapter-about">Who may sign in, and where.</span></summary>
-          <div class="chapter-body">
-        <p id="settings-people" class="hint"></p>
         <!-- THIS SERVER: its disk and memory, what takes them, and the reserve
              no machine may eat into (server/capacity.mjs). Nothing here wakes a machine. -->
-          </div>
-        </details>
         <details class="chapter" id="settings-server-top" data-chapter="s-resources">
           <summary><span class="chapter-title">Resources</span><span class="chapter-about">Disk and memory, what takes them, the reserve.</span></summary>
           <div class="chapter-body">
@@ -703,9 +709,12 @@
           </div>
         </details>
         <details class="chapter" id="settings-ch-about" data-chapter="s-about">
-          <summary><span class="chapter-title">About</span><span class="chapter-about">The version that runs here.</span></summary>
+          <summary><span class="chapter-title">About</span><span class="chapter-about">The version, who may sign in, the address.</span></summary>
           <div class="chapter-body">
+        <!-- Facts only, one line each: a chapter with nothing to act on is not a chapter. -->
         <p id="settings-about" class="hint"></p>
+        <p id="settings-people" class="hint"></p>
+        <p id="settings-address" class="hint"></p>
           </div>
         </details>
       </div>

package/web/style.css

@@ -1108,6 +1108,7 @@ header .ic, #folders .ic { width: 18px; height: 18px; fill: none; stroke: curren
 .as-form form { display: flex; flex-direction: column; gap: 6px; }
 #gitview-remote-box > summary { display: none; }
 #gitview-remote { display: flex; flex-direction: column; gap: 6px; padding: 12px; border: 1px solid var(--line); border-radius: 10px; }
+.as-none { margin: auto; text-align: center; }
 .as-detail .given-row { display: flex; align-items: center; justify-content: space-between; gap: 10px; flex-wrap: wrap; }
 /* A folder of the conversation: the Files sheet, moved into the detail. */
 #files.embedded { position: static; inset: auto; z-index: auto; padding: 0; background: transparent; overflow: visible; flex: 1 1 auto; }

package/web/voice.js

@@ -9,8 +9,9 @@ const api = () => (document.documentElement.dataset.door === 'device' ? `/c/api/
 
 /* Opens the microphone; resolves with a function that closes it.
    `on.phrase(text)`, `on.state(word)`: calibrating, listening, hearing,
-   transcribing; `on.error(message)`. */
-async function listen(on) {
+   transcribing; `on.error(message)`. `to`: where phrases go, if not the
+   usual engine (Settings' "Try it" sends them to the one in its form). */
+async function listen(on, { to } = {}) {
     const stream = await navigator.mediaDevices.getUserMedia({ audio: { echoCancellation: true, noiseSuppression: false, autoGainControl: false } });
     const context = new (window.AudioContext ?? window.webkitAudioContext)({ sampleRate: RATE });
     const source = context.createMediaStreamSource(stream);
@@ -24,7 +25,7 @@ async function listen(on) {
         onPhrase: async (blocks) => {
             pending++; tell();
             try {
-                const r = await fetch(`${api()}/voice`, { method: 'POST', headers: { 'content-type': 'audio/wav' }, body: toWav(blocks) });
+                const r = await fetch(to ?? `${api()}/voice`, { method: 'POST', headers: { 'content-type': 'audio/wav' }, body: toWav(blocks) });
                 const j = await r.json().catch(() => ({}));
                 if (!r.ok) throw new Error(j.error || 'The phrase could not be transcribed.');
                 if (!closed && j.text) on.phrase(j.text);