@rubytech/create-sitedesk-code 0.1.340

package/payload/platform/plugins/whatsapp/PLUGIN.md

@@ -0,0 +1,112 @@
+---
+name: whatsapp
+description: WhatsApp messaging channel — Baileys QR pairing, DM policy enforcement, inbound routing, business hours gating, conversation browsing. Reply-only in DMs (no agent-initiated send); observation-only in groups (the agent never responds in a group).
+tools:
+  - name: whatsapp-login-start
+    publicAllowlist: false
+    adminAllowlist: false
+  - name: whatsapp-login-wait
+    publicAllowlist: false
+    adminAllowlist: false
+  - name: whatsapp-status
+    publicAllowlist: false
+    adminAllowlist: false
+  - name: whatsapp-disconnect
+    publicAllowlist: false
+    adminAllowlist: false
+  - name: whatsapp-config
+    publicAllowlist: false
+    adminAllowlist: false
+  - name: whatsapp-activity
+    publicAllowlist: false
+    adminAllowlist: false
+  - name: whatsapp-conversations
+    publicAllowlist: false
+    adminAllowlist: false
+  - name: whatsapp-messages
+    publicAllowlist: false
+    adminAllowlist: false
+  - name: whatsapp-conversation-graph-state
+    publicAllowlist: false
+    adminAllowlist: false
+  - name: whatsapp-group-info
+    publicAllowlist: false
+    adminAllowlist: false
+metadata: {"platform":{"embed":["admin"]}}
+mcp:
+  command: node
+  args:
+    - ${PLATFORM_ROOT}/lib/mcp-spawn-tee/dist/index.js
+    - ${PLATFORM_ROOT}/plugins/whatsapp/mcp/dist/index.js
+  env:
+    MCP_SPAWN_TEE_NAME: whatsapp
+    LOG_DIR: ${LOG_DIR}
+    PLATFORM_ROOT: ${PLATFORM_ROOT}
+    ACCOUNT_ID: ${ACCOUNT_ID}
+    SESSION_ID: ${SESSION_ID}
+    PLATFORM_PORT: ${PLATFORM_PORT}
+mcp-manifest: auto
+---
+
+# WhatsApp
+
+Activate when the user asks about WhatsApp — connecting, linking, checking status, managing accounts, DM policies, group policies, or sending messages.
+
+## What this unlocks
+
+- QR-code-based WhatsApp pairing via Baileys (linked device) — `whatsapp-login-start` returns the QR as a scannable Unicode block printed on the PTY surface (the only operator surface); the operator scans it directly from the terminal output
+- Multi-account support (optional, multiple linked numbers)
+- Inbound message routing — sender-keyed `claude` PTY sessions via the loopback claude-session-manager (admin phone → admin agent, public → resolved public agent); a "typing…" presence is sent on receipt as an ack while the agent turn runs
+- Group observation — group messages are stored, persisted, and browsable, but the agent never responds in a group (observation-only)
+- DM policy enforcement (open, allowlist, disabled)
+- Conversation browsing — list active conversations, read message history, inspect group metadata
+- Inbound voice note transcription (OGG Opus → text via local whisper.cpp)
+- Outbound voice note normalization (OGG Opus via ffmpeg)
+- Auto-reconnection with exponential backoff
+- Business hours gating — public messages gated by `OpeningHoursSpecification` from Neo4j, with optional after-hours auto-reply via the `afterHoursMessage` config field
+
+## Conversation Browsing
+
+Four tools for reading WhatsApp conversation context. The first two read from the in-memory ring buffer (recent inbound, ~500 per JID, ephemeral). `whatsapp-conversation-graph-state` reads the durable graph view — the writer-known cypher lives in the platform route so the agent never composes its own. `whatsapp-group-info` queries the live WhatsApp servers.
+
+| Tool | Returns |
+|------|---------|
+| `whatsapp-conversations` | JIDs with recent message activity, conversation type (group/DM), last message timestamp, message count |
+| `whatsapp-messages` | In-memory ring-buffer messages for a specific JID — sender, body, timestamp, reply context. Supports optional `limit` for most recent N messages |
+| `whatsapp-conversation-graph-state` | Persisted `:Message:WhatsAppMessage` rows attached to the `:Conversation` (sessionKey-keyed) plus the resolved `sessionId`, the cypher string, and a divergence header reporting graph-row count vs in-memory count. Use when the question is "what got persisted" — never compose the cypher manually |
+| `whatsapp-group-info` | Group metadata from WhatsApp servers — subject, description, participants with admin flags, creation date. Requires active connection |
+
+## Group access — observation-only
+
+The agent never responds in a group. `checkGroupAccess` ([`inbound/access-control.ts`](../../ui/app/lib/whatsapp/inbound/access-control.ts)) is a structural observe-only deny — it always returns `allowed:false reason:group-observe-only`, so every group inbound ends at the manager's `!accessResult.allowed` return before dispatch. There is no group policy, allowlist, per-group activation, or @mention setting; setting any of those keys is a `.strict()` schema rejection, not a silently-dead key. A belt invariant in the manager's `reply` closure refuses any `@g.us` recipient and logs `op=group-reply-blocked` — that line is the leak signature if a dispatch path ever leaks.
+
+Observation is fully preserved: group messages are stored in the ring buffer, recorded as activity, and persisted to the graph at the access-independent capture site, and remain visible via `whatsapp-conversations`, `whatsapp-group-info`, `list-groups`, and the `/whatsapp` reader. This is a Meta-policy constraint (automated messaging from an unofficial linked device is penalised, the same class as the reply-only DM posture); for agent-driven group messaging, Telegram is the recommended channel.
+
+## Native channel reply surface
+
+A native admin channel session runs a per-sender `whatsapp-channel` MCP server (`platform/services/whatsapp-channel/`) exposing two reply-only tools: `reply` (text) and `reply-document` (one or more files delivered as WhatsApp documents). `reply-document` POSTs to the gateway's `POST /wa-channel/reply-document`, which funnels through `sendWhatsAppDocument` — the single send core that owns account-dir path validation, the 100 MB ceiling, the canonical `[whatsapp:outbound] sent document …` log, and per-file reconciliation (`op=reply-document-reconciled` on delivery, `file-delivery-unreconciled` on a miss — no silent failure). A bare `SendUserFile` is also caught and delivered through the same core by a read-only JSONL follower on the session, so an attachment reaches the sender even when the agent skips the explicit tool. Both surfaces are reply-only: a file reply to a sender with no live conversation is refused. See [channels-whatsapp.md](references/channels-whatsapp.md) and `.docs/whatsapp-inbound-lifeline.md`.
+
+## Self-chat command lane
+
+The agent links as a companion device on the operator's own WhatsApp account, so the operator cannot DM the agent from the paired handset — those messages arrive as `fromMe=true` / upsert type `append`. The operator's **self-chat** (message-yourself thread) is the command lane from that handset: the `append` branch in `manager.ts` evaluates a six-clause discriminator (`inbound/self-chat.ts`) — fromMe, self-surface jid (selfJid/selfLid/`selfPhone@s.whatsapp.net`, device-suffix normalised), not an agent-sent echo, timestamp strictly after `lastConnectedAt` (excludes reconnect history backfill; restart-safe backstop for the 2-min echo cache), not a duplicate, non-empty text — and dispatches a match to the **admin** agent with raw text; the reply lands back in the self-chat. Every self-chat `fromMe` message emits one `[whatsapp:self-chat] op=seen` line followed by `op=dispatch` or `op=skip reason=echo|backfill|duplicate|no-text`, so a dropped command is never silent. `fromMe` in any other thread is unchanged (`[Owner reply]` mirror). See [channels-whatsapp.md](references/channels-whatsapp.md) §Self-chat command lane.
+
+## Live persistence
+
+Every `messages.upsert` event (both `notify` and `append`, both `fromMe` directions) writes a `:Message:WhatsAppMessage` row to Neo4j attached to the sessionKey-keyed `:Conversation`. A single capture site at `platform/ui/app/lib/whatsapp/manager.ts` covers inbound, outbound (Baileys echoes agent-sent messages back through `messages.upsert` with `fromMe=true`), and owner-mirror — without touching `outbound/send.ts`. `messageId` namespace is `whatsapp-live:<waName>:<remoteJid>:<msg.key.id>` where `<waName>` is the Baileys credential dirname (e.g. `default`); distinct from the `:ConversationArchive` `:Section` chunks written by the source-agnostic `conversation-archive` skill (parent `:ConversationArchive` keyed on `conversationIdentity`, plus `:Section` children) — live and archive live in disjoint shapes. Persist failures are loud (`[whatsapp-persist] FAIL …`) and never block dispatch — silent loss is the worse failure mode.
+
+**`accountId` contract.** `n.accountId` on every `:Conversation`, `:Person`, and `:Message:WhatsAppMessage` row stamped by this plugin is the **platform-side UUID** resolved by [`resolvePlatformAccountId()`](../../ui/app/lib/whatsapp/platform-account-id.ts) from `data/accounts/<uuid>/account.json` — NOT the Baileys credential dirname (which is only used as the `messageId`/`sessionKey` namespace token). The boot-time line `[whatsapp-persist] resolved-account-id waname=<dir> uuid=<uuid>` records the resolution. Doctrine: see `.docs/neo4j.md` "Account isolation invariant" — every writer that stamps `n.accountId` must verify the value against `${DATA_ROOT}/accounts/<id>/account.json` before write. The helper loud-throws on zero or multi accounts (Phase 0 single-account invariant), aborting the WhatsApp connection start before any write can occur. The same boot-validated identity (`process.env.ACCOUNT_ID`) backs the central live floor at [`writeNodeWithEdges`](../../lib/graph-write/src/index.ts) — any write whose `accountId` differs from the spawning process's `ACCOUNT_ID` is rejected by the gate; the WhatsApp helper is the writer-side discipline, the gate is the universal floor. The env itself is stamped onto the brand systemd unit by `buildMaxyUnitFile` and re-validated at every Hono boot (`[graph-health] account-id-env present=true matches-on-disk=true`) — see `.docs/neo4j.md` "Two boot-time surfaces" (added 2026-05-07).
+
+## Skills
+
+| Skill | Purpose |
+|-------|---------|
+| [connect-whatsapp](skills/connect-whatsapp/SKILL.md) | Complete WhatsApp setup — QR pairing, admin phone registration, public agent selection |
+| [manage-whatsapp-config](skills/manage-whatsapp-config/SKILL.md) | Guided WhatsApp settings editing — DM policy, limits, acknowledgement |
+
+## References
+
+| Reference | Topics |
+|-----------|--------|
+| [channels-whatsapp.md](references/channels-whatsapp.md) | Implementation details — Baileys architecture, reconnection, voice notes, outbound policy, disconnect reasons |
+
+Config field definitions (field names, types, valid values) are available on-device via `whatsapp-config action: schema`.

