@wacando/agent 2.2.0 → 2.4.0

package/packages/wacando/chunks/{chunk-53E7SSTF.mjs → chunk-FUNUGIGH.mjs}

@@ -1,10 +1,370 @@
-// Embedded from lbframe/wacando@618922ecaf2213da18949a8b27d343c8767b64c5 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
+// Embedded from lbframe/wacando@40dd0c30b3653095f08994f9534fd5110e1d0925 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
 import {
   XMPP_DOMAIN
-} from "./chunk-PZDQXGA6.mjs";
+} from "./chunk-FFLYSYV6.mjs";
 
-// packages/xmpp/src/muc.ts
+// packages/xmpp/src/scram.ts
+import { client } from "@xmpp/client";
 import xml from "@xmpp/xml";
+var SASL1_NS = "urn:ietf:params:xml:ns:xmpp-sasl";
+var SASL2_NS = "urn:xmpp:sasl:2";
+var SCRAM_MIN_ITERATIONS = 4096;
+var SCRAM_MAX_ITERATIONS = 1e5;
+var HASH_BYTES = { "SHA-1": 20, "SHA-256": 32 };
+var REASON_TEXT = {
+  "missing-server-signature": "server sent no ServerSignature (v=)",
+  "server-signature-mismatch": "server ServerSignature (v=) does not match",
+  "malformed-server-message": "malformed SCRAM server message",
+  "server-error": "server reported a SCRAM error (e=)",
+  "nonce-mismatch": "server nonce does not extend the client nonce",
+  "weak-iteration-count": `server iteration count below ${SCRAM_MIN_ITERATIONS}`,
+  "excessive-iteration-count": `server iteration count above ${SCRAM_MAX_ITERATIONS}`,
+  "sasl2-refused": "server offers SASL2, which this client refuses (SASL1 SCRAM only)",
+  "no-scram-mechanism": "server offers no supported SCRAM mechanism",
+  "out-of-order": "SCRAM message out of order"
+};
+var ScramAuthError = class extends Error {
+  reason;
+  mechanism;
+  constructor(reason, mechanism) {
+    super(
+      `SCRAM authentication refused${mechanism ? ` (${mechanism})` : ""}: ${REASON_TEXT[reason]}`
+    );
+    this.name = "ScramAuthError";
+    this.reason = reason;
+    this.mechanism = mechanism;
+  }
+};
+var encoder = new TextEncoder();
+function utf8(text) {
+  return new Uint8Array(encoder.encode(text));
+}
+function bytesToBinary(bytes) {
+  let out = "";
+  for (const b of bytes) out += String.fromCharCode(b);
+  return out;
+}
+function binaryToBytes(binary) {
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i) & 255;
+  return out;
+}
+function base64Encode(bytes) {
+  return globalThis.btoa(bytesToBinary(bytes));
+}
+function base64Decode(text) {
+  if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(text)) {
+    return void 0;
+  }
+  try {
+    return binaryToBytes(globalThis.atob(text));
+  } catch {
+    return void 0;
+  }
+}
+function constantTimeEqual(a, b) {
+  let diff = a.length ^ b.length;
+  const n = Math.max(a.length, b.length);
+  for (let i = 0; i < n; i++) diff |= (a[i] ?? 0) ^ (b[i] ?? 0);
+  return diff === 0;
+}
+function xor(a, b) {
+  const out = new Uint8Array(a.length);
+  for (let i = 0; i < a.length; i++) out[i] = (a[i] ?? 0) ^ (b[i] ?? 0);
+  return out;
+}
+async function hmac(hash, key, data) {
+  const k = await globalThis.crypto.subtle.importKey("raw", key, { name: "HMAC", hash }, false, [
+    "sign"
+  ]);
+  return new Uint8Array(await globalThis.crypto.subtle.sign("HMAC", k, data));
+}
+async function digest(hash, data) {
+  return new Uint8Array(await globalThis.crypto.subtle.digest(hash, data));
+}
+async function hi(hash, password, salt, iterations) {
+  const key = await globalThis.crypto.subtle.importKey("raw", utf8(password), "PBKDF2", false, [
+    "deriveBits"
+  ]);
+  return new Uint8Array(
+    await globalThis.crypto.subtle.deriveBits(
+      { name: "PBKDF2", hash, salt, iterations },
+      key,
+      HASH_BYTES[hash] * 8
+    )
+  );
+}
+function parseAttributes(message) {
+  const attrs = /* @__PURE__ */ new Map();
+  for (const part of message.split(",")) {
+    const m = /^([A-Za-z])=(.*)$/s.exec(part);
+    if (!m) return void 0;
+    const [, key, value] = m;
+    if (attrs.has(key)) return void 0;
+    attrs.set(key, value);
+  }
+  return attrs;
+}
+function saslname(name) {
+  return name.replace(/=/g, "=3D").replace(/,/g, "=2C");
+}
+async function scramProofs(hash, password, salt, iterations, authMessage) {
+  const salted = await hi(hash, password, salt, iterations);
+  const clientKey = await hmac(hash, salted, utf8("Client Key"));
+  const storedKey = await digest(hash, clientKey);
+  const am = utf8(authMessage);
+  const clientSignature = await hmac(hash, storedKey, am);
+  const serverKey = await hmac(hash, salted, utf8("Server Key"));
+  return {
+    clientProof: xor(clientKey, clientSignature),
+    serverSignature: await hmac(hash, serverKey, am)
+  };
+}
+function verifyServerFinal(serverFinal, expected, mechanism) {
+  if (serverFinal === void 0 || serverFinal === "") {
+    throw new ScramAuthError("missing-server-signature", mechanism);
+  }
+  const attrs = parseAttributes(serverFinal);
+  if (!attrs) throw new ScramAuthError("malformed-server-message", mechanism);
+  if (attrs.has("e")) throw new ScramAuthError("server-error", mechanism);
+  const v = attrs.get("v");
+  if (v === void 0) throw new ScramAuthError("missing-server-signature", mechanism);
+  const received = base64Decode(v);
+  if (!received) throw new ScramAuthError("malformed-server-message", mechanism);
+  if (!constantTimeEqual(received, expected)) {
+    throw new ScramAuthError("server-signature-mismatch", mechanism);
+  }
+}
+var ScramMechanism = class {
+  constructor(hash, genNonce = defaultNonce) {
+    this.hash = hash;
+    this.genNonce = genNonce;
+    this.name = hash === "SHA-1" ? "SCRAM-SHA-1" : "SCRAM-SHA-256";
+  }
+  hash;
+  genNonce;
+  name;
+  clientFirst = true;
+  stage = "initial";
+  clientNonce = "";
+  clientFirstBare = "";
+  serverFirst = "";
+  expectedServerSignature;
+  pendingServerFinal;
+  verifiedFlag = false;
+  /** True once the server's ServerSignature has been verified. */
+  get verified() {
+    return this.verifiedFlag;
+  }
+  /** True once the client-final-message was sent (a `v=` is now due). */
+  get awaitingServerFinal() {
+    return this.stage === "final";
+  }
+  async response(cred) {
+    switch (this.stage) {
+      case "initial":
+        return this.clientFirstMessage(cred);
+      case "challenge":
+        return this.clientFinalMessage(cred);
+      case "final":
+        await this.final(this.pendingServerFinal);
+        return "";
+      default:
+        throw new ScramAuthError("out-of-order", this.name);
+    }
+  }
+  challenge(chal) {
+    if (this.stage === "challenge") {
+      this.serverFirst = utf8Decode(chal);
+      return;
+    }
+    if (this.stage === "final") {
+      this.pendingServerFinal = chal;
+      return;
+    }
+    throw new ScramAuthError("out-of-order", this.name);
+  }
+  /**
+   * server-final-message (binary string, as decoded from base64) from
+   * <success/> (SASL1), <additional-data/> (SASL2) or a last <challenge/>.
+   */
+  async final(data) {
+    if (this.verifiedFlag) return;
+    if (this.stage !== "final" || !this.expectedServerSignature) {
+      throw new ScramAuthError("out-of-order", this.name);
+    }
+    this.stage = "done";
+    const expected = this.expectedServerSignature;
+    this.expectedServerSignature = void 0;
+    verifyServerFinal(data === void 0 ? void 0 : utf8Decode(data), expected, this.name);
+    this.verifiedFlag = true;
+  }
+  clientFirstMessage(cred) {
+    this.clientNonce = this.genNonce();
+    this.clientFirstBare = `n=${saslname(cred.username ?? "")},r=${this.clientNonce}`;
+    this.stage = "challenge";
+    return utf8Binary(`n,,${this.clientFirstBare}`);
+  }
+  async clientFinalMessage(cred) {
+    const attrs = parseAttributes(this.serverFirst);
+    const nonce = attrs?.get("r");
+    const saltText = attrs?.get("s");
+    const iterText = attrs?.get("i");
+    if (attrs?.has("e")) throw new ScramAuthError("server-error", this.name);
+    if (!attrs || attrs.has("m") || !nonce || !saltText || !iterText) {
+      throw new ScramAuthError("malformed-server-message", this.name);
+    }
+    if (!nonce.startsWith(this.clientNonce) || nonce.length <= this.clientNonce.length) {
+      throw new ScramAuthError("nonce-mismatch", this.name);
+    }
+    const salt = base64Decode(saltText);
+    if (!salt || salt.length === 0 || !/^[1-9][0-9]{0,9}$/.test(iterText)) {
+      throw new ScramAuthError("malformed-server-message", this.name);
+    }
+    const iterations = Number(iterText);
+    if (iterations < SCRAM_MIN_ITERATIONS) {
+      throw new ScramAuthError("weak-iteration-count", this.name);
+    }
+    if (iterations > SCRAM_MAX_ITERATIONS) {
+      throw new ScramAuthError("excessive-iteration-count", this.name);
+    }
+    const withoutProof = `c=biws,r=${nonce}`;
+    const authMessage = `${this.clientFirstBare},${this.serverFirst},${withoutProof}`;
+    const { clientProof, serverSignature } = await scramProofs(
+      this.hash,
+      cred.password ?? "",
+      salt,
+      iterations,
+      authMessage
+    );
+    this.expectedServerSignature = serverSignature;
+    this.stage = "final";
+    return utf8Binary(`${withoutProof},p=${base64Encode(clientProof)}`);
+  }
+};
+function utf8Binary(text) {
+  return bytesToBinary(utf8(text));
+}
+function utf8Decode(binary) {
+  return new TextDecoder().decode(binaryToBytes(binary));
+}
+function defaultNonce() {
+  const bytes = new Uint8Array(24);
+  globalThis.crypto.getRandomValues(bytes);
+  return base64Encode(bytes);
+}
+var SCRAM_HASHES = ["SHA-256", "SHA-1"];
+var SCRAM_NAMES = SCRAM_HASHES.map(
+  (h) => h === "SHA-1" ? "SCRAM-SHA-1" : "SCRAM-SHA-256"
+);
+var NS_STREAM = "http://etherx.jabber.org/streams";
+function saslFeaturesRefusal(features) {
+  if (features.getChild("authentication", SASL2_NS)) return "sasl2-refused";
+  const sasl1 = features.getChild("mechanisms", SASL1_NS);
+  if (!sasl1) return void 0;
+  const offered = sasl1.getChildren("mechanism").map((m) => m.text().trim());
+  return SCRAM_NAMES.some((name) => offered.includes(name)) ? void 0 : "no-scram-mechanism";
+}
+var states = /* @__PURE__ */ new WeakMap();
+function scramClient(options) {
+  const { username, password, ...rest } = options;
+  let current;
+  let rejectFailure = () => {
+  };
+  const state = {
+    failure: new Promise((_, reject) => {
+      rejectFailure = reject;
+    })
+  };
+  state.failure.catch(() => {
+  });
+  const userAgent = xml("user-agent", { id: globalThis.crypto.randomUUID() });
+  const cut = (entity, err) => {
+    state.cutting ??= (async () => {
+      entity.reconnect?.stop();
+      await entity.stop().catch(() => {
+      });
+      rejectFailure(err);
+    })();
+    return state.cutting;
+  };
+  let refused;
+  const xmpp = client({
+    ...rest,
+    credentials: async (authenticate, mechanisms, _fast, entity) => {
+      const failClosed = async (err) => {
+        await cut(entity, err);
+        throw err;
+      };
+      if (refused) return failClosed(refused);
+      const mechanism = SCRAM_NAMES.find((name) => mechanisms.includes(name));
+      if (!mechanism) return failClosed(new ScramAuthError("no-scram-mechanism"));
+      let successData;
+      const onNonza = (el) => {
+        if (el.is("success", SASL1_NS)) successData = decodeSuccess(el.text());
+      };
+      entity.on("nonza", onNonza);
+      current = void 0;
+      try {
+        await authenticate({ username, password }, mechanism, userAgent);
+        const mech = current;
+        if (!mech) throw new ScramAuthError("out-of-order", mechanism);
+        if (!mech.verified) await mech.final(successData);
+      } catch (err) {
+        if (err instanceof ScramAuthError) return failClosed(err);
+        throw err;
+      } finally {
+        entity.removeListener("nonza", onNonza);
+        current = void 0;
+      }
+    }
+  });
+  const factory = xmpp.saslFactory;
+  const bound = SCRAM_HASHES.map((hash) => ({
+    name: hash === "SHA-1" ? "SCRAM-SHA-1" : "SCRAM-SHA-256",
+    mech: class extends ScramMechanism {
+      constructor() {
+        super(hash);
+        current = this;
+      }
+    }
+  }));
+  factory._mechs.splice(0, factory._mechs.length, ...bound);
+  xmpp.on("nonza", (el) => {
+    if (!el.is("features", NS_STREAM)) return;
+    const reason = saslFeaturesRefusal(el);
+    if (!reason) return;
+    refused = new ScramAuthError(reason);
+    void cut(xmpp, refused);
+  });
+  states.set(xmpp, state);
+  return xmpp;
+}
+function decodeSuccess(text) {
+  const trimmed = text.trim();
+  if (trimmed === "" || trimmed === "=") return void 0;
+  try {
+    return globalThis.atob(trimmed);
+  } catch {
+    return void 0;
+  }
+}
+async function startScramClient(xmpp) {
+  const state = states.get(xmpp);
+  if (!state) return xmpp.start();
+  try {
+    return await Promise.race([xmpp.start(), state.failure]);
+  } catch (err) {
+    if (state.cutting) {
+      await state.cutting;
+      return state.failure;
+    }
+    throw err;
+  }
+}
+
+// packages/xmpp/src/muc.ts
+import xml2 from "@xmpp/xml";
 
 // packages/xmpp/src/jid.ts
 var COMPONENT_JID = `policy.${XMPP_DOMAIN}`;
