@xmtp/convos-cli 0.1.0

package/dist/commands/conversation/add-members.js

@@ -0,0 +1,39 @@
+import { Args } 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";
+export default class ConversationAddMembers extends ConvosBaseCommand {
+    static description = `Add members to a conversation by inbox ID.
+
+Low-level member addition. In Convos, members typically join via
+invite links instead. Requires super admin permissions.`;
+    static strict = false;
+    static args = {
+        id: Args.string({ description: "The conversation ID", required: true }),
+    };
+    static flags = { ...ConvosBaseCommand.baseFlags };
+    async run() {
+        const { args, argv } = await this.parse(ConversationAddMembers);
+        const inboxIds = argv.slice(1);
+        if (inboxIds.length === 0)
+            this.error("At least one inbox ID is required");
+        const config = this.getConvosConfig();
+        const store = createIdentityStore();
+        const identity = store.getByConversationId(args.id);
+        if (!identity)
+            this.error(`No identity found for conversation: ${args.id}`);
+        const client = await createClientForIdentity(identity, config);
+        const conversation = await client.conversations.getConversationById(args.id);
+        if (!conversation)
+            this.error(`Conversation not found: ${args.id}`);
+        const group = requireGroup(conversation);
+        await group.addMembers(inboxIds);
+        this.output({
+            success: true,
+            conversationId: args.id,
+            addedInboxIds: inboxIds,
+            count: inboxIds.length,
+        });
+    }
+}

package/dist/commands/conversation/consent-state.d.ts

