@xmtp/convos-cli 0.1.0

package/dist/utils/random.js

@@ -0,0 +1,19 @@
+import { randomBytes } from "node:crypto";
+/**
+ * Generate a random alphanumeric string of the given length.
+ * Uses rejection sampling to avoid modulo bias.
+ */
+export function randomAlphanumeric(length) {
+    const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    const maxValid = 256 - (256 % chars.length); // 252 for 62 chars
+    const result = [];
+    while (result.length < length) {
+        const bytes = randomBytes(length - result.length);
+        for (const b of bytes) {
+            if (b < maxValid && result.length < length) {
+                result.push(chars[b % chars.length]);
+            }
+        }
+    }
+    return result.join("");
+}

package/dist/utils/upload.d.ts

@@ -0,0 +1,14 @@
+export interface UploadProvider {
+    name: string;
+    upload(data: Uint8Array, filename: string, mimeType: string): Promise<string>;
+}
+interface UploadConfig {
+    uploadProvider?: string;
+    uploadProviderToken?: string;
+    uploadProviderGateway?: string;
+}
+export declare function getUploadProvider(config: UploadConfig): UploadProvider | null;
+/** Max size for inline attachments (bytes). Files larger than this
+ *  are automatically sent as remote attachments when a provider is configured. */
+export declare const INLINE_ATTACHMENT_MAX_BYTES = 1000000;
+export {};

package/dist/utils/upload.js

