@zoralabs/cli 1.3.0 → 1.4.1

package/dist/chunk-WF24B44I.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+// src/messaging/native-binding.ts
+var REQUIRED_GLIBC = "2.38";
+var errorChainText = (err) => {
+  const parts = [];
+  const seen = /* @__PURE__ */ new Set();
+  let cur = err;
+  while (cur && !seen.has(cur)) {
+    seen.add(cur);
+    if (cur instanceof Error) {
+      parts.push(cur.message);
+      const code = cur.code;
+      if (code) parts.push(code);
+      cur = cur.cause;
+    } else {
+      parts.push(String(cur));
+      break;
+    }
+  }
+  return parts.join("\n");
+};
+var isNativeBindingError = (err) => {
+  const text = errorChainText(err);
+  return /ERR_DLOPEN_FAILED/.test(text) || /\bdlopen\b/i.test(text) || /GLIBC_[\d.]+'? not found/i.test(text) || /cannot open shared object/i.test(text) || /cannot find native binding/i.test(text) || /@xmtp\/node-bindings/i.test(text);
+};
+var detectGlibc = () => {
+  try {
+    const raw = process.report?.getReport?.();
+    const report = typeof raw === "string" ? JSON.parse(raw) : raw;
+    return report?.header?.glibcVersionRuntime || void 0;
+  } catch {
+    return void 0;
+  }
+};
+var nativeBindingErrorHelp = () => {
+  const glibc = detectGlibc();
+  const where = glibc ? ` (glibc ${glibc})` : "";
+  return [
+    `The XMTP messaging library's native module couldn't load on this system${where}.`,
+    "",
+    "DMs need a platform-native binary. Any of these fixes it:",
+    "  \u2022 run on an Alpine / musl image \u2014 e.g. node:20-alpine (works on any Node version)",
+    "  \u2022 use Node 22+ and reinstall the CLI \u2014 `npm install -g @zoralabs/cli`",
+    `  \u2022 or use a glibc >= ${REQUIRED_GLIBC} image \u2014 Ubuntu 24.04+ or Debian 13`
+  ].join("\n");
+};
+
+export {
+  REQUIRED_GLIBC,
+  isNativeBindingError,
+  detectGlibc,
+  nativeBindingErrorHelp
+};

package/dist/{client-4HW4ZUHD.js → client-QV2PLHGY.js}

@@ -1,33 +1,44 @@
 #!/usr/bin/env node
+import {
+  REQUIRED_GLIBC,
+  detectGlibc
+} from "./chunk-WF24B44I.js";
 
 // src/messaging/client.ts
 import { homedir, platform } from "os";
 import { join } from "path";
 import { mkdirSync } from "fs";
-import {
-  Client,
-  ConsentState,
-  IdentifierKind,
-  LogLevel,
-  isText
-} from "@xmtp/node-sdk";
 import { ReactionCodec } from "@xmtp/content-type-reaction";
 import { ReadReceiptCodec } from "@xmtp/content-type-read-receipt";
 import { getAddress } from "viem";