package/payload/platform/plugins/whatsapp/lib/mcp-spawn-tee/index.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * MCP spawn-tee — in-process stderr capture + lifecycle observability.
+ *
+ * Claude Code spawns each MCP server itself; the platform never holds a
+ * ChildProcess handle. This shim sits between Claude Code and the real MCP
+ * server: Claude Code runs `node <this> <real-entry>`, and the shim runs the
+ * real entry IN ITS OWN PROCESS via dynamic import() — one node runtime, not
+ * two. Before importing, it replaces process.stderr.write with a tee so every
+ * stderr byte the server writes is mirrored to the log sinks; stdin and stdout
+ * (the JSON-RPC channel) are never touched.
+ *
+ *   Claude Code CLI → shim (this file) = node running <real-entry> in-process
+ *        stdin/stdout : untouched (JSON-RPC channel)
+ *        stderr       : process.stderr.write teed → per-date + per-session + passthrough
+ *
+ * Destinations (Task 706) — unchanged:
+ *   - `${LOG_DIR}/mcp-<name>-stderr-<date>.log`  — per-date raw (back-compat;
+ *     the in-process mcp-stderr-tee and the [mcp-init-error] probe read it).
+ *   - `${LOG_DIR}/mcp-<name>-<SESSION_ID>.log`   — per-session raw + lifecycle
+ *     lines. Authoritative sink. Absent when SESSION_ID is unset (enumeration
+ *     spawn) — then the per-date file is the fallback.
+ *   - `server.log` via the loopback log-ingest route — best-effort mirror of
+ *     the [mcp-helper] lifecycle lines.
+ *
+ * Lifecycle lines, correlation key `session=<id8> server=<name>` — unchanged:
+ *   [mcp-helper] op=spawn ... pid= entry=
+ *   [mcp-helper] op=boot  ... head=<first stderr bytes>
+ *   [mcp-helper] op=exit  ... code= signal= lifetimeMs= stderr-tail=
+ *
+ * Process model (Task 989): the shim IS the server's process. op=exit fires
+ * from process.on("exit"), so it covers a normal exit, a non-zero exit, an
+ * uncaught throw (code 1), and a catchable-signal exit (SIGTERM/SIGINT/SIGHUP,
+ * whose handlers record the signal name). An external SIGKILL is uncatchable
+ * and leaves no op=exit line — the per-session stderr tail already on disk and
+ * Claude Code's own transport-drop are the evidence for that death mode.
+ *
+ * The shim never writes to fd 1 (stdout) — that is the JSON-RPC channel.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const SERVER_NAME = process.env.MCP_SPAWN_TEE_NAME ?? "unknown";
+const LOG_DIR = process.env.LOG_DIR;
+const SESSION_ID = process.env.SESSION_ID;
+const PLATFORM_PORT = process.env.PLATFORM_PORT;
+const ENTRY = process.argv[2];
+const SESSION_ID8 = SESSION_ID ? SESSION_ID.slice(0, 8) : "—";
+const spawnStamp = Date.now();
+// Per-session raw + lifecycle log (Task 706). Empty SESSION_ID (enumeration
+// spawn) → undefined, and the per-date file is the fallback.
+const perSessionPath = LOG_DIR && SESSION_ID
+    ? (0, node_path_1.resolve)(LOG_DIR, `mcp-${SERVER_NAME}-${SESSION_ID}.log`)
+    : undefined;
+const perDatePath = LOG_DIR
+    ? (0, node_path_1.resolve)(LOG_DIR, `mcp-${SERVER_NAME}-stderr-${new Date(spawnStamp).toISOString().slice(0, 10)}.log`)
+    : undefined;
+// Rolling tail of entry stderr for op=exit. Capped so a chatty server cannot
+// grow the buffer without bound.
+const TAIL_CAP = 2048;
+let stderrTail = "";
+let bootEmitted = false;
+let exitEmitted = false;
+let exitSignal;
+// The real stderr writer, captured before the tee replaces it. Lifecycle lines
+// and stderr passthrough both go through this so they are never re-teed into
+// the per-date sink nor recursed back into the patched writer.
+const rawStderrWrite = process.stderr.write.bind(process.stderr);
+// LOG_DIR is created once, lazily, on the first successful append — not per
+// chunk. teeWrite runs on the server's own stderr hot path now, so a per-call
+// mkdirSync would be two syscalls per log line for nothing.
+let logDirReady = false;
+function appendSafe(path, data) {
+    if (!path || !LOG_DIR)
+        return;
+    try {
+        if (!logDirReady) {
+            (0, node_fs_1.mkdirSync)(LOG_DIR, { recursive: true });
+            logDirReady = true;
+        }
+        (0, node_fs_1.appendFileSync)(path, data);
+    }
+    catch {
+        /* unwritable destination — never mask primary output */
+    }
+}
+// Best-effort mirror of a lifecycle line to server.log via the loopback
+// log-ingest route. Fire-and-forget: the per-session file is authoritative, so
+// a dropped POST loses nothing. On the "exit" event the loop is stopping, so
+// the op=exit mirror may not flush — the per-session line, written sync, holds.
+function postToServerLog(suffix, level) {
+    if (!PLATFORM_PORT)
+        return;
+    try {
+        const ctrl = new AbortController();
+        const t = setTimeout(() => ctrl.abort(), 500);
+        t.unref?.(); // never let the abort timer keep the shim's event loop alive
+        void fetch(`http://127.0.0.1:${PLATFORM_PORT}/api/admin/log-ingest`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ tag: "mcp-helper", level, line: suffix }),
+            signal: ctrl.signal,
+        }).then(() => clearTimeout(t)).catch(() => clearTimeout(t));
+    }
+    catch {
+        /* fetch threw synchronously — best-effort only */
+    }
+}
+// Emit one [mcp-helper] lifecycle line: authoritative per-session file (sync,
+// survives process.exit), the shim's own stderr via the RAW writer (journald /
+// Claude Code visibility, never re-teed), and a best-effort server.log mirror.
+// `suffix` is the line body after the tag and carries no newline (the
+// log-ingest route rejects newlines).
+function emitLifecycle(suffix, level) {
+    const line = `[mcp-helper] ${suffix}\n`;
+    appendSafe(perSessionPath, line);
+    try {
+        rawStderrWrite(line);
+    }
+    catch { /* stderr closed */ }
+    postToServerLog(suffix, level);
+}
+if (!ENTRY) {
+    emitLifecycle(`op=error session=${SESSION_ID8} server=${SERVER_NAME} reason="no entry given (argv[2] missing)"`, "error");
+    process.exit(2);
+}
+// Replace process.stderr.write with a tee: mirror every server stderr byte to
+// the per-date and per-session sinks, keep a rolling tail for op=exit, emit
+// op=boot on the first bytes, then pass the write through to the real stderr.
+const teeWrite = ((...args) => {
+    const chunk = args[0];
+    appendSafe(perDatePath, chunk); // per-date raw (back-compat)
+    appendSafe(perSessionPath, chunk); // per-session raw (Task 706)
+    const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    stderrTail = (stderrTail + text).slice(-TAIL_CAP);
+    if (!bootEmitted) {
+        bootEmitted = true;
+        const head = text.split("\n")[0].slice(0, 200);
+        emitLifecycle(`op=boot session=${SESSION_ID8} server=${SERVER_NAME} head=${JSON.stringify(head)}`, "info");
+    }
+    return rawStderrWrite(...args); // passthrough
+});
+process.stderr.write = teeWrite;
+// Catchable-signal handling. The shim drives the exit ONLY when it is the sole
+// listener for the signal — i.e. the imported entry installed no handler of its
+// own. In that case it records the signal (so op=exit carries signal=<sig>) and
+// exits with 128+signum, mirroring the prior wrapper's exit-status convention.
+//
+// When the entry DID install a handler, the shim defers entirely and records
+// nothing: the entry's handler decides the exit code, and op=exit reflects that
+// exit verbatim. This matches the prior two-process model, where a child that
+// caught the signal and exited cleanly was observed as code=0 signal=— (a clean
+// self-exit), not as a signal death. Setting exitSignal here unconditionally
+// would mislabel every graceful signal-driven shutdown as a signal kill.
+function onSignal(sig, code) {
+    return () => {
+        if (process.listenerCount(sig) === 1) {
+            exitSignal = sig;
+            process.exit(code);
+        }
+    };
+}
+process.on("SIGTERM", onSignal("SIGTERM", 143));
+process.on("SIGINT", onSignal("SIGINT", 130));
+process.on("SIGHUP", onSignal("SIGHUP", 129));
+// op=exit, emitted once from the process "exit" event. Sync-only — the loop is
+// stopping. When a catchable signal caused the exit, report code=— signal=<sig>
+// to match the prior wrapper's format; otherwise code=<exit code> signal=—.
+process.on("exit", (code) => {
+    if (exitEmitted)
+        return;
+    exitEmitted = true;
+    const lifetimeMs = Date.now() - spawnStamp;
+    const tail = stderrTail.slice(-200);
+    const codeField = exitSignal ? "—" : String(code);
+    const level = exitSignal || code !== 0 ? "error" : "info";
+    emitLifecycle(`op=exit session=${SESSION_ID8} server=${SERVER_NAME} pid=${process.pid} ` +
+        `code=${codeField} signal=${exitSignal ?? "—"} lifetimeMs=${lifetimeMs} stderr-tail=${JSON.stringify(tail)}`, level);
+});
+emitLifecycle(`op=spawn session=${SESSION_ID8} server=${SERVER_NAME} pid=${process.pid} entry=${ENTRY}`, "info");
+// Run the real MCP server in THIS process. Dynamic import() (not top-level
+// await — this file compiles to CommonJS) loads the ESM entry; a load-time
+// failure mirrors the old child spawn-error path (op=error, exit 127). The
+// op=exit handler is suppressed on this path so op=error stays the sole record.
+import((0, node_url_1.pathToFileURL)(ENTRY).href).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    exitEmitted = true;
+    emitLifecycle(`op=error session=${SESSION_ID8} server=${SERVER_NAME} reason=${JSON.stringify(`import error: ${msg}`)}`, "error");
+    process.exit(127);
+});
+//# sourceMappingURL=index.js.map