@@ -0,0 +1,51 @@
+class PinataProvider {
+    name = "pinata";
+    #jwt;
+    #gateway;
+    constructor(jwt, gateway) {
+        this.#jwt = jwt;
+        this.#gateway =
+            gateway?.replace(/\/$/, "") ?? "https://gateway.pinata.cloud";
+    }
+    async upload(data, filename, _mimeType) {
+        const formData = new FormData();
+        formData.append("file", new Blob([data]), filename);
+        const response = await fetch("https://api.pinata.cloud/pinning/pinFileToIPFS", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.#jwt}`,
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Pinata upload failed (${response.status}): ${text}`);
+        }
+        const result = (await response.json());
+        return `${this.#gateway}/ipfs/${result.IpfsHash}`;
+    }
+}
+const PROVIDER_FACTORIES = {
+    pinata: (config) => {
+        if (!config.uploadProviderToken) {
+            throw new Error("Pinata requires a JWT token. Set CONVOS_UPLOAD_PROVIDER_TOKEN or use --upload-provider-token.");
+        }
+        return new PinataProvider(config.uploadProviderToken, config.uploadProviderGateway);
+    },
+};
+function isProviderName(name) {
+    return Object.hasOwn(PROVIDER_FACTORIES, name);
+}
+export function getUploadProvider(config) {
+    if (!config.uploadProvider) {
+        return null;
+    }
+    if (!isProviderName(config.uploadProvider)) {
+        const available = Object.keys(PROVIDER_FACTORIES).join(", ");
+        throw new Error(`Unknown upload provider: ${config.uploadProvider}. Available: ${available}`);
+    }
+    return PROVIDER_FACTORIES[config.uploadProvider](config);
+}
+/** Max size for inline attachments (bytes). Files larger than this
+ *  are automatically sent as remote attachments when a provider is configured. */
+export const INLINE_ATTACHMENT_MAX_BYTES = 1_000_000;

package/dist/utils/xmtp.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Utilities extracted from @xmtp/cli that convos-cli needs.
+ *
+ * The published @xmtp/cli@0.1.0 only exports { run } — these small
+ * helpers are inlined here so convos-cli can be used with the official
+ * npm package instead of a local fork.
+ */
+import { Dm, Group, type DecodedMessage, type Conversation } from "@xmtp/node-sdk";
+export declare function isGroup(conversation: Conversation): conversation is Group;
+export declare function isDm(conversation: Conversation): conversation is Dm;
+export declare function requireGroup(conversation: Conversation): Group;
+export declare function requireDm(conversation: Conversation): Dm;
+export declare function toHexBytes(hex: string): Uint8Array;
+export declare function hexToBytes(value: string): Uint8Array;
+export declare function getAccountAddress(walletKey: string): string;
+export declare const VALID_ENVS: readonly ["local", "dev", "production"];
+/** Map of inboxId (lowercase) → display name. */
+export type ProfileMap = Map<string, string>;
+/**
+ * Build a ProfileMap from a Group's appData.
+ */
+export declare function buildProfileMap(appData: string): ProfileMap;
+/**
+ * Returns true if the message has a content type we know how to display.
+ * Use this to filter out unknown/binary content types from streams.
+ */
+export declare function isDisplayableMessage(message: DecodedMessage): boolean;
+/**
+ * Normalize message content to a string for display. NAPI-backed objects
+ * (like GroupUpdated) don't have enumerable properties, so JSON.stringify
+ * produces `{}` or they coerce to `[object Object]`. This function always
+ * returns a string safe for display.
+ *
+ * @param profiles - optional ProfileMap for resolving inbox IDs to names.
+ *   When omitted, unresolved members appear as "Somebody".
+ */
+export declare function normalizeMessageContent(message: DecodedMessage, profiles?: ProfileMap): string;
+export declare function isTTY(): boolean;
+export declare function jsonStringify(data: unknown, pretty?: boolean): string;
+export declare function formatHuman(data: unknown, indent?: number): string;
+export interface Section {
+    title: string;
+    data: Record<string, unknown>;
+}
+export declare function formatSections(sections: Section[], indent?: number): string;

package/dist/utils/xmtp.js

@@ -0,0 +1,298 @@
+/**
+ * Utilities extracted from @xmtp/cli that convos-cli needs.
+ *
+ * The published @xmtp/cli@0.1.0 only exports { run } — these small
+ * helpers are inlined here so convos-cli can be used with the official
+ * npm package instead of a local fork.
+ */
+import { stdout } from "node:process";
+import { Dm, Group, } from "@xmtp/node-sdk";
+import { parseAppData } from "./metadata.js";
+import { isHex, toBytes } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+// ─── Conversation type guards ───
+export function isGroup(conversation) {
+    return conversation instanceof Group;
+}
+export function isDm(conversation) {
+    return conversation instanceof Dm;
+}
+export function requireGroup(conversation) {
+    if (!isGroup(conversation)) {
+        throw new Error("This command is only available for group conversations");
+    }
+    return conversation;
+}
+export function requireDm(conversation) {
+    if (!isDm(conversation)) {
+        throw new Error("This command is only available for DM conversations");
+    }
+    return conversation;
+}
+// ─── Hex / key helpers ───
+export function toHexBytes(hex) {
+    const prefixedHex = hex.startsWith("0x") ? hex : `0x${hex}`;
+    return hexToBytes(prefixedHex);
+}
+export function hexToBytes(value) {
+    const hex = value.startsWith("0x") ? value : `0x${value}`;
+    if (!isHex(hex, { strict: true })) {
+        throw new Error(`Invalid hex string: ${value}`);
+    }
+    return toBytes(hex);
+}
+export function getAccountAddress(walletKey) {
+    const account = privateKeyToAccount(walletKey);
+    return account.address;
+}
+// ─── Config constants ───
+export const VALID_ENVS = ["local", "dev", "production"];
+/**
+ * Build a ProfileMap from a Group's appData.
+ */
+export function buildProfileMap(appData) {
+    const metadata = parseAppData(appData);
+    const map = new Map();
+    for (const p of metadata.profiles) {
+        if (p.name) {
+            map.set(p.inboxId.toLowerCase(), p.name);
+        }
+    }
+    return map;
+}
+/**
+ * Resolve an inbox ID to a display name, falling back to "Somebody".
+ */
+function resolveName(inboxId, profiles) {
+    return profiles.get(inboxId.toLowerCase()) ?? "Somebody";
+}
+/**
+ * Produce human-readable descriptions for a GroupUpdated event.
+ */
+function describeGroupUpdated(content, profiles) {
+    const descriptions = [];
+    const initiator = resolveName(content.initiatedByInboxId, profiles);
+    for (const inbox of content.addedInboxes) {
+        const added = resolveName(inbox.inboxId, profiles);
+        if (inbox.inboxId.toLowerCase() === content.initiatedByInboxId.toLowerCase()) {
+            descriptions.push(`${added} joined by invite`);
+        }
+        else {
+            descriptions.push(`${initiator} added ${added}`);
+        }
+    }
+    for (const inbox of content.removedInboxes) {
+        const removed = resolveName(inbox.inboxId, profiles);
+        descriptions.push(`${initiator} removed ${removed}`);
+    }
+    for (const inbox of content.leftInboxes) {
+        const left = resolveName(inbox.inboxId, profiles);
+        descriptions.push(`${left} left the group`);
+    }
+    for (const change of content.metadataFieldChanges) {
+        const field = change.fieldName.replace(/_/g, " ");
+        if (change.newValue) {
+            descriptions.push(`${initiator} changed ${field} to "${change.newValue}"`);
+        }
+        else {
+            descriptions.push(`${initiator} cleared ${field}`);
+        }
+    }
+    for (const inbox of content.addedAdminInboxes) {
+        const admin = resolveName(inbox.inboxId, profiles);
+        descriptions.push(`${initiator} made ${admin} an admin`);
+    }
+    for (const inbox of content.removedAdminInboxes) {
+        const admin = resolveName(inbox.inboxId, profiles);
+        descriptions.push(`${initiator} removed ${admin} as admin`);
+    }
+    for (const inbox of content.addedSuperAdminInboxes) {
+        const admin = resolveName(inbox.inboxId, profiles);
+        descriptions.push(`${initiator} made ${admin} a super admin`);
+    }
+    for (const inbox of content.removedSuperAdminInboxes) {
+        const admin = resolveName(inbox.inboxId, profiles);
+        descriptions.push(`${initiator} removed ${admin} as super admin`);
+    }
+    if (descriptions.length === 0) {
+        descriptions.push("Group updated");
+    }
+    return descriptions;
+}
+/**
+ * Content type IDs that we know how to display.
+ * Everything else may be a NAPI object that serializes as `[object Object]`.
+ */
+const DISPLAYABLE_TYPE_IDS = new Set([
+    "text",
+    "markdown",
+    "group_updated",
+    "reaction",
+    "reply",
+    "attachment",
+    "remoteStaticAttachment",
+    "multiRemoteStaticAttachment",
+]);
+/**
+ * Returns true if the message has a content type we know how to display.
+ * Use this to filter out unknown/binary content types from streams.
+ */
+export function isDisplayableMessage(message) {
+    const ct = message.contentType;
+    if (ct.authorityId !== "xmtp.org")
+        return false;
+    if (DISPLAYABLE_TYPE_IDS.has(ct.typeId))
+        return true;
+    // Fallback: if content is already a string, it's safe to display
+    return typeof message.content === "string";
+}
+/**
+ * Normalize message content to a string for display. NAPI-backed objects
+ * (like GroupUpdated) don't have enumerable properties, so JSON.stringify
+ * produces `{}` or they coerce to `[object Object]`. This function always
+ * returns a string safe for display.
+ *
+ * @param profiles - optional ProfileMap for resolving inbox IDs to names.
+ *   When omitted, unresolved members appear as "Somebody".
+ */
+export function normalizeMessageContent(message, profiles) {
+    const ct = message.contentType;
+    // Text / markdown — already a string
+    if (typeof message.content === "string") {
+        return message.content;
+    }
+    // GroupUpdated — human-readable description
+    if (ct.authorityId === "xmtp.org" &&
+        ct.typeId === "group_updated" &&
+        message.content != null &&
+        typeof message.content === "object") {
+        return describeGroupUpdated(message.content, profiles ?? new Map()).join("; ");
+    }
+    // Reaction — e.g. "reacted 👍 to <msgId>"
+    if (ct.authorityId === "xmtp.org" &&
+        ct.typeId === "reaction" &&
+        message.content != null &&
+        typeof message.content === "object") {
+        const r = message.content;
+        const verb = r.action === 2 ? "removed" : "reacted";
+        return `${verb} ${r.content} to ${r.reference}`;
+    }
+    // Reply — extract text content if possible
+    if (ct.authorityId === "xmtp.org" &&
+        ct.typeId === "reply" &&
+        message.content != null &&
+        typeof message.content === "object") {
+        const r = message.content;
+        const text = typeof r.content === "string" ? r.content : JSON.stringify(r.content);
+        return `reply to ${r.reference}: ${text}`;
+    }
+    // Inline attachment — filename and mime type
+    if (ct.authorityId === "xmtp.org" &&
+        ct.typeId === "attachment" &&
+        message.content != null &&
+        typeof message.content === "object") {
+        const a = message.content;
+        const name = a.filename || "unnamed";
+        return `[attachment: ${name} (${a.mimeType})]`;
+    }
+    // Remote attachment — URL, filename, mime info
+    if (ct.authorityId === "xmtp.org" &&
+        ct.typeId === "remoteStaticAttachment" &&
+        message.content != null &&
+        typeof message.content === "object") {
+        const a = message.content;
+        const name = a.filename || "unnamed";
+        return `[remote attachment: ${name} (${a.contentLength} bytes) ${a.url}]`;
+    }
+    // Multi remote attachment
+    if (ct.authorityId === "xmtp.org" &&
+        ct.typeId === "multiRemoteStaticAttachment" &&
+        message.content != null &&
+        typeof message.content === "object") {
+        const m = message.content;
+        const count = m.attachments?.length ?? 0;
+        const names = m.attachments?.map((a) => a.filename || "unnamed").join(", ") ?? "";
+        return `[${count} attachments: ${names}]`;
+    }
+    // Fallback — stringify safely
+    try {
+        const str = JSON.stringify(message.content);
+        return str !== undefined ? str : "";
+    }
+    catch {
+        return "";
+    }
+}
+// ─── Output formatting ───
+export function isTTY() {
+    return stdout.isTTY ?? false;
+}
+export function jsonStringify(data, pretty = false) {
+    return JSON.stringify(data, (_, value) => (typeof value === "bigint" ? value.toString() : value), pretty ? 2 : undefined);
+}
+export function formatHuman(data, indent = 0) {
+    const prefix = " ".repeat(indent);
+    if (data === null || data === undefined)
+        return "";
+    if (typeof data === "string")
+        return prefix + data;
+    if (typeof data === "number" ||
+        typeof data === "boolean" ||
+        typeof data === "bigint")
+        return prefix + String(data);
+    if (Array.isArray(data)) {
+        if (data.length === 0)
+            return prefix + "(empty)";
+        if (typeof data[0] === "object" && data[0] !== null)
+            return formatTable(data, prefix);
+        return data.map((item) => formatHuman(item, indent)).join("\n");
+    }
+    if (typeof data === "object")
+        return formatObject(data, prefix);
+    return prefix + jsonStringify(data);
+}
+function stringifyValue(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "bigint")
+        return String(value);
+    return jsonStringify(value);
+}
+function formatTable(rows, prefix = "") {
+    if (rows.length === 0)
+        return "";
+    const keys = Object.keys(rows[0]);
+    const widths = keys.map((key) => Math.max(key.length, ...rows.map((row) => stringifyValue(row[key]).length)));
+    const header = prefix + keys.map((key, i) => key.padEnd(widths[i])).join("  ");
+    const separator = prefix + widths.map((w) => "-".repeat(w)).join("  ");
+    const body = rows
+        .map((row) => prefix +
+        keys
+            .map((key, i) => stringifyValue(row[key]).padEnd(widths[i]))
+            .join("  "))
+        .join("\n");
+    return `${header}\n${separator}\n${body}`;
+}
+function formatObject(obj, prefix = "", keyWidth) {
+    const entries = Object.entries(obj).filter(([, v]) => v !== undefined && v !== null && v !== "");
+    if (entries.length === 0)
+        return "";
+    const maxKeyLen = keyWidth ?? Math.max(...entries.map(([k]) => k.length));
+    return entries
+        .map(([key, value]) => `${prefix}${key.padEnd(maxKeyLen)}  ${formatHuman(value)}`)
+        .join("\n");
+}
+export function formatSections(sections, indent = 0) {
+    const prefix = " ".repeat(indent);
+    const allKeys = sections.flatMap((s) => Object.entries(s.data)
+        .filter(([, v]) => v !== undefined && v !== null && v !== "")
+        .map(([k]) => k));
+    const keyWidth = allKeys.length > 0 ? Math.max(...allKeys.map((k) => k.length)) : 0;
+    return sections
+        .map((s) => `${s.title}\n\n${formatObject(s.data, prefix, keyWidth)}`)
+        .join("\n\n");
+}