@wirecat/cli-core 0.479.0 → 0.481.0

package/CHANGELOG.md

@@ -7,6 +7,31 @@ shape of this file.
 
 ## Unreleased
 
+## 0.481.0 — 29.10.2026
+
+### Added
+
+- **`messages transcribe` hears an audio file someone sent, not only a voice note** — an iPhone recording reaches
+  WhatsApp as an `audio/mp4` file. MP3, FLAC and Ogg Vorbis are read by small bundled decoders (`mpg123-decoder`,
+  `@wasm-audio-decoders/flac`, `@wasm-audio-decoders/ogg-vorbis`, MIT). AAC/M4A, other formats and a file a bundled
+  decoder fails on go to the machine's own `ffmpeg`, when it has one, limited to audio formats and local files. No
+  decoder for AAC is bundled: the small ones are GPL. Audio longer than an hour is refused. A transcript kept for an
+  audio file shows in lists and is found by `transcript:`; `--transcribe` on a list still hears only voice notes, so it
+  never transcribes music. Where the messenger is asked first (`auto`), the local model takes over only when the
+  messenger refuses the account, so a messenger that rejects an audio file for another reason needs `--local`.
+
+## 0.480.0 — 29.10.2026
+
+### Changed — may break callers
+
+- **`StoredMessages.reactors` is required again.** 0.479.0 made it optional so a messenger that builds its own
+  `StoredMessages` kept compiling; whatsapp-cli now implements it, so every messenger must give it (`async () => []` for
+  one that stores no reactions). tg-cli and max-cli do not build a `StoredMessages` and are not affected.
+
+### Added
+
+- **`reactions list` is in whatsapp-cli too** (`parity.json`: `tg` and `wa`; max-cli does not list who reacted).
+
 ## 0.479.0 — 29.10.2026
 
 ### Added

package/dist/cli/messenger/context.d.ts

