@rubytech/create-maxy-code 0.1.406 → 0.1.408

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/create-maxy-code",
-  "version": "0.1.406",
+  "version": "0.1.408",
   "description": "Install Maxy — AI for Productive People",
   "bin": {
     "create-maxy-code": "./dist/index.js"

package/payload/platform/plugins/whatsapp/references/channels-whatsapp.md

@@ -115,6 +115,8 @@ The platform enforces this at multiple levels:
 
 **The scheduler path fails closed too.** A scheduled dispatch (`POST /api/channel/schedule-inject`) reaches the same spawn machine without going through the gate, resolving its own effective account via `effectiveAccountFor`. That resolver carries the same single-source + fail-closed shape: a non-manager destination scopes to the house (an owner/admin's real scope), a valid manager scopes to the bound sub-account, and a manager whose bound sub-account is not a valid account resolves to nothing — the route **rejects** (`op=schedule-account-manager-reject … reason=unresolved-effective-account`, HTTP 403, no spawn, no reply), never routing to the house. There is no `?? accountId` fallback on this path either. Telegram scheduled dispatch is house-only by construction (no account-manager routing), so there is nothing to fail closed there.
 
+**Socket-key resolution — the reply transport.** The account id that names a *spawn scope* (a platform account UUID) is a different identifier from the key the *socket* is stored under (the credential dirname — `"default"` on a legacy single-account install that was never re-keyed to the UUID). These coincide when the credential dir is named for the UUID and diverge otherwise. The inbound reply path never trips on this: it closes over the live connection object directly. A scheduled dispatch has no live connection to close over, so it resolves the socket by asking the manager — `resolveSocket(accountId)` accepts **either** the platform UUID or the connection map key and returns the one connection that owns the socket (the manager holds the `accountId ↔ platformAccountId` bijection). This is the single resolver both the reply path and the scheduler go through, so the id `getSocket` is called with is always a key the connection map actually holds. A null resolution is **two distinct faults, never conflated**: `op=socket-key-miss accountId=… presentKeys=…` means no connection is registered under that id — an account-keying mismatch, the socket may be alive under a different key, and re-pairing is the wrong advice; a *disconnected* result means the connection exists but its transport is down. Reporting a key miss as "WhatsApp disconnected" is the bug that once told an operator to re-sign-in a connected line.
+
 **`dmPolicy` behaviour (per-account):**
 
 | Policy | Self phone | Admin phones (in `adminPhones`) | Public/unknown |

package/payload/server/server.js

@@ -4248,6 +4248,16 @@ function getStatus() {
 function getSocket(accountId) {
   return connections.get(accountId)?.sock ?? null;
 }
+function selectConnection(conns, accountId) {
+  const presentKeys = conns.map((c) => c.accountId);
+  const conn = conns.find((c) => c.accountId === accountId) ?? conns.find((c) => c.platformAccountId === accountId);
+  if (!conn) return { ok: false, reason: "key-miss", presentKeys };
+  if (!conn.sock) return { ok: false, reason: "disconnected", presentKeys };
+  return { ok: true, sock: conn.sock, accountId: conn.accountId };
+}
+function resolveSocket(accountId) {
+  return selectConnection(Array.from(connections.values()), accountId);
+}
 async function registerLoginSocket(accountId, sock, authDir) {
   if (!configDir) throw new Error("WhatsApp manager not initialized");
   let platformAccountId;
@@ -7442,11 +7452,15 @@ app2.post("/send-admin", async (c) => {
       );
     }
     const accountId = validateAccountId(body.accountId);
-    const sock = getSocket(accountId);
-    if (!sock) {
-      return c.json({ error: `WhatsApp account "${accountId}" is not connected.` }, 503);
+    const res = resolveSocket(accountId);
+    if (!res.ok) {
+      if (res.reason === "key-miss") {
+        console.error(`[whatsapp:outbound] op=socket-key-miss accountId=${accountId} presentKeys=${res.presentKeys.join(",") || "none"}`);
+        return c.json({ error: `No WhatsApp socket is registered for account "${accountId}" (present: ${res.presentKeys.join(", ") || "none"}). This is an account-keying mismatch, not a dropped connection.` }, 503);
+      }
+      return c.json({ error: `WhatsApp account "${accountId}" is registered but its socket is disconnected.` }, 503);
     }
-    const result = await sendTextMessage(sock, normalizeE164(phone), text, { accountId });
+    const result = await sendTextMessage(res.sock, normalizeE164(phone), text, { accountId: res.accountId });
     if (!result.success) {
       return c.json({ error: result.error ?? "send failed" }, 500);
     }
@@ -23588,9 +23602,15 @@ var scheduleInjectRoutes = createScheduleInjectRoutes({
   waHandleInbound: (input) => waGateway.handleInbound(input),
   tgHandleInbound: (input) => telegramGateway.handleInbound(input),
   sendWhatsAppText: async (accountId, destination, text) => {
-    const sock = getSocket(accountId);
-    if (!sock) throw new Error("WhatsApp disconnected \u2014 cannot deliver scheduled reply");
-    await sendTextMessage(sock, toWhatsappJid(destination), text, { accountId });
+    const res = resolveSocket(accountId);
+    if (!res.ok) {
+      if (res.reason === "key-miss") {
+        console.error(`[whatsapp-native] op=socket-key-miss accountId=${accountId} presentKeys=${res.presentKeys.join(",") || "none"}`);
+        throw new Error(`WhatsApp socket key miss: no socket is registered for accountId=${accountId} (present keys: ${res.presentKeys.join(",") || "none"}). This is an account-keying fault, not a dropped link \u2014 do not advise re-pairing.`);
+      }
+      throw new Error(`WhatsApp disconnected: the socket for accountId=${accountId} is registered but its transport is down; cannot deliver scheduled reply.`);
+    }
+    await sendTextMessage(res.sock, toWhatsappJid(destination), text, { accountId: res.accountId });
   },
   sendTelegramText: async (botToken, chatId, text) => {
     const sent = await sendTelegramText(botToken, chatId, text);