@@ -0,0 +1,18 @@
+import { ConvosBaseCommand } from "../../baseCommand.js";
+export default class ConversationConsentState extends ConvosBaseCommand {
+    static 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/conversation/consent-state.js

@@ -0,0 +1,24 @@
+import { Args } from "@oclif/core";
+import { ConvosBaseCommand } from "../../baseCommand.js";
+import { createClientForIdentity } from "../../utils/client.js";
+import { createIdentityStore } from "../../utils/identities.js";
+export default class ConversationConsentState extends ConvosBaseCommand {
+    static description = `Get the consent state of a conversation.`;
+    static args = {
+        id: Args.string({ description: "The conversation ID", required: true }),
+    };
+    static flags = { ...ConvosBaseCommand.baseFlags };
+    async run() {
+        const { args } = await this.parse(ConversationConsentState);
+        const config = this.getConvosConfig();
+        const store = createIdentityStore();
+        const identity = store.getByConversationId(args.id);
+        if (!identity)
+            this.error(`No identity found for conversation: ${args.id}`);
+        const client = await createClientForIdentity(identity, config);
+        const conversation = await client.conversations.getConversationById(args.id);
+        if (!conversation)
+            this.error(`Conversation not found: ${args.id}`);
+        this.output({ conversationId: args.id, consentState: conversation.consentState() });
+    }
+}

package/dist/commands/conversation/download-attachment.d.ts

@@ -0,0 +1,28 @@
+import { ConvosBaseCommand } from "../../baseCommand.js";
+export default class ConversationDownloadAttachment extends ConvosBaseCommand {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        "message-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        raw: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        sync: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "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>;
+    private downloadInline;
+    private downloadRemote;
+}

package/dist/commands/conversation/download-attachment.js

@@ -0,0 +1,164 @@
+import { writeFile as fsWriteFile, mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { cwd } from "node:process";
+import { Args, Flags } from "@oclif/core";
+import { decryptAttachment, } from "@xmtp/node-sdk";
+import { ConvosBaseCommand } from "../../baseCommand.js";
+import { createClientForIdentity } from "../../utils/client.js";
+import { createIdentityStore } from "../../utils/identities.js";
+import { getExtension } from "../../utils/mime.js";
+export default class ConversationDownloadAttachment extends ConvosBaseCommand {
+    static description = `Download an attachment from a message.
+
+Downloads an attachment message and saves it to disk. Handles both
+inline attachments and remote (encrypted) attachments transparently.
+
+For inline attachments, the content is written directly to disk.
+
+For remote attachments, the encrypted payload is fetched from the URL
+embedded in the message, decrypted using the keys in the message, and
+the decrypted content is saved to disk.
+
+The output filename is determined by (in order of priority):
+1. The --output flag (explicit path)
+2. The filename from the message metadata
+3. Auto-generated from message ID + MIME type extension
+
+Use --raw to save the encrypted payload without decrypting (remote
+attachments only).`;
+    static examples = [
+        {
+            command: "<%= config.bin %> <%= command.id %> <conversation-id> <message-id>",
+            description: "Download attachment (auto-names from message metadata)",
+        },
+        {
+            command: "<%= config.bin %> <%= command.id %> <conversation-id> <message-id> --output ./photo.jpg",
+            description: "Download to a specific path",
+        },
+        {
+            command: "<%= config.bin %> <%= command.id %> <conversation-id> <message-id> --raw",
+            description: "Save the encrypted payload without decrypting (remote only)",
+        },
+    ];
+    static args = {
+        id: Args.string({
+            description: "The conversation ID",
+            required: true,
+        }),
+        "message-id": Args.string({
+            description: "The message ID of the attachment",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...ConvosBaseCommand.baseFlags,
+        output: Flags.string({
+            char: "o",
+            description: "Output file path (default: auto-generated from metadata)",
+            helpValue: "<path>",
+        }),
+        raw: Flags.boolean({
+            description: "Save encrypted payload without decrypting (remote attachments only)",
+            default: false,
+        }),
+        sync: Flags.boolean({
+            description: "Sync conversation from network before downloading",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ConversationDownloadAttachment);
+        const config = this.getConvosConfig();
+        const store = createIdentityStore();
+        const identity = store.getByConversationId(args.id);
+        if (!identity) {
+            this.error(`No identity found for conversation: ${args.id}\nUse 'convos conversations list' to see available conversations.`);
+        }
+        const client = await createClientForIdentity(identity, config);
+        const conversation = await client.conversations.getConversationById(args.id);
+        if (!conversation) {
+            this.error(`Conversation not found: ${args.id}`);
+        }
+        if (flags.sync) {
+            await conversation.sync();
+        }
+        const message = client.conversations.getMessageById(args["message-id"]);
+        if (!message) {
+            this.error(`Message not found: ${args["message-id"]}. Try --sync to fetch latest messages.`);
+        }
+        const typeId = message.contentType.typeId;
+        if (typeId === "attachment") {
+            await this.downloadInline(message.content, args["message-id"], flags);
+        }
+        else if (typeId === "remoteStaticAttachment") {
+            await this.downloadRemote(message.content, args["message-id"], flags);
+        }
+        else {
+            this.error(`Message ${args["message-id"]} is not an attachment (type: ${typeId})`);
+        }
+    }
+    async downloadInline(attachment, messageId, flags) {
+        const bytes = attachment.content;
+        const mimeType = attachment.mimeType;
+        const filename = flags.output ??
+            attachment.filename ??
+            `${messageId.slice(0, 16)}${getExtension(mimeType)}`;
+        const outputPath = isAbsolute(filename) ? filename : join(cwd(), filename);
+        await writeFileWithDirs(outputPath, bytes);
+        this.output({
+            success: true,
+            type: "inline",
+            outputPath,
+            filename: attachment.filename,
+            mimeType,
+            size: bytes.length,
+        });
+    }
+    async downloadRemote(remote, messageId, flags) {
+        const response = await fetch(remote.url);
+        if (!response.ok) {
+            this.error(`Failed to fetch remote attachment: ${response.status} ${response.statusText} (${remote.url})`);
+        }
+        const encryptedBytes = new Uint8Array(await response.arrayBuffer());
+        if (flags.raw) {
+            const filename = flags.output ??
+                `${remote.filename ?? messageId.slice(0, 16)}.encrypted`;
+            const outputPath = isAbsolute(filename)
+                ? filename
+                : join(cwd(), filename);
+            await writeFileWithDirs(outputPath, encryptedBytes);
+            this.output({
+                success: true,
+                type: "remote-raw",
+                outputPath,
+                url: remote.url,
+                size: encryptedBytes.length,
+            });
+            return;
+        }
+        const decrypted = decryptAttachment(encryptedBytes, remote);
+        const mimeType = decrypted.mimeType;
+        const filename = flags.output ??
+            decrypted.filename ??
+            remote.filename ??
+            `${messageId.slice(0, 16)}${getExtension(mimeType)}`;
+        const outputPath = isAbsolute(filename) ? filename : join(cwd(), filename);
+        await writeFileWithDirs(outputPath, decrypted.content);
+        this.output({
+            success: true,
+            type: "remote",
+            outputPath,
+            filename: decrypted.filename ?? remote.filename,
+            mimeType,
+            size: decrypted.content.length,
+            url: remote.url,
+        });
+    }
+}
+function isAbsolute(p) {
+    return p.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(p);
+}
+async function writeFileWithDirs(path, data) {
+    await mkdir(dirname(path), { recursive: true });
+    await fsWriteFile(path, data);
+}

package/dist/commands/conversation/explode.d.ts

@@ -0,0 +1,24 @@
+import { ConvosBaseCommand } from "../../baseCommand.js";
+export default class ConversationExplode 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: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        scheduled: 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/conversation/explode.js

@@ -0,0 +1,156 @@
+import { Args, 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 { parseAppData, serializeAppData } from "../../utils/metadata.js";
+/**
+ * Encode an ExplodeSettings message matching the iOS content type.
+ *
+ * Content type: convos.org/explode_settings:1.0
+ * Payload: JSON-encoded { expiresAt: ISO8601 string }
+ * Fallback: "Conversation expires at {date}"
+ */
+function encodeExplodeSettings(expiresAt) {
+    const payload = JSON.stringify({
+        expiresAt: expiresAt.toISOString(),
+    });
+    return {
+        type: {
+            authorityId: "convos.org",
+            typeId: "explode_settings",
+            versionMajor: 1,
+            versionMinor: 0,
+        },
+        parameters: {},
+        fallback: `Conversation expires at ${expiresAt.toISOString()}`,
+        content: new TextEncoder().encode(payload),
+    };
+}
+export default class ConversationExplode extends ConvosBaseCommand {
+    static description = `Explode (permanently destroy) a conversation.
+
+Sends an ExplodeSettings message to notify all members, updates the
+group metadata with the expiration timestamp, removes all members,
+then deletes the local identity including wallet key, database
+encryption key, and XMTP database. This is irreversible.
+
+Per ADR 004: destroying the per-conversation identity destroys the
+cryptographic material needed to decrypt messages. Recovery is
+impossible.
+
+Steps:
+1. Send ExplodeSettings message (notifies iOS/other clients)
+2. Update group metadata with expiresAtUnix
+3. Remove all other members from the XMTP group
+4. Delete the local identity (private keys + database)
+
+Only the conversation creator (super admin) should explode.`;
+    static examples = [
+        {
+            command: "<%= config.bin %> <%= command.id %> <conversation-id> --force",
+            description: "Explode a conversation immediately",
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> <conversation-id> --scheduled "2025-03-01T00:00:00Z"',
+            description: "Schedule a conversation to explode at a specific time",
+        },
+    ];
+    static args = {
+        id: Args.string({ description: "The conversation ID", required: true }),
+    };
+    static flags = {
+        ...ConvosBaseCommand.baseFlags,
+        force: Flags.boolean({
+            char: "f",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+        scheduled: Flags.string({
+            description: "Schedule explosion for a future date (ISO8601). If omitted, explodes immediately.",
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ConversationExplode);
+        const config = this.getConvosConfig();
+        const store = createIdentityStore();
+        const identity = store.getByConversationId(args.id);
+        if (!identity)
+            this.error(`No identity found for conversation: ${args.id}`);
+        // Determine expiration time
+        let expiresAt;
+        if (flags.scheduled) {
+            expiresAt = new Date(flags.scheduled);
+            if (isNaN(expiresAt.getTime())) {
+                this.error(`Invalid date: ${flags.scheduled}`);
+            }
+            if (expiresAt <= new Date()) {
+                this.error("Scheduled date must be in the future");
+            }
+        }
+        else {
+            expiresAt = new Date();
+        }
+        const isImmediate = !flags.scheduled;
+        const confirmMessage = isImmediate
+            ? "This will permanently destroy the conversation and delete all cryptographic keys.\n" +
+                "All members will be removed. Messages cannot be recovered."
+            : `This will schedule the conversation to explode at ${expiresAt.toISOString()}.\n` +
+                "All members will be notified. When the time arrives, clients will destroy their local data.";
+        await this.confirmAction(confirmMessage, flags.force);
+        const client = await createClientForIdentity(identity, config);
+        const conversation = await client.conversations.getConversationById(args.id);
+        if (!conversation)
+            this.error(`Conversation not found: ${args.id}`);
+        const group = requireGroup(conversation);
+        // Step 1: Send ExplodeSettings message (must happen before removing members)
+        const encodedContent = encodeExplodeSettings(expiresAt);
+        await group.send(encodedContent, { shouldPush: true });
+        // Step 2: Update group metadata with expiresAtUnix
+        try {
+            let appData = "";
+            try {
+                appData = group.appData ?? "";
+            }
+            catch {
+                // No appData yet
+            }
+            const metadata = parseAppData(appData);
+            metadata.expiresAtUnix = Math.floor(expiresAt.getTime() / 1000);
+            const newAppData = serializeAppData(metadata);
+            await group.updateAppData(newAppData);
+        }
+        catch {
+            // Non-fatal: metadata update is secondary to the message
+        }
+        if (isImmediate) {
+            // Step 3: Remove all other members
+            const members = await group.members();
+            const others = members.filter((m) => m.inboxId !== client.inboxId);
+            if (others.length > 0) {
+                await group.removeMembers(others.map((m) => m.inboxId));
+            }
+            // Step 4: Delete local identity
+            store.remove(identity.id);
+            this.output({
+                success: true,
+                conversationId: args.id,
+                identityDestroyed: identity.id,
+                membersRemoved: others.length,
+                expiresAt: expiresAt.toISOString(),
+                message: "Conversation exploded. All cryptographic keys destroyed.",
+            });
+        }
+        else {
+            // Scheduled: don't remove members or destroy identity yet
+            this.output({
+                success: true,
+                conversationId: args.id,
+                scheduled: true,
+                expiresAt: expiresAt.toISOString(),
+                message: `Conversation scheduled to explode at ${expiresAt.toISOString()}. All members have been notified.`,
+            });
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import { ConvosBaseCommand } from "../../baseCommand.js";
+export default class ConversationInfo 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/conversation/info.js

@@ -0,0 +1,79 @@
+import { Args } from "@oclif/core";
+import { getAccountAddress, isGroup, 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 ConversationInfo extends ConvosBaseCommand {
+    static description = `Get detailed information about a conversation.
+
+Resolves the per-conversation identity and shows full details
+including members, permissions, metadata, and identity info.`;
+    static examples = [
+        {
+            command: "<%= config.bin %> <%= command.id %> <conversation-id>",
+            description: "Get conversation details",
+        },
+    ];
+    static args = {
+        id: Args.string({ description: "The conversation ID", required: true }),
+    };
+    static flags = {
+        ...ConvosBaseCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(ConversationInfo);
+        const config = this.getConvosConfig();
+        const store = createIdentityStore();
+        const identity = store.getByConversationId(args.id);
+        if (!identity) {
+            this.error(`No identity found for conversation: ${args.id}`);
+        }
+        const client = await createClientForIdentity(identity, config);
+        const conversation = await client.conversations.getConversationById(args.id);
+        if (!conversation) {
+            this.error(`Conversation not found on network: ${args.id}`);
+        }
+        const metadata = await conversation.metadata();
+        const members = await conversation.members();
+        const convData = {
+            id: conversation.id,
+            createdAt: conversation.createdAt.toISOString(),
+            consentState: conversation.consentState(),
+            isActive: conversation.isActive,
+            creatorInboxId: metadata.creatorInboxId,
+            memberCount: members.length,
+        };
+        if (isGroup(conversation)) {
+            convData.name = conversation.name;
+            convData.description = conversation.description;
+            convData.imageUrl = conversation.imageUrl;
+        }
+        const identityData = {
+            identityId: identity.id,
+            address: getAccountAddress(identity.walletKey),
+            inboxId: client.inboxId,
+            label: identity.label ?? "",
+            profileName: identity.profileName ?? "",
+        };
+        const memberList = members.map((m) => ({
+            inboxId: m.inboxId,
+            accountIdentifiers: m.accountIdentifiers,
+            permissionLevel: m.permissionLevel,
+        }));
+        if (this.jsonOutput) {
+            this.output({
+                conversation: convData,
+                identity: identityData,
+                members: memberList,
+            });
+        }
+        else {
+            this.log(formatSections([
+                { title: "Conversation", data: convData },
+                { title: "Identity", data: identityData },
+            ], 2));
+            this.log("\nMembers\n");
+            this.output(memberList);
+        }
+    }
+}

package/dist/commands/conversation/invite.d.ts

@@ -0,0 +1,26 @@
+import { ConvosBaseCommand } from "../../baseCommand.js";
+export default class ConversationInvite 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: {
+        qr: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "expires-in": import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "single-use": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "include-metadata": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "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>;
+}