-var CONSENT_TO_SDK = {
-  allowed: ConsentState.Allowed,
-  unknown: ConsentState.Unknown,
-  denied: ConsentState.Denied
+
+// src/messaging/load-xmtp-sdk.ts
+var parseVer = (v) => {
+  const [major = 0, minor = 0] = v.split(".").map((n) => parseInt(n, 10) || 0);
+  return [major, minor];
 };
-var consentFromSdk = (state) => {
-  if (state === ConsentState.Allowed) return "allowed";
-  if (state === ConsentState.Denied) return "denied";
-  return "unknown";
+var glibcOlderThan = (a, b) => {
+  const [aMaj, aMin] = parseVer(a);
+  const [bMaj, bMin] = parseVer(b);
+  return aMaj !== bMaj ? aMaj < bMaj : aMin < bMin;
+};
+var shouldUseLowGlibcSdk = () => {
+  if (process.platform !== "linux") return false;
+  const glibc = detectGlibc();
+  if (!glibc) return false;
+  return glibcOlderThan(glibc, REQUIRED_GLIBC);
+};
+var loadXmtpSdk = async () => {
+  if (shouldUseLowGlibcSdk()) {
+    try {
+      return await import("@xmtp/node-sdk-lowglibc");
+    } catch {
+    }
+  }
+  return import("@xmtp/node-sdk");
 };
-var toIdentifier = (address) => ({
-  identifier: address.toLowerCase(),
-  identifierKind: IdentifierKind.Ethereum
-});
+
+// src/messaging/client.ts
 var formatContentType = (ct) => `${ct.authorityId}/${ct.typeId}:${ct.versionMajor}.${ct.versionMinor}`;
 var asAddress = (value) => {
   if (!value) return null;
@@ -46,19 +57,34 @@ var defaultDbPath = (env, inboxId) => {
   mkdirSync(dir, { recursive: true });
   return join(dir, `xmtp-${env}-${inboxId}.db3`);
 };
-var buildXmtpSigner = (spec) => {
-  const getIdentifier = () => toIdentifier(spec.address);
-  if (spec.type === "EOA") {
-    return { type: "EOA", getIdentifier, signMessage: spec.signMessage };
-  }
-  return {
-    type: "SCW",
-    getIdentifier,
-    getChainId: () => BigInt(spec.chainId),
-    signMessage: spec.signMessage
-  };
-};
 var createMessagingClient = async (spec, options = {}) => {
+  const { Client, ConsentState, IdentifierKind, LogLevel, isText } = await loadXmtpSdk();
+  const consentToSdk = {
+    allowed: ConsentState.Allowed,
+    unknown: ConsentState.Unknown,
+    denied: ConsentState.Denied
+  };
+  const consentFromSdk = (state) => {
+    if (state === ConsentState.Allowed) return "allowed";
+    if (state === ConsentState.Denied) return "denied";
+    return "unknown";
+  };
+  const toIdentifier = (address2) => ({
+    identifier: address2.toLowerCase(),
+    identifierKind: IdentifierKind.Ethereum
+  });
+  const buildXmtpSigner = (s) => {
+    const getIdentifier = () => toIdentifier(s.address);
+    if (s.type === "EOA") {
+      return { type: "EOA", getIdentifier, signMessage: s.signMessage };
+    }
+    return {
+      type: "SCW",
+      getIdentifier,
+      getChainId: () => BigInt(s.chainId),
+      signMessage: s.signMessage
+    };
+  };
   const env = options.env ?? "production";
   const signer = buildXmtpSigner(spec);
   const clientOptions = {
@@ -96,15 +122,16 @@ var createMessagingClient = async (spec, options = {}) => {
     sentAtMs: Number(message.sentAtNs / 1000000n)
   });
   const findDm = (peerAddress) => client.conversations.fetchDmByIdentifier(toIdentifier(peerAddress));
+  let streamAbort;
   return {
     address,
     async sync(consent) {
-      const states = consent?.map((c) => CONSENT_TO_SDK[c]);
+      const states = consent?.map((c) => consentToSdk[c]);
       await client.conversations.syncAll(states);
       await client.conversations.sync();
     },
     async listDms(consent) {
-      const states = consent?.map((c) => CONSENT_TO_SDK[c]);
+      const states = consent?.map((c) => consentToSdk[c]);
       const dms = client.conversations.listDms({ consentStates: states });
       return Promise.all(
         dms.map(async (dm) => {
@@ -154,13 +181,39 @@ var createMessagingClient = async (spec, options = {}) => {
       if (!dm) {
         throw new Error(`No conversation found with ${peerAddress}`);
       }
-      await dm.updateConsentState(CONSENT_TO_SDK[consent]);
+      await dm.updateConsentState(consentToSdk[consent]);
+    },
+    streamAllMessages() {
+      const ctrl = new AbortController();
+      streamAbort = ctrl;
+      const outerClient = client;
+      async function* generate() {
+        await outerClient.conversations.sync();
+        const stream = await outerClient.conversations.streamAllMessages();
+        for await (const message of stream) {
+          if (ctrl.signal.aborted) break;
+          let convo = outerClient.conversations.listDms().find((dm) => dm.id === message.conversationId);
+          if (!convo) {
+            await outerClient.conversations.sync();
+            convo = outerClient.conversations.listDms().find((dm) => dm.id === message.conversationId);
+            if (!convo) continue;
+          }
+          const addrByInbox = await addressMapForDm(convo);
+          const dmMessage = toMessage(message, addrByInbox);
+          const peerAddr = addrByInbox.get(convo.peerInboxId) ?? null;
+          yield { ...dmMessage, peerAddress: peerAddr };
+        }
+      }
+      return generate();
     },
     async close() {
+      if (streamAbort) {
+        streamAbort.abort();
+        streamAbort = void 0;
+      }
     }
   };
 };
 export {
-  buildXmtpSigner,
   createMessagingClient
 };