Business operating system for Claude Code — 57 skills, 21 agents, smart daemon. Unified inbox (WhatsApp/Email/Slack/Telegram), autonomous PR merge, full-AWS monitoring, revenue (Stripe+RevenueCat), e-commerce (Shopify), marketing (Klaviyo/Meta/GA4), voice (Bland/ElevenLabs), APM (Datadog/NewRelic/OTEL), YOLO mode.
Shell agent-teamsai-agentai-automationanthropicautonomous-agentawsbusiness-operationsclaudeclaude-codeclaude-code-plugindevopsecommerceinbox-zeroklaviyomarketingmcpmorning-briefingpr-automationshopifyterminal
fix(whatsapp-mcp): persist outbound sends, resync_app_state endpoint, dict serialisation (Fix C/D/E)
Aurora Capitalb6cb902cc560
diff --git a/claude-ops/scripts/whatsapp/apply-patches.py b/claude-ops/scripts/whatsapp/apply-patches.pyindex 2b8619e4..369b8d0c 100755--- a/claude-ops/scripts/whatsapp/apply-patches.py+++ b/claude-ops/scripts/whatsapp/apply-patches.py@@ -16,6 +16,19 @@ Patches included:Python whatsapp.py — LID-to-phone resolver via whatsmeow_lid_map, andcontact-name lookup via whatsmeow_contacts (replaces the macOS-only`contacts` table populated by the Contacts.app mapper).+ Fix C — Outbound send persistence: /api/send handler persists sent messages+ as is_from_me=1 rows in messages.db immediately after SendMessage+ succeeds. Without this, agent-sent messages were absent from the MCP+ read path (bridge only stored phone-originated echoes, not API sends).+ Fix D — POST /api/resync_app_state REST endpoint: makes the MCP server's+ resync_app_state tool actually reachable (previously returned 404).+ Triggers client.FetchAppState for the requested patch name.+ Fix E — Python MCP shape fix: all tool functions now return JSON-serialisable+ dicts (not dataclass objects). Adds _open_db() with WAL mode so reads+ never block the bridge writer and always see the latest committed state+ (single source of truth). Fixes the 30+ pydantic validation errors on+ list_chats, list_messages, search_contacts, get_chat, get_contact_chats,+ get_direct_chat_by_contact, get_last_interaction, get_message_context.Every patch is gated on a sentinel string so re-running is a no-op.@@ -332,6 +345,220 @@ def _name_from_whatsmeow_contacts(jid: str):PY_PATH_SENTINEL = "_name_from_whatsmeow_contacts"+# ─── main.go Fix C: persist outbound sends to messages.db (is_from_me=1) ─────+# The /api/send handler called client.SendMessage but discarded the response and+# never wrote a row to messages.db. Phone-originated self-sends were stored via+# the inbound event path, but agent sends via POST /api/send were invisible to+# the MCP read path. This patch persists each successful send immediately.+OUTBOUND_PERSIST_NEEDLE = """\t// Send message+\t_, err = client.SendMessage(context.Background(), recipientJID, msg)++\tif err != nil {+\t\treturn false, fmt.Sprintf("Error sending message: %v", err)+\t}++\treturn true, fmt.Sprintf("Message sent to %s", recipient)+}"""++OUTBOUND_PERSIST_REPLACEMENT = """\t// Send message+\tsendResp, err := client.SendMessage(context.Background(), recipientJID, msg)++\tif err != nil {+\t\treturn false, fmt.Sprintf("Error sending message: %v", err)+\t}++\t// claude-ops Fix C: persist the sent message to messages.db so the MCP server+\t// sees it as is_from_me=1 (single source of truth). The bridge's inbound event+\t// handler stores phone-originated sends; POST /api/send sends were previously+\t// never written. INSERT OR REPLACE is idempotent if whatsmeow also echoes it.+\tif messageStore != nil {+\t\tchatJID := recipientJID.String()+\t\tsenderJID := client.Store.ID.User+\t\tts := sendResp.Timestamp+\t\tif ts.IsZero() {+\t\t\tts = time.Now()+\t\t}+\t\tmsgID := string(sendResp.ID)+\t\tif msgID == "" {+\t\t\tmsgID = client.GenerateMessageID()+\t\t}+\t\t_ = messageStore.StoreChat(chatJID, "", ts)+\t\t_ = messageStore.StoreMessage(+\t\t\tmsgID, chatJID, senderJID, message, ts, true,+\t\t\t"", "", "", nil, nil, nil, 0,+\t\t)+\t}++\treturn true, fmt.Sprintf("Message sent to %s", recipient)+}"""++OUTBOUND_PERSIST_SENTINEL = "claude-ops Fix C: persist the sent message"++# The function signature must also accept *MessageStore (needle matches original)+OUTBOUND_SIG_NEEDLE = "func sendWhatsAppMessage(client *whatsmeow.Client, recipient string, message string, mediaPath string) (bool, string) {"+OUTBOUND_SIG_REPLACEMENT = "func sendWhatsAppMessage(client *whatsmeow.Client, messageStore *MessageStore, recipient string, message string, mediaPath string) (bool, string) {"+OUTBOUND_SIG_SENTINEL = "messageStore *MessageStore, recipient string"++# The /api/send call site must pass messageStore+OUTBOUND_CALLSITE_NEEDLE = "success, message := sendWhatsAppMessage(client, req.Recipient, req.Message, req.MediaPath)"+OUTBOUND_CALLSITE_REPLACEMENT = "// messageStore passed so outbound is persisted immediately (claude-ops Fix C)\n\t\tsuccess, message := sendWhatsAppMessage(client, messageStore, req.Recipient, req.Message, req.MediaPath)"+OUTBOUND_CALLSITE_SENTINEL = "messageStore passed so outbound is persisted immediately"++# The appstate import is needed for Fix D+APPSTATE_IMPORT_NEEDLE = (+ '\t"go.mau.fi/whatsmeow"\n\twaProto "go.mau.fi/whatsmeow/binary/proto"'+)+APPSTATE_IMPORT_REPLACEMENT = '\t"go.mau.fi/whatsmeow"\n\t"go.mau.fi/whatsmeow/appstate"\n\twaProto "go.mau.fi/whatsmeow/binary/proto"'+APPSTATE_IMPORT_SENTINEL = '"go.mau.fi/whatsmeow/appstate"'++# ─── main.go Fix D: POST /api/resync_app_state REST endpoint ──────────────────+RESYNC_ENDPOINT_NEEDLE = """\t// Run server in a goroutine so it doesn't block+\tgo func() {+\t\tif err := http.ListenAndServe(serverAddr, nil); err != nil {+\t\t\tfmt.Printf(\"REST API server error: %v\\n\", err)+\t\t}+\t}()+}"""++RESYNC_ENDPOINT_REPLACEMENT = """\t// claude-ops Fix D: POST /api/resync_app_state — force a full whatsmeow+\t// app-state resync. Used by the MCP server's resync_app_state tool.+\t// Body: {"name":"regular_low","full_sync":true}+\thttp.HandleFunc(\"/api/resync_app_state\", func(w http.ResponseWriter, r *http.Request) {+\t\tif r.Method != http.MethodPost {+\t\t\thttp.Error(w, \"Method not allowed\", http.StatusMethodNotAllowed)+\t\t\treturn+\t\t}+\t\tw.Header().Set(\"Content-Type\", \"application/json\")+\t\tif !client.IsConnected() {+\t\t\tw.WriteHeader(http.StatusServiceUnavailable)+\t\t\tfmt.Fprintln(w, `{\"success\":false,\"message\":\"client not connected\"}`)+\t\t\treturn+\t\t}+\t\tvar req struct {+\t\t\tName string `json:\"name\"`+\t\t\tFullSync bool `json:\"full_sync\"`+\t\t}+\t\treq.Name = \"regular_low\"+\t\treq.FullSync = true+\t\tif err := json.NewDecoder(r.Body).Decode(&req); err == nil {+\t\t\tif req.Name == \"\" {+\t\t\t\treq.Name = \"regular_low\"+\t\t\t}+\t\t}+\t\tif err := client.FetchAppState(context.Background(), appstate.WAPatchName(req.Name), req.FullSync, false); err != nil {+\t\t\tw.WriteHeader(http.StatusInternalServerError)+\t\t\tfmt.Fprintf(w, `{\"success\":false,\"message\":%q}`, err.Error())+\t\t\treturn+\t\t}+\t\tfmt.Fprintf(w, `{\"success\":true,\"message\":\"app-state %s resynced\"}`, req.Name)+\t})++\t// Run server in a goroutine so it doesn't block+\tgo func() {+\t\tif err := http.ListenAndServe(serverAddr, nil); err != nil {+\t\t\tfmt.Printf(\"REST API server error: %v\\n\", err)+\t\t}+\t}()+}"""++RESYNC_ENDPOINT_SENTINEL = "claude-ops Fix D: POST /api/resync_app_state"++# ─── main.go Fix D (Connected): auto-resync regular_low on startup ────────────+CONNECTED_RESYNC_NEEDLE = """\t\tcase *events.Connected:+\t\t\tlogger.Infof(\"Connected to WhatsApp\")+\t\t\t// claude-ops: auto-trigger a deep history backfill on every Connected event."""++CONNECTED_RESYNC_REPLACEMENT = """\t\tcase *events.Connected:+\t\t\tlogger.Infof(\"Connected to WhatsApp\")+\t\t\t// claude-ops Fix D: force a full resync of the regular_low app-state patch+\t\t\t// on every connect. Clears LTHash mismatch errors that fire when the local+\t\t\t// snapshot is stale. Non-fatal if it fails (message delivery unaffected).+\t\t\tgo func(c *whatsmeow.Client) {+\t\t\t\ttime.Sleep(3 * time.Second)+\t\t\t\tlogger.Infof(\"Auto-resync: fetching fresh regular_low app-state snapshot\")+\t\t\t\tif err := c.FetchAppState(context.Background(), \"regular_low\", true, false); err != nil {+\t\t\t\t\tlogger.Debugf(\"regular_low app-state resync: %v (non-fatal)\", err)+\t\t\t\t} else {+\t\t\t\t\tlogger.Infof(\"regular_low app-state resync complete\")+\t\t\t\t}+\t\t\t}(client)+\t\t\t// claude-ops: auto-trigger a deep history backfill on every Connected event."""++CONNECTED_RESYNC_SENTINEL = "claude-ops Fix D: force a full resync of the regular_low"++# ─── whatsapp.py Fix E: WAL-mode _open_db + dict serialisation helpers ────────+# The MCP server returned raw dataclass objects where FastMCP expected dicts,+# causing 30+ pydantic validation errors on every list_chats / list_messages+# call. This patch adds _open_db (WAL mode, read-only) and _*_to_dict helpers,+# then all public functions return dicts/list-of-dicts.+PY_SHAPE_NEEDLE = """@dataclass+class MessageContext:+ message: Message+ before: List[Message]+ after: List[Message]+++def get_sender_name(sender_jid: str) -> str:"""++PY_SHAPE_REPLACEMENT = """@dataclass+class MessageContext:+ message: Message+ before: List[Message]+ after: List[Message]+++# claude-ops Fix E: serialization helpers + WAL-mode DB open.+# All public tool functions return plain dicts so FastMCP can validate them.+def _open_db(path: str, read_only: bool = True):+ \"\"\"Open SQLite in WAL mode: reads see bridge's latest committed state without+ ever blocking or being blocked by the bridge writer (single source of truth).\"\"\"+ import sqlite3 as _sq+ if read_only:+ conn = _sq.connect(f"file:{path}?mode=ro", uri=True, check_same_thread=False)+ else:+ conn = _sq.connect(path, check_same_thread=False)+ try:+ conn.execute("PRAGMA journal_mode=WAL")+ except _sq.Error:+ pass+ return conn+++def _message_to_dict(msg) -> dict:+ ts = msg.timestamp+ return {+ "id": msg.id,+ "chat_jid": msg.chat_jid,+ "chat_name": msg.chat_name,+ "sender": msg.sender,+ "content": msg.content,+ "timestamp": ts.isoformat() if hasattr(ts, "isoformat") else str(ts),+ "is_from_me": bool(msg.is_from_me),+ "media_type": msg.media_type,+ }+++def _chat_to_dict(chat) -> dict:+ lmt = chat.last_message_time+ return {+ "jid": chat.jid,+ "name": chat.name,+ "last_message_time": lmt.isoformat() if hasattr(lmt, "isoformat") else (str(lmt) if lmt else None),+ "last_message": chat.last_message,+ "last_sender": chat.last_sender,+ "last_is_from_me": bool(chat.last_is_from_me) if chat.last_is_from_me is not None else None,+ "is_group": chat.is_group,+ }+++def _contact_to_dict(contact) -> dict:+ return {"phone_number": contact.phone_number, "name": contact.name, "jid": contact.jid}+++def get_sender_name(sender_jid: str) -> str:"""++PY_SHAPE_SENTINEL = "claude-ops Fix E: serialization helpers + WAL-mode DB open"+def replace_idempotent(p: pathlib.Path, needle: str, replacement: str, sentinel: str, label: str@@ -405,6 +632,48 @@ def main() -> int:SAFE_RHS_SENTINEL,"crash-safe requestHistorySync (per-chat anchor)",)+ changed_go |= replace_idempotent(+ main_go,+ APPSTATE_IMPORT_NEEDLE,+ APPSTATE_IMPORT_REPLACEMENT,+ APPSTATE_IMPORT_SENTINEL,+ "Fix D: add go.mau.fi/whatsmeow/appstate import",+ )+ changed_go |= replace_idempotent(+ main_go,+ OUTBOUND_SIG_NEEDLE,+ OUTBOUND_SIG_REPLACEMENT,+ OUTBOUND_SIG_SENTINEL,+ "Fix C: sendWhatsAppMessage signature (+messageStore)",+ )+ changed_go |= replace_idempotent(+ main_go,+ OUTBOUND_CALLSITE_NEEDLE,+ OUTBOUND_CALLSITE_REPLACEMENT,+ OUTBOUND_CALLSITE_SENTINEL,+ "Fix C: /api/send call site passes messageStore",+ )+ changed_go |= replace_idempotent(+ main_go,+ OUTBOUND_PERSIST_NEEDLE,+ OUTBOUND_PERSIST_REPLACEMENT,+ OUTBOUND_PERSIST_SENTINEL,+ "Fix C: persist outbound send as is_from_me=1 row",+ )+ changed_go |= replace_idempotent(+ main_go,+ CONNECTED_RESYNC_NEEDLE,+ CONNECTED_RESYNC_REPLACEMENT,+ CONNECTED_RESYNC_SENTINEL,+ "Fix D: auto-resync regular_low on Connected event",+ )+ changed_go |= replace_idempotent(+ main_go,+ RESYNC_ENDPOINT_NEEDLE,+ RESYNC_ENDPOINT_REPLACEMENT,+ RESYNC_ENDPOINT_SENTINEL,+ "Fix D: POST /api/resync_app_state endpoint",+ )print(" whatsapp.py:")changed_py = replace_idempotent(@@ -414,6 +683,13 @@ def main() -> int:PY_PATH_SENTINEL,"LID resolver + whatsmeow_contacts lookup",)+ changed_py |= replace_idempotent(+ whatsapp_py,+ PY_SHAPE_NEEDLE,+ PY_SHAPE_REPLACEMENT,+ PY_SHAPE_SENTINEL,+ "Fix E: WAL _open_db + dict serialisation helpers",+ )if changed_go:print(" main.go changed — caller should `go build` the bridge")