@xmtp/convos-cli 0.1.0

package/dist/commands/conversations/list.js

@@ -0,0 +1,109 @@
+import { Flags } from "@oclif/core";
+import { getAccountAddress, isGroup } from "../../utils/xmtp.js";
+import { ConvosBaseCommand } from "../../baseCommand.js";
+import { createClientForIdentity } from "../../utils/client.js";
+import { createIdentityStore } from "../../utils/identities.js";
+export default class ConversationsList extends ConvosBaseCommand {
+    static description = `List all Convos conversations.
+
+Lists conversations across all per-conversation identities.
+Each conversation is associated with its own XMTP identity.
+
+Use --sync to fetch the latest state from the network.`;
+    static examples = [
+        {
+            command: "<%= config.bin %> <%= command.id %>",
+            description: "List all conversations",
+        },
+        {
+            command: "<%= config.bin %> <%= command.id %> --sync",
+            description: "Sync from network then list",
+        },
+        {
+            command: "<%= config.bin %> <%= command.id %> --json",
+            description: "Output as JSON",
+        },
+    ];
+    static flags = {
+        ...ConvosBaseCommand.baseFlags,
+        sync: Flags.boolean({
+            description: "Sync each identity from network before listing",
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ConversationsList);
+        const config = this.getConvosConfig();
+        const store = createIdentityStore();
+        const allLinked = store.list().filter((i) => i.conversationId);
+        // Deduplicate: only use the oldest identity per conversation ID
+        const seen = new Map();
+        const identities = [];
+        // list() is sorted newest-first, so iterate in reverse to pick oldest first
+        for (let i = allLinked.length - 1; i >= 0; i--) {
+            const identity = allLinked[i];
+            const convId = identity.conversationId;
+            if (!seen.has(convId)) {
+                seen.set(convId, true);
+                identities.push(identity);
+            }
+        }
+        // Warn about duplicate identities for the same conversation
+        const duplicates = new Map();
+        for (const identity of allLinked) {
+            const convId = identity.conversationId;
+            duplicates.set(convId, (duplicates.get(convId) ?? 0) + 1);
+        }
+        for (const [convId, count] of duplicates) {
+            if (count > 1) {
+                this.warn(`${count} identities found for conversation ${convId}. ` +
+                    `Run 'convos identity list' to review and remove duplicates.`);
+            }
+        }
+        if (identities.length === 0) {
+            this.output({
+                message: "No conversations found. Create one with: convos conversations create",
+                count: 0,
+            });
+            return;
+        }
+        const output = [];
+        for (const identity of identities) {
+            try {
+                const client = await createClientForIdentity(identity, config);
+                if (flags.sync) {
+                    await client.conversations.sync();
+                }
+                const conversations = await client.conversations.list();
+                for (const conversation of conversations) {
+                    const members = await conversation.members();
+                    let isLocked = false;
+                    if (isGroup(conversation)) {
+                        const { policySet } = conversation.permissions();
+                        isLocked = policySet.addMemberPolicy === 1 /* PermissionPolicy.Deny */;
+                    }
+                    output.push({
+                        conversationId: conversation.id,
+                        identityId: identity.id,
+                        label: identity.label ?? "",
+                        profileName: identity.profileName ?? "",
+                        address: getAccountAddress(identity.walletKey),
+                        createdAt: conversation.createdAt.toISOString(),
+                        memberCount: members.length,
+                        isActive: conversation.isActive,
+                        isLocked,
+                    });
+                }
+            }
+            catch (error) {
+                output.push({
+                    conversationId: identity.conversationId,
+                    identityId: identity.id,
+                    label: identity.label ?? "",
+                    error: error instanceof Error ? error.message : "Unknown error",
+                });
+            }
+        }
+        this.output(output);
+    }
+}

package/dist/commands/conversations/process-join-requests.d.ts

@@ -0,0 +1,26 @@
+import { ConvosBaseCommand } from "../../baseCommand.js";
+export default class ProcessJoinRequests extends ConvosBaseCommand {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {
+        watch: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        conversation: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "log-level": import("@oclif/core/interfaces").OptionFlag<"off" | "error" | "warn" | "info" | "debug" | "trace" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "structured-logging": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "app-version": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "env-file": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        env: import("@oclif/core/interfaces").OptionFlag<"local" | "dev" | "production" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "gateway-host": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    /**
+     * Attempt to process a single DM message as a join request.
+     * Returns the result if successfully processed, or undefined.
+     */
+    private processMessage;
+    run(): Promise<void>;
+}

package/dist/commands/conversations/process-join-requests.js

@@ -0,0 +1,261 @@
+import { Flags } from "@oclif/core";
+import { requireGroup } from "../../utils/xmtp.js";
+import { ConvosBaseCommand } from "../../baseCommand.js";
+import { createClientForIdentity } from "../../utils/client.js";
+import { createIdentityStore } from "../../utils/identities.js";
+import { parseInvite, decryptConversationToken, verifyInvite, verifyInviteSignature } from "../../utils/invite.js";
+import { parseAppData } from "../../utils/metadata.js";
+export default class ProcessJoinRequests extends ConvosBaseCommand {
+    static description = `Process pending join requests for all conversations.
+
+Scans DMs for each identity looking for join requests (text messages
+containing signed invite slugs). When a valid join request is found:
+
+1. Verify the invite signature
+2. Decrypt the conversation token to get the conversation ID
+3. Verify the creator inbox ID matches
+4. Add the requester to the conversation
+5. Block invalid/spam requests
+
+Without --watch, processes all pending DMs and exits.
+With --watch, streams DM messages in real-time and processes
+join requests as they arrive (recommended for always-on usage).`;
+    static examples = [
+        {
+            command: "<%= config.bin %> <%= command.id %>",
+            description: "Process all pending join requests",
+        },
+        {
+            command: "<%= config.bin %> <%= command.id %> --watch",
+            description: "Continuously stream and process join requests in real-time",
+        },
+        {
+            command: "<%= config.bin %> <%= command.id %> --conversation <id>",
+            description: "Process join requests for a specific conversation only",
+        },
+    ];
+    static flags = {
+        ...ConvosBaseCommand.baseFlags,
+        watch: Flags.boolean({
+            description: "Stream DM messages in real-time and process join requests as they arrive",
+            default: false,
+        }),
+        conversation: Flags.string({
+            description: "Only process requests for this conversation ID",
+            helpValue: "<id>",
+        }),
+    };
+    /**
+     * Attempt to process a single DM message as a join request.
+     * Returns the result if successfully processed, or undefined.
+     */
+    async processMessage(message, client, identity) {
+        // Skip our own messages
+        if (message.senderInboxId === client.inboxId)
+            return;
+        // Try to parse as invite
+        const text = typeof message.content === "string" ? message.content : null;
+        if (!text)
+            return;
+        let invite;
+        try {
+            invite = parseInvite(text);
+        }
+        catch {
+            return; // Not an invite, skip
+        }
+        // Look up the DM conversation to manage consent
+        const dmConversation = await client.conversations.getConversationById(message.conversationId);
+        // Step 1: Verify structural validity and signature recoverability
+        if (!(await verifyInvite(invite))) {
+            this.log(`Invalid invite structure/signature from ${message.senderInboxId} — blocking DM`);
+            if (dmConversation)
+                dmConversation.updateConsentState(2 /* ConsentState.Denied */);
+            return;
+        }
+        // Step 2: Verify the signature was made by this identity's wallet key
+        if (!(await verifyInviteSignature(invite, identity.walletKey))) {
+            this.log(`Invite signature doesn't match our wallet key — blocking DM`);
+            if (dmConversation)
+                dmConversation.updateConsentState(2 /* ConsentState.Denied */);
+            return;
+        }
+        // Step 3: Verify creator inbox ID matches us
+        if (invite.creatorInboxId !== client.inboxId) {
+            this.log(`Invite not for this inbox — blocking DM`);
+            if (dmConversation)
+                dmConversation.updateConsentState(2 /* ConsentState.Denied */);
+            return;
+        }
+        // Step 4: Check expiration
+        if (invite.expiresAt && invite.expiresAt < new Date()) {
+            this.log(`Invite expired — skipping`);
+            return;
+        }
+        // Step 5: Decrypt conversation token
+        let conversationId;
+        try {
+            conversationId = decryptConversationToken(invite.conversationToken, client.inboxId, Buffer.from(identity.walletKey.replace("0x", ""), "hex"));
+        }
+        catch {
+            this.log(`Failed to decrypt conversation token — blocking DM`);
+            if (dmConversation)
+                dmConversation.updateConsentState(2 /* ConsentState.Denied */);
+            return;
+        }
+        // Step 6: Verify conversation exists
+        const conversation = await client.conversations.getConversationById(conversationId);
+        if (!conversation) {
+            this.log(`Conversation ${conversationId} not found — skipping`);
+            return;
+        }
+        const group = requireGroup(conversation);
+        // Step 7: Verify the invite tag matches the group's current tag
+        try {
+            const appData = group.appData ?? "";
+            const metadata = parseAppData(appData);
+            if (metadata.tag && invite.tag !== metadata.tag) {
+                this.log(`Invite tag mismatch (invite=${invite.tag}, group=${metadata.tag}) — rejecting`);
+                return;
+            }
+        }
+        catch {
+            // If we can't read appData, skip tag check but continue
+        }
+        // Step 8: Add the requester
+        this.log(`Adding ${message.senderInboxId} to conversation ${conversationId}`);
+        await group.addMembers([message.senderInboxId]);
+        // Mark DM as allowed so we don't re-process
+        if (dmConversation)
+            dmConversation.updateConsentState(1 /* ConsentState.Allowed */);
+        return {
+            conversationId,
+            joinerInboxId: message.senderInboxId,
+            identityId: identity.id,
+            tag: invite.tag,
+        };
+    }
+    async run() {
+        const { flags } = await this.parse(ProcessJoinRequests);
+        const config = this.getConvosConfig();
+        const store = createIdentityStore();
+        const identities = flags.conversation
+            ? [store.getByConversationId(flags.conversation)].filter(Boolean)
+            : store.list().filter((i) => i.conversationId);
+        if (identities.length === 0) {
+            this.output({ message: "No linked identities found.", processed: 0 });
+            return;
+        }
+        // ─── Batch mode: process all pending DMs ───
+        const allResults = [];
+        // Build clients for all identities (needed for both batch and watch)
+        const clientMap = new Map();
+        for (const identity of identities) {
+            if (!identity)
+                continue;
+            try {
+                const client = await createClientForIdentity(identity, config);
+                clientMap.set(identity.id, { client, identity });
+            }
+            catch (error) {
+                this.log(`Error initializing identity ${identity.id}: ${error instanceof Error ? error.message : "unknown"}`);
+            }
+        }
+        for (const [, { client, identity }] of clientMap) {
+            try {
+                await client.conversations.sync();
+                // List DMs with unknown consent (potential join requests)
+                const dms = await client.conversations.list({
+                    conversationType: 0 /* ConversationType.Dm */,
+                    consentStates: [0 /* ConsentState.Unknown */],
+                });
+                for (const dm of dms) {
+                    try {
+                        await dm.sync();
+                        const messages = await dm.messages({ limit: 10 });
+                        for (const message of messages) {
+                            try {
+                                const result = await this.processMessage(message, client, identity);
+                                if (result) {
+                                    allResults.push(result);
+                                    break; // Only process first valid invite per DM
+                                }
+                            }
+                            catch (error) {
+                                this.log(`Error processing message: ${error instanceof Error ? error.message : "unknown"}`);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        this.log(`Error processing DM: ${error instanceof Error ? error.message : "unknown"}`);
+                    }
+                }
+            }
+            catch (error) {
+                this.log(`Error with identity ${identity.id}: ${error instanceof Error ? error.message : "unknown"}`);
+            }
+        }
+        if (!flags.watch) {
+            this.output({
+                processed: allResults.length,
+                results: allResults,
+            });
+            return;
+        }
+        // ─── Watch mode: stream DM messages in real-time ───
+        if (allResults.length > 0) {
+            this.log(`\nProcessed ${allResults.length} pending request(s).`);
+        }
+        this.log("\nStreaming DM messages for join requests (Ctrl+C to stop)...\n");
+        // Build an inboxId → { client, identity } lookup so we can route
+        // streamed messages to the correct identity
+        const inboxMap = new Map();
+        for (const [, entry] of clientMap) {
+            inboxMap.set(entry.client.inboxId, entry);
+        }
+        // Start a DM message stream for each identity
+        const streams = [];
+        for (const [, { client, identity }] of clientMap) {
+            try {
+                const stream = await client.conversations.streamAllDmMessages();
+                streams.push(stream);
+                // Process messages from this stream in the background
+                (async () => {
+                    try {
+                        for await (const message of stream) {
+                            try {
+                                const result = await this.processMessage(message, client, identity);
+                                if (result) {
+                                    this.streamOutput({
+                                        event: "join_request_accepted",
+                                        ...result,
+                                        timestamp: new Date().toISOString(),
+                                    });
+                                }
+                            }
+                            catch (error) {
+                                this.log(`Error processing streamed message: ${error instanceof Error ? error.message : "unknown"}`);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        this.log(`Stream ended for identity ${identity.id}: ${error instanceof Error ? error.message : "unknown"}`);
+                    }
+                })();
+            }
+            catch (error) {
+                this.log(`Failed to start stream for identity ${identity.id}: ${error instanceof Error ? error.message : "unknown"}`);
+            }
+        }
+        // Keep running until interrupted
+        await new Promise((resolve) => {
+            process.on("SIGINT", () => {
+                this.log("\nStopping streams...");
+                for (const stream of streams) {
+                    void stream.return();
+                }
+                resolve();
+            });
+        });
+    }
+}

package/dist/commands/conversations/sync.d.ts

@@ -0,0 +1,19 @@
+import { ConvosBaseCommand } from "../../baseCommand.js";
+export default class ConversationsSync extends ConvosBaseCommand {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {
+        "log-level": import("@oclif/core/interfaces").OptionFlag<"off" | "error" | "warn" | "info" | "debug" | "trace" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "structured-logging": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "app-version": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "env-file": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        env: import("@oclif/core/interfaces").OptionFlag<"local" | "dev" | "production" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "gateway-host": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/conversations/sync.js

@@ -0,0 +1,50 @@
+import { ConvosBaseCommand } from "../../baseCommand.js";
+import { createClientForIdentity } from "../../utils/client.js";
+import { createIdentityStore } from "../../utils/identities.js";
+export default class ConversationsSync extends ConvosBaseCommand {
+    static description = `Sync all conversations from the network.
+
+Synchronizes every linked identity with the XMTP network.
+Fetches new messages and membership changes for all conversations.`;
+    static examples = [
+        {
+            command: "<%= config.bin %> <%= command.id %>",
+            description: "Sync all conversations",
+        },
+    ];
+    static flags = {
+        ...ConvosBaseCommand.baseFlags,
+    };
+    async run() {
+        const config = this.getConvosConfig();
+        const store = createIdentityStore();
+        const identities = store.list().filter((i) => i.conversationId);
+        const results = [];
+        for (const identity of identities) {
+            try {
+                const client = await createClientForIdentity(identity, config);
+                await client.conversations.sync();
+                results.push({
+                    identityId: identity.id,
+                    conversationId: identity.conversationId,
+                    label: identity.label ?? "",
+                    success: true,
+                });
+            }
+            catch (error) {
+                results.push({
+                    identityId: identity.id,
+                    conversationId: identity.conversationId,
+                    label: identity.label ?? "",
+                    success: false,
+                    error: error instanceof Error ? error.message : "Unknown error",
+                });
+            }
+        }
+        this.output({
+            synced: results.filter((r) => r.success).length,
+            failed: results.filter((r) => !r.success).length,
+            results,
+        });
+    }
+}

package/dist/commands/identity/create.d.ts

@@ -0,0 +1,21 @@
+import { ConvosBaseCommand } from "../../baseCommand.js";
+export default class IdentityCreate extends ConvosBaseCommand {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {
+        label: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "profile-name": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "log-level": import("@oclif/core/interfaces").OptionFlag<"off" | "error" | "warn" | "info" | "debug" | "trace" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "structured-logging": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "app-version": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "env-file": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        env: import("@oclif/core/interfaces").OptionFlag<"local" | "dev" | "production" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "gateway-host": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/identity/create.js

@@ -0,0 +1,56 @@
+import { Flags } from "@oclif/core";
+import { getAccountAddress } from "../../utils/xmtp.js";
+import { ConvosBaseCommand } from "../../baseCommand.js";
+import { createIdentityStore } from "../../utils/identities.js";
+export default class IdentityCreate extends ConvosBaseCommand {
+    static description = `Create a new Convos identity.
+
+Generates a new wallet key and database encryption key for use with
+a single conversation. Each conversation gets its own identity for
+maximum privacy (per ADR 002).
+
+You can optionally set a label (local-only) and profile name (shared
+with conversation members per ADR 005).`;
+    static examples = [
+        {
+            command: "<%= config.bin %> <%= command.id %>",
+            description: "Create a new identity",
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> --label "Work Chat"',
+            description: "Create with a local label",
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> --label "Team" --profile-name "Alice"',
+            description: "Create with label and profile name",
+        },
+    ];
+    static flags = {
+        ...ConvosBaseCommand.baseFlags,
+        label: Flags.string({
+            description: "Local label for this identity (not shared)",
+            helpValue: "<label>",
+        }),
+        "profile-name": Flags.string({
+            description: "Profile display name (shared with conversation members)",
+            helpValue: "<name>",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(IdentityCreate);
+        const store = createIdentityStore();
+        const identity = store.create({
+            label: flags.label,
+            profileName: flags["profile-name"],
+        });
+        this.output({
+            id: identity.id,
+            address: getAccountAddress(identity.walletKey),
+            label: identity.label ?? "",
+            profileName: identity.profileName ?? "",
+            createdAt: identity.createdAt,
+            message: "Identity created. Use it with: convos conversations create --identity " +
+                identity.id,
+        });
+    }
+}

package/dist/commands/identity/info.d.ts

@@ -0,0 +1,22 @@
+import { ConvosBaseCommand } from "../../baseCommand.js";
+export default class IdentityInfo extends ConvosBaseCommand {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        "log-level": import("@oclif/core/interfaces").OptionFlag<"off" | "error" | "warn" | "info" | "debug" | "trace" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "structured-logging": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "app-version": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "env-file": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        env: import("@oclif/core/interfaces").OptionFlag<"local" | "dev" | "production" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "gateway-host": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/identity/info.js

@@ -0,0 +1,63 @@
+import { Args } from "@oclif/core";
+import { getAccountAddress, formatSections } from "../../utils/xmtp.js";
+import { ConvosBaseCommand } from "../../baseCommand.js";
+import { createClientForIdentity } from "../../utils/client.js";
+import { createIdentityStore } from "../../utils/identities.js";
+export default class IdentityInfo extends ConvosBaseCommand {
+    static description = `Display detailed information about an identity.
+
+Shows wallet address, XMTP inbox ID, linked conversation, profile
+settings, and XMTP client details. Creates and registers the XMTP
+client if not yet registered.`;
+    static examples = [
+        {
+            command: "<%= config.bin %> <%= command.id %> <identity-id>",
+            description: "Show identity details",
+        },
+    ];
+    static args = {
+        id: Args.string({
+            description: "The identity ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...ConvosBaseCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(IdentityInfo);
+        const config = this.getConvosConfig();
+        const store = createIdentityStore();
+        const identity = store.get(args.id);
+        if (!identity) {
+            this.error(`Identity not found: ${args.id}`);
+        }
+        const client = await createClientForIdentity(identity, config);
+        const properties = {
+            id: identity.id,
+            address: getAccountAddress(identity.walletKey),
+            inboxId: client.inboxId,
+            installationId: client.installationId,
+            isRegistered: client.isRegistered,
+            conversationId: identity.conversationId ?? "(unlinked)",
+            label: identity.label ?? "",
+            profileName: identity.profileName ?? "",
+            createdAt: identity.createdAt,
+        };
+        const clientInfo = {
+            env: config.env,
+            libxmtpVersion: client.libxmtpVersion,
+            appVersion: client.appVersion,
+            disableDeviceSync: true,
+        };
+        if (this.jsonOutput) {
+            this.output({ properties, client: clientInfo });
+        }
+        else {
+            this.log(formatSections([
+                { title: "Identity", data: properties },
+                { title: "Client", data: clientInfo },
+            ], 2));
+        }
+    }
+}

package/dist/commands/identity/list.d.ts

@@ -0,0 +1,19 @@
+import { ConvosBaseCommand } from "../../baseCommand.js";
+export default class IdentityList extends ConvosBaseCommand {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {
+        "log-level": import("@oclif/core/interfaces").OptionFlag<"off" | "error" | "warn" | "info" | "debug" | "trace" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "structured-logging": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "app-version": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "env-file": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        env: import("@oclif/core/interfaces").OptionFlag<"local" | "dev" | "production" | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "gateway-host": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}