@@ -31,9 +31,8 @@ export interface StoredMessages {
     wroteTo(personId: Id): Promise<boolean>;
     /** Each voter's newest vote in the poll the message carries, newest first; a retracted vote has no answers. */
     pollVotes(chatId: Id, messageId: Id): Promise<PollVote[]>;
-    /** Each person's newest reaction the store received for the message, newest first; a taken-back one is not listed.
-     *  Optional so an adapter that builds its own `StoredMessages` still compiles. */
-    reactors?(chatId: Id, messageId: Id): Promise<Reactor[]>;
+    /** Each person's newest reaction the store received for the message, newest first; a taken-back one is not listed. */
+    reactors(chatId: Id, messageId: Id): Promise<Reactor[]>;
 }
 /** `listen` opens a connection that receives updates — only `watch` asks; the rest stay quiet. */
 export interface ConnectOptions {

package/dist/cli/messenger/hearing-command.js

@@ -1,4 +1,4 @@
-import { hearVoices, isVoice, openKept, spoken, withTranscript } from "../../speech/hearing.js";
+import { hasAudio, hearVoices, openKept, spoken, withTranscript } from "../../speech/hearing.js";
 import { choose } from "../../speech/transcribe.js";
 export const TRANSCRIBE_OPTION = [
     "--transcribe",
@@ -13,7 +13,7 @@ export const MODEL_OPTION = [
  * supplied. It is released before local recognition. `undefined` when there is no voice message, and then no file is opened.
  */
 export const hearForCommand = async (context, messenger, messages, transcribe, model, connect) => {
-    if (!messages.some(isVoice))
+    if (!messages.some(hasAudio))
         return undefined;
     const offline = context.settings.offline;
     if (transcribe && offline)

package/dist/cli/messenger/store-maintenance-command.d.ts

@@ -3,9 +3,9 @@ import type { CacheDatabase } from "../../store/driver.js";
 import type { Messenger } from "./context.js";
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export declare const storeSummary: (env: NodeJS.ProcessEnv) => Promise<{
+    error?: undefined;
     path: string;
     exists: boolean;
-    error?: undefined;
 } | {
     path: string;
     exists: boolean;

package/dist/meetings/mcp/index.d.ts

@@ -38,7 +38,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -54,11 +53,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -76,11 +75,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -102,6 +101,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -188,7 +188,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -204,11 +203,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -226,11 +225,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -252,6 +251,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -338,7 +338,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -354,11 +353,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -376,11 +375,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -402,6 +401,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -488,7 +488,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -504,11 +503,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -526,11 +525,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -552,6 +551,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -638,7 +638,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -654,11 +653,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -676,11 +675,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -702,6 +701,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;

package/dist/speech/decode.d.ts

@@ -0,0 +1,21 @@
+export interface Pcm {
+    samples: Float32Array;
+    rate: number;
+}
+/** An hour of speech; a longer "voice message" is a podcast or a song, and its samples would not fit in memory. */
+export declare const LONGEST_AUDIO_SECONDS = 3600;
+export type Ffmpeg = (bytes: Uint8Array) => Promise<Pcm>;
+type Format = "opus" | "vorbis" | "flac" | "mp3" | "other";
+/** From the bytes, never the MIME type: WhatsApp calls an iPhone recording `audio/mp4` and a voice note `audio/ogg`. */
+export declare const formatOf: (bytes: Uint8Array) => Format;
+/**
+ * The owner's own ffmpeg, for what no bundled decoder reads — AAC above all, which every small decoder does under
+ * the GPL. From a file rather than a pipe: an MP4 whose index sits at the end cannot be read from a pipe.
+ */
+export declare const runFfmpeg: Ffmpeg;
+/**
+ * Opus, Vorbis, FLAC and MP3 by the bundled decoders; anything else, or what one of them could not read, by ffmpeg
+ * when the machine has it. The bundled decoder's error wins: it names the file's own problem.
+ */
+export declare const decodeAudio: (bytes: Uint8Array, ffmpeg?: Ffmpeg) => Promise<Pcm>;
+export {};

package/dist/speech/decode.js

@@ -0,0 +1,164 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { CliError } from "@wirecat/cli-base";
+import { decodeOgg, SAMPLE_RATE } from "./recognize.js";
+/** An hour of speech; a longer "voice message" is a podcast or a song, and its samples would not fit in memory. */
+export const LONGEST_AUDIO_SECONDS = 3600;
+const FFMPEG_TIMEOUT_MS = 120_000;
+/**
+ * Formats a sender's file may claim to be. A playlist (HLS, concat) would make ffmpeg open other files and URLs,
+ * so it never gets past this list or the file-only protocol list.
+ */
+const FFMPEG_FORMATS = "mov,mp4,m4a,3gp,3g2,mj2,aac,mp3,wav,amr,caf,aiff,flac,ogg,matroska,webm,asf";
+const text = (bytes, from, length) => String.fromCharCode(...bytes.subarray(from, from + length));
+const contains = (bytes, needle, within) => Buffer.from(bytes.buffer, bytes.byteOffset, Math.min(bytes.length, within)).includes(needle, 0, "latin1");
+/** From the bytes, never the MIME type: WhatsApp calls an iPhone recording `audio/mp4` and a voice note `audio/ogg`. */
+export const formatOf = (bytes) => {
+    if (text(bytes, 0, 4) === "OggS") {
+        if (contains(bytes, "OpusHead", 128))
+            return "opus";
+        if (contains(bytes, "\x01vorbis", 128))
+            return "vorbis";
+        return "other";
+    }
+    if (text(bytes, 0, 4) === "fLaC")
+        return "flac";
+    // ADTS AAC shares MPEG's frame sync; its layer bits are 00, which MPEG audio reserves.
+    const frame = bytes[0] === 0xff && ((bytes[1] ?? 0) & 0xe0) === 0xe0 && (((bytes[1] ?? 0) >> 1) & 3) !== 0;
+    if (text(bytes, 0, 3) === "ID3" || frame)
+        return "mp3";
+    return "other";
+};
+const firstChannel = (decoded) => {
+    const samples = decoded.channelData[0];
+    if (!samples || decoded.samplesDecoded === 0)
+        throw new CliError("validation_error", "no audio in that file");
+    return { samples, rate: decoded.sampleRate };
+};
+/**
+ * Found from cli-core's own place and imported by URL, so a CLI's bundler leaves the decoder whole: bundled, it looks
+ * for its worker file beside the bundle, where there is none.
+ */
+const load = (name) => import(pathToFileURL(createRequire(import.meta.url).resolve(name)).href);
+const decodeVorbis = async (bytes) => {
+    const { OggVorbisDecoder } = await load("@wasm-audio-decoders/ogg-vorbis");
+    const decoder = new OggVorbisDecoder();
+    await decoder.ready;
+    try {
+        return firstChannel(await decoder.decodeFile(bytes));
+    }
+    finally {
+        decoder.free();
+    }
+};
+const decodeFlac = async (bytes) => {
+    const { FLACDecoder } = await load("@wasm-audio-decoders/flac");
+    const decoder = new FLACDecoder();
+    await decoder.ready;
+    try {
+        return firstChannel(await decoder.decodeFile(bytes));
+    }
+    finally {
+        decoder.free();
+    }
+};
+const decodeMp3 = async (bytes) => {
+    const { MPEGDecoder } = await load("mpg123-decoder");
+    const decoder = new MPEGDecoder();
+    await decoder.ready;
+    try {
+        return firstChannel(decoder.decode(bytes));
+    }
+    finally {
+        decoder.free();
+    }
+};
+/**
+ * The owner's own ffmpeg, for what no bundled decoder reads — AAC above all, which every small decoder does under
+ * the GPL. From a file rather than a pipe: an MP4 whose index sits at the end cannot be read from a pipe.
+ */
+export const runFfmpeg = async (bytes) => {
+    const directory = await mkdtemp(join(tmpdir(), "wirecat-audio-"));
+    try {
+        const input = join(directory, "audio");
+        await writeFile(input, bytes, { mode: 0o600 });
+        const largest = LONGEST_AUDIO_SECONDS * SAMPLE_RATE * 4;
+        const output = await new Promise((resolve, reject) => {
+            const child = spawn("ffmpeg", [
+                "-nostdin",
+                "-hide_banner",
+                "-loglevel",
+                "error",
+                "-protocol_whitelist",
+                "file",
+                "-format_whitelist",
+                FFMPEG_FORMATS,
+                "-i",
+                input,
+                "-vn",
+                "-ac",
+                "1",
+                "-ar",
+                String(SAMPLE_RATE),
+                "-f",
+                "f32le",
+                "pipe:1",
+            ], { stdio: ["ignore", "pipe", "pipe"], timeout: FFMPEG_TIMEOUT_MS });
+            const chunks = [];
+            let size = 0;
+            let errors = "";
+            child.stdout.on("data", (chunk) => {
+                size += chunk.length;
+                if (size > largest)
+                    child.kill();
+                else
+                    chunks.push(chunk);
+            });
+            child.stderr.on("data", (chunk) => {
+                errors = (errors + chunk.toString()).slice(-500);
+            });
+            child.on("error", (error) => reject(error.code === "ENOENT"
+                ? new CliError("validation_error", "only ffmpeg reads this audio format, and ffmpeg is not installed")
+                : error));
+            child.on("close", (code) => {
+                if (size > largest)
+                    reject(new CliError("validation_error", `the audio is longer than ${LONGEST_AUDIO_SECONDS / 60} minutes`));
+                else if (code === 0)
+                    resolve(Buffer.concat(chunks));
+                else
+                    reject(new CliError("validation_error", `ffmpeg could not read the audio: ${errors.trim() || code}`));
+            });
+        });
+        const samples = new Float32Array(Math.floor(output.length / 4));
+        Buffer.from(samples.buffer).set(output.subarray(0, samples.length * 4));
+        return { samples, rate: SAMPLE_RATE };
+    }
+    finally {
+        await rm(directory, { recursive: true, force: true });
+    }
+};
+const BUNDLED = {
+    opus: decodeOgg,
+    vorbis: decodeVorbis,
+    flac: decodeFlac,
+    mp3: decodeMp3,
+};
+/**
+ * Opus, Vorbis, FLAC and MP3 by the bundled decoders; anything else, or what one of them could not read, by ffmpeg
+ * when the machine has it. The bundled decoder's error wins: it names the file's own problem.
+ */
+export const decodeAudio = async (bytes, ffmpeg = runFfmpeg) => {
+    const format = formatOf(bytes);
+    const pcm = format === "other"
+        ? await ffmpeg(bytes)
+        : await BUNDLED[format](bytes).catch((error) => ffmpeg(bytes).catch(() => {
+            throw error;
+        }));
+    if (pcm.samples.length / pcm.rate > LONGEST_AUDIO_SECONDS)
+        throw new CliError("validation_error", `the audio is longer than ${LONGEST_AUDIO_SECONDS / 60} minutes`);
+    return pcm;
+};

package/dist/speech/hearing.d.ts

@@ -25,6 +25,8 @@ export interface Hearing {
 export declare const keyOf: ({ chatId, messageId }: Voice) => string;
 /** Telegram says `voice`; MAX says `audio` with Ogg in it. */
 export declare const isVoice: (message: Message) => boolean;
+/** `messages transcribe` hears any audio file; `--transcribe` hears only voice notes, or every song in a chat. */
+export declare const hasAudio: (message: Message) => boolean;
 export interface Kept {
     get(voice: Voice): Promise<{
         text: string;

package/dist/speech/hearing.js

@@ -1,7 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { recalledAccount } from "../cli/messenger/accounts.js";
 import { openStore } from "../store/store.js";
-import { choose, hearLocally, hearOnline } from "./transcribe.js";
+import { choose, hearLocally, hearOnline, isAudioFile } from "./transcribe.js";
 /** `--model` chooses who hears what `--transcribe` asks for; alone it would quietly do nothing. */
 export const modelWith = (transcribe, model) => {
     if (model !== undefined && transcribe !== true) {
@@ -14,6 +14,8 @@ export const HEARING_BUDGET_MS = 120_000;
 export const keyOf = ({ chatId, messageId }) => `${chatId}/${messageId}`;
 /** Telegram says `voice`; MAX says `audio` with Ogg in it. */
 export const isVoice = (message) => message.attachments.some(({ kind, mime }) => kind === "voice" || mime === "audio/ogg");
+/** `messages transcribe` hears any audio file; `--transcribe` hears only voice notes, or every song in a chat. */
+export const hasAudio = (message) => message.attachments.some(isAudioFile);
 /**
  * Transcripts already heard, in the shared store, for the account this profile last logged in as
  * (owner, NEED-418 B). A profile that has never been online has no account yet: nothing is kept for
@@ -38,13 +40,13 @@ export const openKept = async (messenger, profile, env) => {
 export const hearVoices = async (messenger, messages, kept, transcribe) => {
     const transcripts = new Map();
     const missing = [];
-    for (const message of messages.filter(isVoice)) {
+    for (const message of messages.filter(hasAudio)) {
         const voice = { chatId: message.chatId, messageId: message.id };
         const text = (await kept.get(voice))?.text;
-        if (text === undefined)
-            missing.push(voice);
-        else
+        if (text !== undefined)
             transcripts.set(keyOf(voice), text);
+        else if (isVoice(message))
+            missing.push(voice);
     }
     if (!transcribe || missing.length === 0)
         return { transcripts, unheard: missing };
@@ -91,7 +93,7 @@ export const spoken = ({ transcript, ...message }) => transcript === undefined
     : { ...message, text: [message.text, `🎤 ${transcript}`].filter(Boolean).join("\n") };
 /** For an MCP tool: the same hearing, over the session's own connection. */
 export const hearForTool = async (messenger, connect, messages, transcribe, { settings, env }, model) => {
-    if (!messages.some(isVoice))
+    if (!messages.some(hasAudio))
         return undefined;
     const kept = await openKept(messenger, settings.profile, env);
     try {

package/dist/speech/transcribe.d.ts

@@ -2,6 +2,7 @@ import { CliError } from "@wirecat/cli-base";
 import type { Messenger } from "../cli/messenger/context.js";
 import { type Settings } from "../cli/settings.js";
 import { type MessengerAdapter, type RemoteFile, type Transcript } from "../ports/messenger.js";
+import type { Ffmpeg } from "./decode.js";
 import { type SpeechModel } from "./models.js";
 import type { Recognizer } from "./recognize.js";
 /** `messenger`: its own recognition (Telegram Premium). `local`: a model on this machine. `auto`: the first, then the second. */
@@ -22,7 +23,13 @@ export interface Choice {
     directory: string;
     /** The local recognizer, where a test hands one in. */
     open?: OpenRecognizer;
+    ffmpeg?: Ffmpeg;
 }
+/** A voice note, or an audio file someone sent — an iPhone recording reaches WhatsApp as `audio/mp4`. */
+export declare const isAudioFile: ({ kind, mime }: {
+    kind: string;
+    mime?: string | undefined;
+}) => boolean;
 /** The flag, then the profile's `transcribeWith` and `speechModel`, then `auto` and the CLI's first model. */
 export declare const choose: (messenger: Messenger, settings: Pick<Settings, "configured" | "shared">, flags: {
     local?: boolean;
@@ -37,4 +44,4 @@ export declare const notDownloaded: (messenger: Messenger, model: SpeechModel) =
  */
 export declare const hearOnline: (messenger: Messenger, connection: MessengerAdapter, chat: string, messageId: string, choice: Choice, read?: (file: RemoteFile) => Promise<void>) => Promise<Heard | Uint8Array>;
 /** The local model, on the bytes `hearOnline` fetched. */
-export declare const hearLocally: (bytes: Uint8Array, messageId: string, { model, directory, open }: Choice) => Promise<Heard>;
+export declare const hearLocally: (bytes: Uint8Array, messageId: string, { model, directory, open, ffmpeg }: Choice) => Promise<Heard>;

package/dist/speech/transcribe.js

@@ -6,8 +6,10 @@ import { installedBytes, isInstalled, megabytes, modelPath, modelsDirectory, vad
 import { orderedModels, speechModel } from "./models.js";
 /** `messenger`: its own recognition (Telegram Premium). `local`: a model on this machine. `auto`: the first, then the second. */
 export const TRANSCRIBE_WITH = ["auto", "messenger", "local"];
-/** A voice message is read into memory whole; minutes of Opus are a few megabytes. */
+/** A recording is read into memory whole; minutes of Opus are a few megabytes. */
 const LARGEST_VOICE = 32 * 1024 * 1024;
+/** A voice note, or an audio file someone sent — an iPhone recording reaches WhatsApp as `audio/mp4`. */
+export const isAudioFile = ({ kind, mime }) => kind === "voice" || kind === "audio" || (mime?.startsWith("audio/") ?? false);
 /** The flag, then the profile's `transcribeWith` and `speechModel`, then `auto` and the CLI's first model. */
 export const choose = (messenger, settings, flags, env = process.env) => {
     const model = flags.model ?? fromFile(settings, "speechModel", undefined).value;
@@ -45,17 +47,18 @@ export const hearOnline = async (messenger, connection, chat, messageId, choice,
     if (!isInstalled(choice.model, choice.directory))
         throw notDownloaded(messenger, choice.model);
     const { files } = await capability(connection, "download", "download attachments")(chat, messageId);
-    const voice = files.find((file) => file.kind === "voice" || file.mime === "audio/ogg");
+    const voice = files.find(isAudioFile);
     if (!voice)
-        throw new CliError("validation_error", "that message is not a voice message");
+        throw new CliError("validation_error", "that message has no voice message or audio file");
     const bytes = await readAll(voice);
     await read?.(voice);
     return bytes;
 };
 /** The local model, on the bytes `hearOnline` fetched. */
-export const hearLocally = async (bytes, messageId, { model, directory, open }) => {
-    const { decodeOgg, openRecognizer, toModelRate } = await import("./recognize.js");
-    const { samples, rate } = await decodeOgg(bytes);
+export const hearLocally = async (bytes, messageId, { model, directory, open, ffmpeg }) => {
+    const { openRecognizer, toModelRate } = await import("./recognize.js");
+    const { decodeAudio } = await import("./decode.js");
+    const { samples, rate } = await decodeAudio(bytes, ffmpeg);
     const recognizer = (open ?? openRecognizer)(model, modelPath(directory, model), vadPath(directory));
     try {
         return {

package/dist/store/sqlite/attachment-texts.js

@@ -78,7 +78,7 @@ export const resetAttachmentWords = (database) => {
            extraction_error = NULL, extracted_at = t.heard_at, updated_at = t.updated_at
          FROM message_transcripts t
          WHERE attachments.attachable_type = 'message' AND attachments.attachable_id = t.message_id
-           AND (attachments.kind = 'voice' OR attachments.mime = 'audio/ogg')
+           AND (attachments.kind IN ('voice', 'audio') OR attachments.mime LIKE 'audio/%')
            AND coalesce(attachments.text, '') = '' AND coalesce(attachments.extraction, '') <> 'agent'`)
             .run();
         const update = database.prepare("UPDATE attachments SET normalized_text = ? WHERE id = ?");

package/dist/store/sqlite/transcripts.js

@@ -47,7 +47,7 @@ export const intoVoiceAttachment = (context, messagePk) => {
     const row = context.database
         .prepare(`SELECT a.id, t.text, t.source FROM message_transcripts t
        JOIN attachments a ON a.attachable_type = 'message' AND a.attachable_id = t.message_id
-       WHERE t.message_id = ? AND (a.kind = 'voice' OR a.mime = 'audio/ogg') ORDER BY a.position LIMIT 1`)
+       WHERE t.message_id = ? AND (a.kind IN ('voice', 'audio') OR a.mime LIKE 'audio/%') ORDER BY a.position LIMIT 1`)
         .get(messagePk);
     if (!row)
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.479.0",
+  "version": "0.481.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",
@@ -200,6 +200,8 @@
     "@modelcontextprotocol/server": "^2.4.0",
     "@resvg/resvg-js": "2.6.2",
     "@valibot/to-json-schema": "1.8.0",
+    "@wasm-audio-decoders/flac": "0.2.11",
+    "@wasm-audio-decoders/ogg-vorbis": "0.1.20",
     "@wirecat/cli-core-onnx": "1.2.0",
     "@wirecat/cli-core-sqlite": "1.1.0",
     "@xmldom/xmldom": "0.9.12",
@@ -220,6 +222,7 @@
     "mdast-util-from-markdown": "2.1.0",
     "mdast-util-gfm": "3.1.0",
     "micromark-extension-gfm": "3.0.0",
+    "mpg123-decoder": "1.0.3",
     "ogg-opus-decoder": "1.7.5",
     "postal-mime": "4.1.4",
     "psl": "1.15.0",

package/parity.json

@@ -3671,16 +3671,16 @@
       "in": "all"
     },
     "reactions list": {
-      "in": ["tg"],
-      "reason": "max-cli and whatsapp-cli do not list who reacted to a message",
+      "in": ["tg", "wa"],
+      "reason": "max-cli does not list who reacted to a message",
       "options": {
         "--cursor": {
-          "in": ["tg"],
-          "reason": "max-cli and whatsapp-cli do not list who reacted to a message"
+          "in": ["tg", "wa"],
+          "reason": "max-cli does not list who reacted to a message"
         },
         "--limit": {
-          "in": ["tg"],
-          "reason": "max-cli and whatsapp-cli do not list who reacted to a message"
+          "in": ["tg", "wa"],
+          "reason": "max-cli does not list who reacted to a message"
         }
       }
     },