package/payload/platform/plugins/whatsapp/lib/mcp-spawn-tee/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/payload/platform/plugins/whatsapp/mcp/dist/__tests__/boot-without-env.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=boot-without-env.test.d.ts.map

package/payload/platform/plugins/whatsapp/mcp/dist/__tests__/boot-without-env.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot-without-env.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/boot-without-env.test.ts"],"names":[],"mappings":""}

package/payload/platform/plugins/whatsapp/mcp/dist/__tests__/boot-without-env.test.js

@@ -0,0 +1,58 @@
+// Task 265 — CC's plugin-system enumerates tools/list by spawning this
+// server with empty env. Module-init must not throw `MissingPortEnvError`;
+// any throw empties plugin registry #1 and breaks /agents resolution
+// (see learnings_mcp_module_init_never_throws_on_per_account_env.md).
+//
+// This test spawns the compiled dist/index.js with env: {} and asserts:
+//   1. The process accepts JSON-RPC initialize without exiting with the
+//      module-init throw.
+//   2. tools/list returns the tool descriptor list.
+//
+// The MCP stdio transport exits cleanly when stdin EOFs, so success here
+// is "got the initialize + tools/list responses on stdout, never saw
+// `[whatsapp:module-init] missing-port-env` on stderr."
+import { describe, it, expect } from "vitest";
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+const SERVER_BIN = resolve(__dirname, "..", "..", "dist", "index.js");
+describe("whatsapp MCP boot without env", () => {
+    it("initialize + tools/list succeed with env: {}", async () => {
+        const child = spawn(process.execPath, [SERVER_BIN], {
+            env: {},
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (b) => { stdout += String(b); });
+        child.stderr.on("data", (b) => { stderr += String(b); });
+        child.stdin.write(JSON.stringify({
+            jsonrpc: "2.0", id: 1, method: "initialize",
+            params: {
+                protocolVersion: "2024-11-05",
+                capabilities: {},
+                clientInfo: { name: "boot-test", version: "0" },
+            },
+        }) + "\n");
+        child.stdin.write(JSON.stringify({
+            jsonrpc: "2.0", method: "notifications/initialized",
+        }) + "\n");
+        child.stdin.write(JSON.stringify({
+            jsonrpc: "2.0", id: 2, method: "tools/list",
+        }) + "\n");
+        // Wait for both responses, then close stdin to let the server exit.
+        await new Promise((res) => setTimeout(res, 500));
+        child.stdin.end();
+        const exitCode = await new Promise((res) => {
+            child.on("exit", (code) => res(code ?? -1));
+        });
+        expect(stderr).not.toMatch(/missing-port-env reason=missing-env/);
+        expect(exitCode).toBe(0);
+        const lines = stdout.trim().split("\n").map((l) => JSON.parse(l));
+        const initResp = lines.find((m) => m.id === 1);
+        expect(initResp?.result?.serverInfo?.name).toBe("maxy-whatsapp");
+        const toolsResp = lines.find((m) => m.id === 2);
+        expect(Array.isArray(toolsResp?.result?.tools)).toBe(true);
+        expect(toolsResp.result.tools.length).toBeGreaterThan(0);
+    }, 10_000);
+});
+//# sourceMappingURL=boot-without-env.test.js.map

package/payload/platform/plugins/whatsapp/mcp/dist/__tests__/boot-without-env.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot-without-env.test.js","sourceRoot":"","sources":["../../src/__tests__/boot-without-env.test.ts"],"names":[],"mappings":"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"}

package/payload/platform/plugins/whatsapp/mcp/dist/__tests__/format-login-start.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=format-login-start.test.d.ts.map

package/payload/platform/plugins/whatsapp/mcp/dist/__tests__/format-login-start.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-login-start.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/format-login-start.test.ts"],"names":[],"mappings":""}

package/payload/platform/plugins/whatsapp/mcp/dist/__tests__/format-login-start.test.js

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "vitest";
+import { buildLoginStartText } from "../format.js";
+describe("buildLoginStartText", () => {
+    it("renders the pairing code and the phone-side steps", () => {
+        const text = buildLoginStartText({ message: "msg", pairingCode: "ABCD1234" });
+        expect(text).toContain("ABCD1234");
+        expect(text).toContain("Link with phone number instead");
+        expect(text).toContain("whatsapp-login-wait");
+    });
+    it("falls back to the message when no code is present", () => {
+        const text = buildLoginStartText({ message: "WhatsApp already linked (+44...)." });
+        expect(text).toContain("already linked");
+        expect(text).not.toContain("Link with phone number instead");
+    });
+});
+//# sourceMappingURL=format-login-start.test.js.map

package/payload/platform/plugins/whatsapp/mcp/dist/__tests__/format-login-start.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-login-start.test.js","sourceRoot":"","sources":["../../src/__tests__/format-login-start.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEnD,QAAQ,CAAC,qBAAqB,EAAE,GAAG,EAAE;IACnC,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;QAC3D,MAAM,IAAI,GAAG,mBAAmB,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;QAC9E,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QACnC,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,gCAAgC,CAAC,CAAC;QACzD,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,qBAAqB,CAAC,CAAC;IAChD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;QAC3D,MAAM,IAAI,GAAG,mBAAmB,CAAC,EAAE,OAAO,EAAE,mCAAmC,EAAE,CAAC,CAAC;QACnF,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;QACzC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,gCAAgC,CAAC,CAAC;IAC/D,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/payload/platform/plugins/whatsapp/mcp/dist/call-api.d.ts

@@ -0,0 +1,14 @@
+/**
+ * MCP tool helper that calls the WhatsApp Hono routes on localhost and
+ * surfaces structured error bodies on non-2xx responses.
+ *
+ * Why this exists separate from `index.ts`: the previous inline helper at
+ * `index.ts:36-38` discarded the response body on every non-2xx, returning
+ * only `HTTP <status>: <statusText>`. The Hono route emits validation
+ * details (e.g. `{ ok: false, error: "Unrecognized keys: mode, agent" }`)
+ * that the agent needs to self-correct. Without surfacing them, every
+ * 400 looks identical and the agent retries blindly until max-turns
+ * (root cause).
+ */
+export declare function callApi(baseUrl: string, path: string, method?: "GET" | "POST", body?: unknown): Promise<unknown>;
+//# sourceMappingURL=call-api.d.ts.map

package/payload/platform/plugins/whatsapp/mcp/dist/call-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-api.d.ts","sourceRoot":"","sources":["../src/call-api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,wBAAsB,OAAO,CAC3B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,GAAE,KAAK,GAAG,MAAe,EAC/B,IAAI,CAAC,EAAE,OAAO,GACb,OAAO,CAAC,OAAO,CAAC,CA2BlB"}

package/payload/platform/plugins/whatsapp/mcp/dist/call-api.js

@@ -0,0 +1,42 @@
+/**
+ * MCP tool helper that calls the WhatsApp Hono routes on localhost and
+ * surfaces structured error bodies on non-2xx responses.
+ *
+ * Why this exists separate from `index.ts`: the previous inline helper at
+ * `index.ts:36-38` discarded the response body on every non-2xx, returning
+ * only `HTTP <status>: <statusText>`. The Hono route emits validation
+ * details (e.g. `{ ok: false, error: "Unrecognized keys: mode, agent" }`)
+ * that the agent needs to self-correct. Without surfacing them, every
+ * 400 looks identical and the agent retries blindly until max-turns
+ * (root cause).
+ */
+export async function callApi(baseUrl, path, method = "POST", body) {
+    const res = await fetch(`${baseUrl}${path}`, {
+        method,
+        headers: body ? { "Content-Type": "application/json" } : undefined,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (res.ok)
+        return res.json();
+    const fallback = `HTTP ${res.status}: ${res.statusText} (${method} ${path})`;
+    let text;
+    try {
+        text = await res.text();
+    }
+    catch {
+        return { ok: false, error: fallback };
+    }
+    if (!text)
+        return { ok: false, error: fallback };
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed.error === "string" && parsed.error.trim()) {
+            return { ok: false, error: parsed.error };
+        }
+        return { ok: false, error: fallback };
+    }
+    catch {
+        return { ok: false, error: fallback };
+    }
+}
+//# sourceMappingURL=call-api.js.map

package/payload/platform/plugins/whatsapp/mcp/dist/call-api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-api.js","sourceRoot":"","sources":["../src/call-api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,OAAe,EACf,IAAY,EACZ,SAAyB,MAAM,EAC/B,IAAc;IAEd,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,GAAG,OAAO,GAAG,IAAI,EAAE,EAAE;QAC3C,MAAM;QACN,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC,CAAC,CAAC,SAAS;QAClE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS;KAC9C,CAAC,CAAC;IAEH,IAAI,GAAG,CAAC,EAAE;QAAE,OAAO,GAAG,CAAC,IAAI,EAAE,CAAC;IAE9B,MAAM,QAAQ,GAAG,QAAQ,GAAG,CAAC,MAAM,KAAK,GAAG,CAAC,UAAU,KAAK,MAAM,IAAI,IAAI,GAAG,CAAC;IAC7E,IAAI,IAAY,CAAC;IACjB,IAAI,CAAC;QACH,IAAI,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC;IAC1B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;IACxC,CAAC;IACD,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;IAEjD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAA4B,CAAC;QAC3D,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;YAC5D,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;QAC5C,CAAC;QACD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;IACxC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;IACxC,CAAC;AACH,CAAC"}

package/payload/platform/plugins/whatsapp/mcp/dist/format.d.ts

@@ -0,0 +1,7 @@
+/** Pure formatters for WhatsApp MCP tool results (testable without booting the server). */
+export declare function buildLoginStartText(result: {
+    message?: string;
+    pairingCode?: string;
+    selfPhone?: string;
+}): string;
+//# sourceMappingURL=format.d.ts.map

package/payload/platform/plugins/whatsapp/mcp/dist/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../src/format.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAE3F,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,MAAM,CAkBT"}

package/payload/platform/plugins/whatsapp/mcp/dist/format.js

@@ -0,0 +1,21 @@
+/** Pure formatters for WhatsApp MCP tool results (testable without booting the server). */
+export function buildLoginStartText(result) {
+    let response = result.message ?? "";
+    if (result.pairingCode) {
+        response = [
+            `WhatsApp pairing code: ${result.pairingCode}`,
+            "",
+            "Tell the operator, on the phone whose number this is:",
+            "1. Open WhatsApp → Settings → Linked Devices → Link a Device",
+            '2. Tap "Link with phone number instead"',
+            `3. Enter this code: ${result.pairingCode}`,
+            "",
+            "Then call whatsapp-login-wait to poll for completion.",
+        ].join("\n");
+    }
+    if (result.selfPhone) {
+        response += `\nLinked phone: ${result.selfPhone}`;
+    }
+    return response;
+}
+//# sourceMappingURL=format.js.map

package/payload/platform/plugins/whatsapp/mcp/dist/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../src/format.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAE3F,MAAM,UAAU,mBAAmB,CAAC,MAInC;IACC,IAAI,QAAQ,GAAG,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC;IACpC,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;QACvB,QAAQ,GAAG;YACT,0BAA0B,MAAM,CAAC,WAAW,EAAE;YAC9C,EAAE;YACF,uDAAuD;YACvD,8DAA8D;YAC9D,yCAAyC;YACzC,uBAAuB,MAAM,CAAC,WAAW,EAAE;YAC3C,EAAE;YACF,uDAAuD;SACxD,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACf,CAAC;IACD,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;QACrB,QAAQ,IAAI,mBAAmB,MAAM,CAAC,SAAS,EAAE,CAAC;IACpD,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/payload/platform/plugins/whatsapp/mcp/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WhatsApp MCP server — exposes WhatsApp lifecycle tools to the admin agent.
+ *
+ * Tools call the platform's Hono API routes (localhost) which manage the
+ * Baileys connection lifecycle in the server process.
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/payload/platform/plugins/whatsapp/mcp/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}