@@ -113,7 +473,7 @@ var MucJoinError = class extends MucError {
   nick;
 };
 function joinPresenceEl(room, nick) {
-  return xml("presence", { to: occupantJid(room, nick) }, xml("x", { xmlns: NS_MUC }));
+  return xml2("presence", { to: occupantJid(room, nick) }, xml2("x", { xmlns: NS_MUC }));
 }
 async function joinRoom(entity, room, nick, timeoutMs = defaultTimeoutMs()) {
   const self = occupantJid(room, nick);
@@ -266,24 +626,24 @@ var MucOriginTracker = class {
 };
 
 // packages/xmpp/src/mam.ts
-import xml2 from "@xmpp/xml";
+import xml3 from "@xmpp/xml";
 var NS_MAM = "urn:xmpp:mam:2";
 var NS_FORWARD2 = "urn:xmpp:forward:0";
 var NS_RSM = "http://jabber.org/protocol/rsm";
 var queryCounter = 0;
 function filterField(varName, value) {
-  return xml2("field", { var: varName }, xml2("value", {}, value));
+  return xml3("field", { var: varName }, xml3("value", {}, value));
 }
 function mamQueryEl(options) {
-  const fields = [xml2("field", { var: "FORM_TYPE", type: "hidden" }, xml2("value", {}, NS_MAM))];
+  const fields = [xml3("field", { var: "FORM_TYPE", type: "hidden" }, xml3("value", {}, NS_MAM))];
   if (options.withJid !== void 0) fields.push(filterField("with", options.withJid));
   if (options.start !== void 0) fields.push(filterField("start", options.start));
   if (options.end !== void 0) fields.push(filterField("end", options.end));
-  const children = [xml2("x", { xmlns: NS_DATA_FORMS, type: "submit" }, ...fields)];
+  const children = [xml3("x", { xmlns: NS_DATA_FORMS, type: "submit" }, ...fields)];
   if (options.max !== void 0) {
-    children.push(xml2("set", { xmlns: NS_RSM }, xml2("max", {}, String(options.max))));
+    children.push(xml3("set", { xmlns: NS_RSM }, xml3("max", {}, String(options.max))));
   }
-  return xml2("query", { xmlns: NS_MAM, queryid: options.queryId }, ...children);
+  return xml3("query", { xmlns: NS_MAM, queryid: options.queryId }, ...children);
 }
 async function queryMam(entity, options, timeoutMs = defaultTimeoutMs()) {
   const queryId = options.queryId ?? `mam${++queryCounter}`;
@@ -326,7 +686,7 @@ function forwardedStanza(forwarded) {
 
 // packages/xmpp/src/roster.ts
 import { jid as parseJid } from "@xmpp/jid";
-import xml3 from "@xmpp/xml";
+import xml4 from "@xmpp/xml";
 function subscriptionRefusal(stanza) {
   if (!stanza.is("presence") || stanza.getAttr("type") !== "subscribe") return null;
   const from = stanza.getAttr("from");
@@ -337,7 +697,7 @@ function subscriptionRefusal(stanza) {
   } catch {
     return null;
   }
-  return xml3("presence", { to: bare, type: "unsubscribed" });
+  return xml4("presence", { to: bare, type: "unsubscribed" });
 }
 function refuseSubscriptionRequests(entity) {
   const onStanza = (stanza) => {
@@ -356,26 +716,26 @@ var UNKNOWN_PRESENCE = Object.freeze({
 });
 
 // packages/xmpp/src/pubsub.ts
-import xml4 from "@xmpp/xml";
+import xml5 from "@xmpp/xml";
 var NS_PUBSUB = "http://jabber.org/protocol/pubsub";
 var NS_PUBSUB_PUBLISH_OPTIONS = "http://jabber.org/protocol/pubsub#publish-options";
 function pepPublishEl(node, itemId, payload, accessModel = "open") {
-  return xml4(
+  return xml5(
     "pubsub",
     { xmlns: NS_PUBSUB },
-    xml4("publish", { node }, xml4("item", { id: itemId }, payload)),
-    xml4(
+    xml5("publish", { node }, xml5("item", { id: itemId }, payload)),
+    xml5(
       "publish-options",
       {},
-      xml4(
+      xml5(
         "x",
         { xmlns: NS_DATA_FORMS, type: "submit" },
-        xml4(
+        xml5(
           "field",
           { var: "FORM_TYPE", type: "hidden" },
-          xml4("value", {}, NS_PUBSUB_PUBLISH_OPTIONS)
+          xml5("value", {}, NS_PUBSUB_PUBLISH_OPTIONS)
         ),
-        xml4("field", { var: "pubsub#access_model" }, xml4("value", {}, accessModel))
+        xml5("field", { var: "pubsub#access_model" }, xml5("value", {}, accessModel))
       )
     )
   );
@@ -383,7 +743,7 @@ function pepPublishEl(node, itemId, payload, accessModel = "open") {
 function pubsubItemsEl(node, maxItems) {
   const attrs = { node };
   if (maxItems !== void 0) attrs.max_items = String(maxItems);
-  return xml4("pubsub", { xmlns: NS_PUBSUB }, xml4("items", attrs));
+  return xml5("pubsub", { xmlns: NS_PUBSUB }, xml5("items", attrs));
 }
 async function pepPublish(entity, to, node, itemId, payload, timeoutMs = defaultTimeoutMs()) {
   await entity.iqCaller.set(pepPublishEl(node, itemId, payload), to, timeoutMs);
@@ -408,6 +768,9 @@ function isItemNotFound(err) {
 }
 
 export {
+  ScramAuthError,
+  scramClient,
+  startScramClient,
   defaultTimeoutMs,
   waitForStanza,
   MucJoinError,

package/packages/wacando/omemo-wire.mjs

@@ -1,4 +1,4 @@
-// Embedded from lbframe/wacando@618922ecaf2213da18949a8b27d343c8767b64c5 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
+// Embedded from lbframe/wacando@40dd0c30b3653095f08994f9534fd5110e1d0925 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
 import {
   BODY_MARKER,
   GCM_IV_BYTES,
@@ -29,8 +29,8 @@ import {
   signerJid,
   signerRole,
   targetJid
-} from "./chunks/chunk-PHGOH4AU.mjs";
-import "./chunks/chunk-PZDQXGA6.mjs";
+} from "./chunks/chunk-F7J3K43U.mjs";
+import "./chunks/chunk-FFLYSYV6.mjs";
 
 // packages/omemo/src/policy-wire.ts
 import xml from "@xmpp/xml";

package/packages/wacando/omemo.mjs

@@ -1,9 +1,9 @@
-// Embedded from lbframe/wacando@618922ecaf2213da18949a8b27d343c8767b64c5 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
+// Embedded from lbframe/wacando@40dd0c30b3653095f08994f9534fd5110e1d0925 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
 import {
   authenticatedMessageOrigin,
   pepFetchItems,
   pepPublish
-} from "./chunks/chunk-53E7SSTF.mjs";
+} from "./chunks/chunk-FUNUGIGH.mjs";
 import {
   BODY_MARKER,
   GCM_IV_BYTES,
@@ -37,13 +37,13 @@ import {
   signerJid,
   signerRole,
   utf8Encode
-} from "./chunks/chunk-PHGOH4AU.mjs";
+} from "./chunks/chunk-F7J3K43U.mjs";
 import {
   ALLOWED_MEDIA_TYPES,
   MAX_FILE_BYTES,
   MIN_FILE_BYTES,
   looksLikePlaintext
-} from "./chunks/chunk-PZDQXGA6.mjs";
+} from "./chunks/chunk-FFLYSYV6.mjs";
 
 // packages/omemo/src/libsignal.ts
 import { jid as parseJid2 } from "@xmpp/jid";
@@ -585,8 +585,8 @@ var OmemoProvider = class {
   /**
    * Resolve OMEMO device targets for a member set via PEP — fail closed:
    * missing devicelist or missing bundle throws OmemoError before any
-   * plaintext is touched. Bundle elements are kept raw: each session
-   * backend parses the flavor it accepts (kyber → PQXDH, else classic).
+   * plaintext is touched. Bundle elements are kept raw: the session
+   * backend parses them and refuses any non-PQXDH (classic) bundle.
    */
   async resolveDeviceTargets(entity, memberBareJids, timeoutMs = 1e4) {
     const recipients = [.../* @__PURE__ */ new Set([...memberBareJids, this.bareJid])];
@@ -1175,6 +1175,7 @@ var NAME_INVISIBLE = new RegExp(
   "g"
 );
 var NAME_RESERVED = /[<>:"|?*]/g;
+var NAME_DOT_LOOKALIKE = /[\uff0e\ufe52\u2024]/g;
 var WINDOWS_DEVICE = /^(con|prn|aux|nul|conin\$|conout\$|clock\$|com[0-9\u00b9\u00b2\u00b3]|lpt[0-9\u00b9\u00b2\u00b3])\s*(\..*)?$/i;
 function utf8Length(s) {
   return new TextEncoder().encode(s).length;
@@ -1188,7 +1189,7 @@ function cutUtf8(s, max) {
   return out;
 }
 function sanitizeFileName(raw) {
-  let name = raw.normalize("NFC").replace(NAME_INVISIBLE, "");
+  let name = raw.normalize("NFC").replace(NAME_INVISIBLE, "").replace(NAME_DOT_LOOKALIKE, ".");
   name = name.split(/[/\\]/).pop() ?? "";
   name = name.replace(NAME_RESERVED, "_").trim();
   name = name.replace(/^[.\s]+/, "").replace(/[.\s]+$/, "");
@@ -1540,7 +1541,10 @@ function fileIdOfShare(share) {
 }
 async function downloadFile(share, opts) {
   const { fetchUrl } = parseAesgcmUrl(share.url, opts.pin);
-  const limit = share.ciphertextSize;
+  const expected = share.ciphertextSize;
+  if (!Number.isSafeInteger(expected) || expected < FILE_TAG_BYTES)
+    throw new FileCryptoError("invalid_descriptor", "file share: ciphertext size");
+  const limit = Math.min(expected, MAX_FILE_CIPHERTEXT_BYTES);
   const doFetch = opts.fetch ?? globalThis.fetch;
   const signal = AbortSignal.timeout(opts.timeoutMs ?? FILE_DOWNLOAD_TIMEOUT_MS);
   const failed = (what) => new FileCryptoError("download_failed", `download ${what}`);
@@ -1593,6 +1597,7 @@ async function downloadFile(share, opts) {
     if (e instanceof FileCryptoError) throw e;
     throw failed(signal.aborted ? "timed out" : "interrupted");
   }
+  if (total !== expected) throw failed("truncated");
   const out = new Uint8Array(total);
   let at = 0;
   for (const c of chunks) {

package/packages/wacando/xmpp.mjs

@@ -1,17 +1,20 @@
-// Embedded from lbframe/wacando@618922ecaf2213da18949a8b27d343c8767b64c5 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
+// Embedded from lbframe/wacando@40dd0c30b3653095f08994f9534fd5110e1d0925 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
 import {
   MucJoinError,
   MucOriginTracker,
+  ScramAuthError,
   authenticatedMessageOrigin,
   defaultTimeoutMs,
   forwardedStanza,
   joinRoom,
   queryMam,
   refuseSubscriptionRequests,
+  scramClient,
+  startScramClient,
   unwrapPolicyDelivery,
   waitForStanza
-} from "./chunks/chunk-53E7SSTF.mjs";
-import "./chunks/chunk-PZDQXGA6.mjs";
+} from "./chunks/chunk-FUNUGIGH.mjs";
+import "./chunks/chunk-FFLYSYV6.mjs";
 
 // packages/xmpp/src/index.ts
 import { default as default2 } from "@xmpp/xml";
@@ -73,6 +76,7 @@ async function requestUploadSlot(entity, service, req, timeoutMs = defaultTimeou
 export {
   MucJoinError,
   MucOriginTracker,
+  ScramAuthError,
   announceAvailable,
   authenticatedMessageOrigin,
   forwardedStanza,
@@ -80,6 +84,8 @@ export {
   queryMam,
   refuseSubscriptionRequests,
   requestUploadSlot,
+  scramClient,
+  startScramClient,
   unwrapPolicyDelivery,
   uploadServiceJid,
   default2 as xml

package/plugins/wacando/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wacando",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "Connect agents with Wacando onboarding and view conversations in the built-in Codex browser.",
   "author": { "name": "Wacando" },
   "skills": "./skills/",

package/plugins/wacando-claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "wacando-claude",
   "displayName": "Wacando",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "Connect agents with Wacando onboarding and view live Claude Code conversations locally.",
   "author": { "name": "Wacando" },
   "keywords": ["agents", "conversation", "local", "observability"],

package/plugins/wacando-cursor/.cursor-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "wacando-cursor",
   "displayName": "Wacando",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "Connect agents with Wacando onboarding and view conversations in the built-in Cursor browser.",
   "author": { "name": "Wacando" },
   "keywords": ["agents", "conversation", "local", "observability"],