wazap-mcp 0.17.0 → 0.18.0

package/dist/account-cli.js

@@ -38,7 +38,7 @@ export function describeStatusAccount(row) {
 export function accountRows(config) {
     const registry = AccountRegistry.load(config.dataDir);
     return registry.all().map((record) => {
-        let linked = null;
+        let linked;
         try {
             linked = readLinkedAccount(accountPaths(config.dataDir, record.id).authDir);
         }

package/dist/account-resolve.js

@@ -136,7 +136,9 @@ export function renderGetStatus(s, writeTools, hub) {
         `- **contacts named**: ${s.contacts_named}`,
         `- **data dir**: ${s.data_dir} · **read-only**: ${s.read_only} · **write tools**: ${writeLine} · **rate limit**: ${s.rate_limit}/min`,
         `- **versions**: wazap ${s.wazap_version}, baileys ${s.baileys_version}`,
-        s.pairing ? `- **pairing code**: ${s.pairing.code} for ${s.pairing.phone_masked}, until ${s.pairing.expires_at}` : null,
+        s.pairing
+            ? `- **pairing code**: ${s.pairing.code} for ${s.pairing.phone_masked}, until ${s.pairing.expires_at}`
+            : null,
         webhookStatusLine(s.webhook),
         s.last_error ? `- **last error**: ${s.last_error}` : null,
         s.hint ? `- **hint**: ${s.hint}` : null,

package/dist/cli.js

@@ -23,13 +23,14 @@ import { lockHolder, releaseLock, writeLock } from "./lock.js";
 import { log, logError, say } from "./logger.js";
 import { clockLabel, formatAge } from "./messages.js";
 import { oauthProblem } from "./oauth.js";
+import { downloadEmbed, embedModelSpec, readRecallSettings, } from "./recall/index.js";
 import { PAIRING_TIMEOUT_MS, linkSession, prettyCode, settledAccount, startPairing } from "./pairing.js";
 import { runHttp, runStdio, startLoopbackEndpoint } from "./server.js";
 import { fetchHealth, serviceHolding } from "./service.js";
 import { applyWrites } from "./settings.js";
 import { MODELS, downloadModel, maskKey, modelSpec, readTranscribeSettings, stripPasted, transcribeFile, transcribeReady, } from "./transcribe/index.js";
 import { bold, box, brand, humanLayout, dim, fail, fix, info, maskNumber, next, ok, openScreen, qrSavedLine, shortPath, spinner, tilde, warn, } from "./ui.js";
-import { loginWizardSteps, maybeWizard, wizDim, wizFail, wizInfo, wizOk, wizWarn, } from "./wizard.js";
+import { loginWizardSteps, maybeWizard, wizDim, wizFail, wizInfo, wizOk, wizWarn } from "./wizard.js";
 import { WhatsAppService } from "./whatsapp.js";
 /** How long a probe waits for the socket to settle; tests shorten it through the environment. */
 const LIVE_TIMEOUT_MS = Number.parseInt(process.env.WAZAP_LIVE_TIMEOUT_MS ?? "", 10) || 15_000;
@@ -106,7 +107,9 @@ export async function runStatus(config) {
 /** Today's phrasing, kept verbatim so pipes and log captures keep parsing. */
 function plainStatus(report) {
     const lines = [`data dir: ${report.data_dir}`];
-    const credsNote = report.credentials_readable ? "" : " (credentials unreadable — run `wazap logout` then `wazap login`)";
+    const credsNote = report.credentials_readable
+        ? ""
+        : " (credentials unreadable — run `wazap logout` then `wazap login`)";
     lines.push(`linked: ${report.linked ? "yes" : "no"}${credsNote}`);
     if (report.account)
         lines.push(`account: ${describeAccount(report.account)}`);
@@ -326,6 +329,32 @@ export async function downloadTranscribeModel(settings, spec) {
         throw err;
     }
 }
+/** `wazap embed download`. */
+export async function runEmbed(config) {
+    const [verb] = config.args;
+    if (verb !== "download") {
+        throw new WazapError("INVALID_ID", `Cannot run \`wazap embed ${config.args.join(" ")}\`.`, "Run `wazap embed download`");
+    }
+    await ensureDeps([DEPS.llama], config);
+    const settings = readRecallSettings(process.env, config.dataDir);
+    await downloadEmbedModel(settings, config.modelName);
+}
+/** The same check-then-fetch dance downloadTranscribeModel does, for the embed table. */
+export async function downloadEmbedModel(settings, modelName) {
+    const spec = embedModelSpec(modelName ?? settings.model);
+    const spin = spinner(`Checking ${spec.file}…`);
+    try {
+        const result = await downloadEmbed(settings.modelsDir, spec, (progress) => {
+            const percent = Math.floor((progress.received / progress.total) * 100);
+            spin.update(`Downloading ${spec.file} — ${mib(progress.received)} / ${mib(progress.total)} MiB (${percent}%)`);
+        });
+        spin.stop(ok(`${spec.file} (${mib(spec.bytes)} MiB) ${result.alreadyPresent ? "already present" : "verified"}`));
+    }
+    catch (err) {
+        spin.stop();
+        throw err;
+    }
+}
 /** What identifies each provider on screen. Keyed like PROVIDERS, never branched on. */
 const PROVIDER_ROWS = {
     local: (settings) => [
@@ -617,7 +646,10 @@ export async function linkAndSync(config, announce = () => { }, w = null) {
             announce("Link your phone");
         let account;
         try {
-            account = phone === null ? await linkByQr(selected.paths, waiting, w) : await linkByCode(selected.paths.authDir, phone, waiting, w);
+            account =
+                phone === null
+                    ? await linkByQr(selected.paths, waiting, w)
+                    : await linkByCode(selected.paths.authDir, phone, waiting, w);
         }
         catch (err) {
             waiting.stop();
@@ -732,7 +764,8 @@ export async function yieldSession(config, lockFile, why = "pairing") {
         return () => { };
     const held = serviceHolding(config.dataDir, running);
     if (held === null) {
-        throw leftoverRefusal(config) ?? new WazapError("WHATSAPP_ERROR", `wazap is running (pid ${running}).`, leftoverFix(running));
+        throw (leftoverRefusal(config) ??
+            new WazapError("WHATSAPP_ERROR", `wazap is running (pid ${running}).`, leftoverFix(running)));
     }
     say(info(`Stopping the wazap service for ${why}`));
     held.supervisor.stop(held.record);

package/dist/compact.js

@@ -30,7 +30,13 @@ export function compactConversations(conversations) {
                 last.message_ids.push(m.message_id);
                 continue;
             }
-            lines.push({ timestamp: m.timestamp, sender: m.sender.id, from_me: m.from_me, text: m.text, message_ids: [m.message_id] });
+            lines.push({
+                timestamp: m.timestamp,
+                sender: m.sender.id,
+                from_me: m.from_me,
+                text: m.text,
+                message_ids: [m.message_id],
+            });
             // The name rides on the line, once, for the renderer.
             lines[lines.length - 1].name = m.from_me
                 ? "me"
@@ -40,7 +46,14 @@ export function compactConversations(conversations) {
         }
         if (lines.length === 0 && dropped.media === 0 && dropped.wordless === 0)
             continue;
-        out.push({ chat_id: c.chat_id, chat_name: c.chat_name, type: c.type, ...(c.note ? { note: c.note } : {}), lines, dropped });
+        out.push({
+            chat_id: c.chat_id,
+            chat_name: c.chat_name,
+            type: c.type,
+            ...(c.note ? { note: c.note } : {}),
+            lines,
+            dropped,
+        });
     }
     return out;
 }

package/dist/config.js

@@ -50,6 +50,7 @@ const COMMAND_ARGS = {
     // No positional means the first available provider; `off` takes the tunnel down.
     expose: [0, 1],
     transcribe: [1, 2],
+    embed: [1],
     update: [0],
     webhook: [1],
     account: [1, 2],
@@ -67,8 +68,9 @@ const COMMAND_USAGE = {
     skills: "Run `wazap skills install [<harness>]`",
     service: "Run `wazap service install|status|start|stop|restart|logs|uninstall`",
     transcribe: "Run `wazap transcribe download` or `wazap transcribe test <audio file>`",
+    embed: "Run `wazap embed download`",
     contacts: "Run `wazap contacts resync`",
-    config: "Run `wazap config`, `wazap config writes on|off`, `wazap config transcribe local|openai|off`, or `wazap config webhook on|off`",
+    config: "Run `wazap config`, `wazap config writes on|off`, `wazap config transcribe local|openai|off`, `wazap config recall local|off`, or `wazap config webhook on|off`",
     webhook: "Run `wazap webhook test`",
     account: ACCOUNT_USAGE,
     migrate: MIGRATE_USAGE,
@@ -225,6 +227,7 @@ export function parseCli(argv = process.argv.slice(2)) {
                 rateLimit: sourceOf("WAZAP_RATE_LIMIT", false),
                 transcribe: sourceOf("WAZAP_TRANSCRIBE", false),
                 webhook: sourceOf("WAZAP_WEBHOOK", false),
+                recall: sourceOf("WAZAP_RECALL", false),
             },
             command,
             explicitCommand: first !== undefined,

package/dist/connect.js

@@ -135,8 +135,18 @@ export function whereInstalled(binPath = process.argv[1] ?? "", pathEnv = proces
     const script = binPath === "" ? "" : resolve(binPath);
     if (isNpxPath(binPath))
         return { kind: "npx", script };
-    if (commandOnPath("wazap", pathEnv, exists))
-        return { kind: "global", script };
+    const onPath = commandPath("wazap", pathEnv, exists);
+    if (onPath) {
+        try {
+            if (realpathSync(onPath) === realpathSync(script))
+                return { kind: "global", script };
+        }
+        catch {
+            // A package path or a direct launcher can still be classified when inspecting another host.
+            if (/[/\\]node_modules[/\\]wazap(?:-mcp)?[/\\]/.test(script) || resolve(onPath) === script)
+                return { kind: "global", script };
+        }
+    }
     return { kind: "checkout", script };
 }
 const GLOBAL_FIX = "run `npm i -g wazap-mcp` yourself (sudo on some Linux installs), then `wazap setup` again";
@@ -145,7 +155,12 @@ export function installGlobally(version = WAZAP_VERSION, npm = "npm") {
     const result = spawnSync(npm, ["install", "-g", `wazap-mcp@${version}`], { stdio: "inherit" });
     if (result.error !== undefined || result.status !== 0) {
         const detail = result.error === undefined ? `exit ${result.status ?? -1}` : result.error.message;
-        return { name: "install", state: "fail", detail: `npm install -g wazap-mcp@${version} failed (${detail})`, fix: GLOBAL_FIX };
+        return {
+            name: "install",
+            state: "fail",
+            detail: `npm install -g wazap-mcp@${version} failed (${detail})`,
+            fix: GLOBAL_FIX,
+        };
     }
     return { name: "install", state: "ok", detail: `wazap-mcp@${version} installed globally` };
 }
@@ -224,8 +239,9 @@ export const GUI_PATH = "/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin";
 export function mcpEntry(config, spec, install = whereInstalled()) {
     const entry = entryFor(install);
     // The global `wazap` bin is a symlink into the package, and launchd's PATH has
-    // neither it nor npx, so a GUI client gets this Node and the script behind it.
-    if (spec.gui && entry.command === "wazap") {
+    // neither it, nor npx, nor the bare `node` a checkout entry would name, so a
+    // GUI client gets this Node and the script behind it.
+    if (spec.gui && (entry.command === "wazap" || install.kind === "checkout")) {
         entry.command = process.execPath;
         entry.args = [realpathSync(install.script)];
     }
@@ -244,7 +260,11 @@ export function launchCheck(spec, entry, pathEnv = GUI_PATH, exists, platform =
     if (platform !== "darwin")
         return { name: "launch", state: "info", detail: "not checked on this platform" };
     if (isAbsolute(entry.command) || commandOnPath(entry.command, pathEnv, exists)) {
-        return { name: "launch", state: "ok", detail: `${spec.describe} can start \`${entry.command}\` without your shell PATH` };
+        return {
+            name: "launch",
+            state: "ok",
+            detail: `${spec.describe} can start \`${entry.command}\` without your shell PATH`,
+        };
     }
     return {
         name: "launch",

package/dist/deps.js

@@ -12,6 +12,7 @@ import { brand, info } from "./ui.js";
 export const DEPS = {
     whisper: { binary: "whisper-cli", brew: "whisper-cpp", why: "transcribes voice messages locally" },
     ffmpeg: { binary: "ffmpeg", brew: "ffmpeg", why: "converts voice notes for whisper" },
+    llama: { binary: "llama-server", brew: "llama.cpp", why: "embeds messages for local semantic recall" },
     tailscale: { binary: "tailscale", brew: "tailscale", why: "gives wazap a public https URL" },
     cloudflared: { binary: "cloudflared", brew: "cloudflared", why: "gives wazap a public https URL" },
 };

package/dist/doctor.js

@@ -1,10 +1,11 @@
 import { accessSync, constants, statSync } from "node:fs";
 import { AccountRegistry, accountPolicy, anyAccountLinked, resolveAccount } from "./accounts.js";
 import { readLinkedAccount } from "./auth-state.js";
-import { WAZAP_VERSION, WRITES_ENABLE_FIX, WRITE_TOKEN_NOTE, accountPaths, isRemoteHttp, paths } from "./config.js";
+import { WAZAP_VERSION, WRITES_ENABLE_FIX, WRITE_TOKEN_NOTE, accountPaths, isRemoteHttp, paths, } from "./config.js";
 import { asWazapError } from "./errors.js";
 import { lockHolder, lockPid } from "./lock.js";
 import { oauthProblem, readGrants } from "./oauth.js";
+import { EMBED_MODELS, embedModelPath, embedReady, readRecallSettings } from "./recall/index.js";
 import { installedService } from "./service.js";
 import { detectedTargets, skillState } from "./skills.js";
 import { MODELS, findWhisper, localProvider, maskKey, modelPath, readTranscribeSettings, which, } from "./transcribe/index.js";
@@ -25,6 +26,7 @@ const CHECKS = [
     checkSkills,
     checkOAuth,
     checkTranscribe,
+    checkRecall,
     checkWebhook,
     checkUpdate,
 ];
@@ -34,7 +36,7 @@ export async function runChecks(config) {
     const checks = [];
     for (const check of CHECKS)
         checks.push(...[await check(config)].flat());
-    let linked = false;
+    let linked;
     try {
         linked = anyAccountLinked(config.dataDir);
     }
@@ -81,7 +83,12 @@ function checkDataDir(config) {
         return { name: "data dir", state: "info", detail: `${dir} does not exist yet (login creates it)` };
     }
     if (!stat.isDirectory()) {
-        return { name: "data dir", state: "fail", detail: `${dir} is not a directory`, fix: "move it aside or use --data-dir" };
+        return {
+            name: "data dir",
+            state: "fail",
+            detail: `${dir} is not a directory`,
+            fix: "move it aside or use --data-dir",
+        };
     }
     const mode = stat.mode & 0o777;
     if (process.platform !== "win32" && mode !== 0o700) {
@@ -96,7 +103,12 @@ function checkDataDir(config) {
         accessSync(dir, constants.W_OK);
     }
     catch {
-        return { name: "data dir", state: "fail", detail: `${dir} is not writable`, fix: "fix its ownership or permissions" };
+        return {
+            name: "data dir",
+            state: "fail",
+            detail: `${dir} is not writable`,
+            fix: "fix its ownership or permissions",
+        };
     }
     return { name: "data dir", state: "ok", detail: `${dir} (0700, writable)` };
 }
@@ -165,7 +177,11 @@ function checkCredentials(config) {
     if (linkedIds.length === 0)
         return { name: "credentials", state: "info", detail: "no account linked yet" };
     // The number is deliberately absent: status is the thing people screenshot.
-    return { name: "credentials", state: "ok", detail: records.length > 1 ? `readable (${linkedIds.join(", ")})` : "readable" };
+    return {
+        name: "credentials",
+        state: "ok",
+        detail: records.length > 1 ? `readable (${linkedIds.join(", ")})` : "readable",
+    };
 }
 function checkWrites(config) {
     const selected = resolveAccount(config.dataDir, config.accountId);
@@ -278,6 +294,35 @@ async function localChecks(settings) {
             : { name: "model", state: "ok", detail: `${spec.file} (${Math.round(size / MIB)} MiB)` },
     ];
 }
+const RECALL_OFF_FIX = "run `wazap config recall local` to search messages by meaning";
+/**
+ * Off is quiet; on reports the sidecar binary and the model file, the two
+ * things `embed download` plus an install can repair.
+ */
+async function checkRecall(config) {
+    let settings;
+    try {
+        settings = readRecallSettings(process.env, config.dataDir);
+    }
+    catch (err) {
+        const failure = asWazapError(err);
+        return [{ name: "recall", state: "fail", detail: failure.message, fix: failure.fix }];
+    }
+    if (!settings.enabled)
+        return [{ name: "recall", state: "info", detail: "off", fix: RECALL_OFF_FIX }];
+    const spec = EMBED_MODELS[settings.model];
+    const size = fileSize(embedModelPath(settings.modelsDir, spec));
+    const readiness = await embedReady(settings, spec);
+    return [
+        { name: "recall", state: "ok", detail: `local (${settings.model})` },
+        readiness.ok
+            ? { name: "llama-server", state: "ok", detail: settings.embedUrl ?? "found" }
+            : { name: "llama-server", state: "fail", detail: readiness.detail, fix: readiness.fix },
+        size === null && settings.embedUrl === null
+            ? { name: "embed model", state: "fail", detail: `${spec.file} is not downloaded`, fix: "run `wazap embed download`" }
+            : { name: "embed model", state: "ok", detail: `${spec.file} (${Math.round((size ?? 0) / MIB)} MiB)` },
+    ];
+}
 /** W1 webhook: off is quiet; on without a URL or secret is a visible fail. */
 export function webhookCheck(env = process.env) {
     const settings = readWebhookSettings(env);
@@ -341,6 +386,11 @@ async function checkUpdate() {
     if (latest === null)
         return { name: "update", state: "info", detail: "update check skipped (no answer)" };
     return isNewer(latest, WAZAP_VERSION)
-        ? { name: "update", state: "info", detail: `${latest} is out (running ${WAZAP_VERSION})`, fix: "run `wazap update`" }
+        ? {
+            name: "update",
+            state: "info",
+            detail: `${latest} is out (running ${WAZAP_VERSION})`,
+            fix: "run `wazap update`",
+        }
         : { name: "update", state: "ok", detail: `${WAZAP_VERSION} is current` };
 }

package/dist/drafts.js

@@ -142,6 +142,9 @@ function formatNumber(digits) {
     const raw = digits.startsWith("+") ? digits.slice(1) : digits;
     if (!/^\d+$/.test(raw) || raw.length < 4)
         return digits.startsWith("+") ? digits : `+${digits}`;
-    const rest = raw.slice(2).match(/.{1,3}/g)?.join(" ") ?? raw.slice(2);
+    const rest = raw
+        .slice(2)
+        .match(/.{1,3}/g)
+        ?.join(" ") ?? raw.slice(2);
     return `+${raw.slice(0, 2)} ${rest}`;
 }

package/dist/errors.js

@@ -29,6 +29,7 @@ export const ERROR_GUIDE = {
     NOT_ADMIN: "The linked account is not an admin of that group, so this action is refused. Do not retry.",
     GROUP_ANNOUNCEMENT_ONLY: "Only admins may post in that group. Do not retry.",
     MEDIA_UNAVAILABLE: "The media expired on WhatsApp's servers or was never synced. Do not retry; ask the sender to resend.",
+    MEDIA_ACCESS_DENIED: "The URL is not a public http(s) address, or resolves to a private or internal one. Pass a public URL or download the file and use file_path.",
     FILE_NOT_FOUND: "The local path does not exist on the machine running wazap. Check the path with the user.",
     FILE_TOO_LARGE: "The file is too large. Chat media may be 100 MB; a profile picture may be 10 MB. Send a smaller file.",
     INVALID_IMAGE: "The file is not a JPEG, PNG or WebP. Pass a photo via file_path or url; GIF, video and documents are refused.",
@@ -41,6 +42,8 @@ export const ERROR_GUIDE = {
     RATE_LIMITED: "Too many writes too fast. Wait the number of seconds in the fix, then retry once.",
     TRANSCRIBE_UNAVAILABLE: "Transcription is off, or its binaries or model are missing. Tell the user to run the command in the fix; do not retry.",
     TRANSCRIBE_FAILED: "The transcription provider ran and failed. Read the message; retry once at most.",
+    RECALL_UNAVAILABLE: "Semantic recall is off, or llama.cpp or the embedding model is missing. Tell the user to run the command in the fix; do not retry.",
+    RECALL_FAILED: "The embedding backend ran and failed. Read the message; retry once at most.",
     TIMEOUT: "WhatsApp did not answer in time. Retry once; if it fails again, call get_status.",
     SERVICE_ERROR: "wazap's own background service could not be managed. This is a machine problem, not a WhatsApp one: read the fix and tell the user.",
     DRAFT_NOT_FOUND: "That draft_id is unknown or was already sent. Call the send tool again to draft, show the new preview, then confirm_send.",

package/dist/gif.js

@@ -25,11 +25,18 @@ export async function gifToMp4(gif) {
         const output = join(dir, "out.mp4");
         await writeFile(input, gif);
         const args = [
-            "-nostdin", "-loglevel", "error", "-y",
-            "-i", input,
-            "-movflags", "faststart",
-            "-pix_fmt", "yuv420p",
-            "-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2",
+            "-nostdin",
+            "-loglevel",
+            "error",
+            "-y",
+            "-i",
+            input,
+            "-movflags",
+            "faststart",
+            "-pix_fmt",
+            "yuv420p",
+            "-vf",
+            "scale=trunc(iw/2)*2:trunc(ih/2)*2",
             "-an",
             output,
         ];

package/dist/ids.js

@@ -2,7 +2,10 @@ import { WazapError } from "./errors.js";
 const PHONE_EXAMPLE = "Use international format, e.g. +15550100";
 /** Digits of a phone number in international format, or INVALID_PHONE. */
 export function normalizePhone(input) {
-    const digits = input.trim().replace(/^\+/, "").replace(/[\s\-().]/g, "");
+    const digits = input
+        .trim()
+        .replace(/^\+/, "")
+        .replace(/[\s\-().]/g, "");
     if (!/^\d+$/.test(digits) || digits.startsWith("0") || digits.length < 8 || digits.length > 15) {
         throw new WazapError("INVALID_PHONE", `"${input.trim()}" is not a phone number in international format.`, PHONE_EXAMPLE);
     }

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { BANNER } from "./banner.js";
-import { runAccount, runContacts, runGreet, runLogin, runLogout, runMigrate, runServe, runStatus, runTranscribe } from "./cli.js";
+import { runAccount, runContacts, runEmbed, runGreet, runLogin, runLogout, runMigrate, runServe, runStatus, runTranscribe, } from "./cli.js";
 import { WAZAP_VERSION, parseCli, pickDefaultAction } from "./config.js";
 import { migrateLayout } from "./migrate.js";
 import { CLIENT_NAMES, runConnect } from "./connect.js";
@@ -24,11 +24,12 @@ Usage:
   wazap service ${SERVICE_VERBS}
                                                            Keep the server running in the background, under launchd or systemd
   wazap expose [tailscale|cloudflare|off]                  Give the running service a public https URL cloud agents can reach
-  wazap config [writes on|off] [transcribe local|openai|off] [webhook on|off]
+  wazap config [writes on|off] [transcribe local|openai|off] [recall local|off] [webhook on|off]
                                                            Show the effective settings, or change one
   wazap webhook test [--event <name>] [--account <id>]     POST a test event to the configured webhook
   wazap transcribe download [--model <alias>]              Fetch the whisper.cpp model into the data dir
   wazap transcribe test <audio file>                       Transcribe a local file with the configured provider
+  wazap embed download [--model <alias>]                   Fetch the llama.cpp embedding model for semantic recall
   wazap contacts resync                                    Fetch the phone's address book from WhatsApp again
   wazap update [--dry-run]                                 Upgrade wazap, then the service and the skills that follow it
   wazap status [--live] [--json] [--account <id>]          Check the install, the session and the server
@@ -62,7 +63,8 @@ Options:
   --transcribe <how>  With setup: answer the transcription question (local, openai or off)
   --service           With setup: keep wazap running on this machine, without asking
   --expose            With setup: also give it a public URL cloud agents can reach
-  --model <alias>     With transcribe download: turbo (default), large-v3 or medium
+  --model <alias>     With transcribe download: turbo (default), large-v3 or medium.
+                      With embed download: embeddinggemma-300m (default) or e5-base-multilingual
   --dry-run           With connect, skills install, service install or update: print what would happen, and do nothing
   --live              With status: reach WhatsApp for real, then close the connection
   --json              With status: print the whole report as one JSON object on stdout
@@ -78,7 +80,8 @@ WAZAP_OAUTH_PASSWORD, WAZAP_RATE_LIMIT,
 WAZAP_NO_SHARE, WAZAP_NO_UPDATE_CHECK, WAZAP_TRANSCRIBE, WAZAP_TRANSCRIBE_AUTO,
 WAZAP_TRANSCRIBE_LANGUAGE, WAZAP_TRANSCRIBE_API_KEY, WAZAP_TRANSCRIBE_URL, WAZAP_TRANSCRIBE_MODEL,
 WAZAP_WHISPER_MODEL, WAZAP_WHISPER_BIN, WAZAP_WEBHOOK, WAZAP_WEBHOOK_URL,
-WAZAP_WEBHOOK_SECRET, WAZAP_WEBHOOK_EVENTS.
+WAZAP_WEBHOOK_SECRET, WAZAP_WEBHOOK_EVENTS, WAZAP_RECALL, WAZAP_RECALL_MAX,
+WAZAP_EMBED_MODEL, WAZAP_EMBED_BIN.
 An optional <data-dir>/.env is loaded if present.`;
 async function main() {
     const invocation = parseCli();
@@ -95,7 +98,16 @@ async function main() {
     // half-finished migrate and then fail to undo it. The other exempt commands
     // never open account state, and `service stop` is how a lock that blocks the
     // migration is released.
-    const MIGRATE_EXEMPT = new Set(["migrate", "service", "connect", "skills", "expose", "update", "transcribe"]);
+    const MIGRATE_EXEMPT = new Set([
+        "migrate",
+        "service",
+        "connect",
+        "skills",
+        "expose",
+        "update",
+        "transcribe",
+        "embed",
+    ]);
     if (!MIGRATE_EXEMPT.has(config.command))
         migrateLayout(config.dataDir);
     switch (config.command) {
@@ -130,6 +142,9 @@ async function main() {
         case "transcribe":
             await runTranscribe(config);
             return;
+        case "embed":
+            await runEmbed(config);
+            return;
         case "contacts":
             await runContacts(config);
             return;

package/dist/messages.js

@@ -82,7 +82,11 @@ const RULES = {
     extendedTextMessage: { type: "text", tag: "[text]", text: (m) => m.extendedTextMessage?.text },
     imageMessage: { type: "image", tag: "[image]", caption: (m) => m.imageMessage?.caption },
     // A GIF on WhatsApp is an mp4 with a flag; the reader deserves the word.
-    videoMessage: { type: "video", tag: (m) => (m.videoMessage?.gifPlayback ? "[gif]" : "[video]"), caption: (m) => m.videoMessage?.caption },
+    videoMessage: {
+        type: "video",
+        tag: (m) => (m.videoMessage?.gifPlayback ? "[gif]" : "[video]"),
+        caption: (m) => m.videoMessage?.caption,
+    },
     ptvMessage: { type: "video", tag: "[video]", caption: (m) => m.ptvMessage?.caption },
     audioMessage: {
         type: (m) => (m.audioMessage?.ptt ? "voice" : "audio"),
@@ -152,7 +156,12 @@ const MEDIA_KEYS = [
     "stickerMessage",
 ];
 /** Media whose WhatsApp envelope carries a JPEG preview of a few KB. */
-const THUMBNAIL_KEYS = ["imageMessage", "videoMessage", "ptvMessage", "documentMessage"];
+const THUMBNAIL_KEYS = [
+    "imageMessage",
+    "videoMessage",
+    "ptvMessage",
+    "documentMessage",
+];
 /** Envelopes that only wrap another message; the inner one is the real content. */
 function unwrapEnvelopes(content) {
     let current = content ?? undefined;
@@ -376,6 +385,35 @@ function spokenTranscript(raw, transcript) {
     const type = messageType(raw);
     return type === "voice" || type === "audio" ? transcript.text : undefined;
 }
+/**
+ * What the recall index stores for a message: the rendered view text when the
+ * message carries words a person chose, and null when it is only a placeholder
+ * — "[sticker]", "[deleted]", a call log, a reaction. A bare tag is nothing to
+ * search by; a voice note becomes indexable once its transcript exists.
+ */
+export function searchableText(raw, transcript) {
+    const spoken = spokenTranscript(raw, transcript);
+    const content = unwrapEnvelopes(raw.message);
+    const { rule, content: node } = ruleFor(content);
+    const type = resolve(rule.type, node);
+    if (type === "reaction" || type === "deleted" || type === "system")
+        return null;
+    const own = rule.text?.(node)?.trim() || rule.caption?.(node)?.trim() || rule.detail?.(node)?.trim() || "";
+    // No letter or digit means no words to embed — a "🥰🥰" or "..." only adds
+    // noise that outranks real hits on short queries.
+    if (!/[\p{L}\p{N}]/u.test(own) && spoken === undefined)
+        return null;
+    return viewText(raw, transcript);
+}
+/** The message a REVOKE protocol message takes back, when there is one. */
+export function revokedTargetKey(raw) {
+    const content = unwrapEnvelopes(raw.message);
+    const proto_ = content?.protocolMessage;
+    if (proto_?.type !== proto.Message.ProtocolMessage.Type.REVOKE)
+        return undefined;
+    const key = proto_.key;
+    return key?.id ? key : undefined;
+}
 /**
  * What a reader sees. searchMessages matches on this rather than on the bare
  * placeholder, so a transcript is findable by the words it puts on the screen.
@@ -482,7 +520,7 @@ function senderJid(raw, ctx) {
     const from = raw.key.participant || raw.participant || raw.key.remoteJid || "";
     return from ? ctx.canonical(from) : ctx.ownId;
 }
-function phoneOf(jid) {
+export function phoneOf(jid) {
     const [user = "", domain] = jid.split("@");
     return domain === "s.whatsapp.net" && /^\d+$/.test(user) ? user : undefined;
 }

package/dist/notes.js

@@ -8,6 +8,9 @@ import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 export class Notes {
     file;
+    /** Why the file on disk could not be read, or why the last save failed. Null when healthy. */
+    error = null;
+    loadError = null;
     contacts = new Map();
     handled = new Map();
     constructor(file) {
@@ -19,24 +22,38 @@ export class Notes {
         try {
             parsed = JSON.parse(readFileSync(this.file, "utf8"));
         }
-        catch {
+        catch (error) {
+            if (error.code !== "ENOENT")
+                this.error = this.loadError = error instanceof Error ? error.message : String(error);
             return;
         }
-        if (parsed?.v !== 1)
+        if (parsed?.v !== 1) {
+            this.error = this.loadError = "Unsupported notes file version";
             return;
+        }
         for (const [jid, note] of Object.entries(parsed.contacts ?? {}))
             this.contacts.set(jid, note);
         for (const [jid, mark] of Object.entries(parsed.handled ?? {}))
             this.handled.set(jid, mark);
     }
     save() {
+        // A file that never read cleanly must not be overwritten with a fresh one.
+        if (this.loadError)
+            throw new Error(`Cannot overwrite unreadable notes: ${this.loadError}`);
         const data = {
             v: 1,
             contacts: Object.fromEntries(this.contacts),
             handled: Object.fromEntries(this.handled),
         };
         mkdirSync(dirname(this.file), { recursive: true, mode: 0o700 });
-        writeFileSync(this.file, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+        try {
+            writeFileSync(this.file, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+            this.error = null;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+            throw error;
+        }
     }
     noteFor(jid) {
         return this.contacts.get(jid)?.note;