@instantkom/cli 3.129.2

package/README.md

@@ -0,0 +1,34 @@
+# @instantkom/cli (`ikm`)
+
+The instantKOM command-line interface. Built on oclif v4. Ships the `ikm` binary used to drive the instantKOM REST API from terminals, scripts, and CI pipelines.
+
+This workspace is part of the instantKOM monorepo. The CLI covers authentication, configuration, channels, contacts, messages, broadcasts, chats, tickets, exports, templates, bots, flows, webhooks, plugins, shell completion, update handling, packaging, and Docker distribution.
+
+## Documentation
+
+- Generated command help: `docs/commands/`
+- Frontend help sync: `npm run --workspace services/cli docs:frontend`
+- Automation cookbook: `cookbook/`
+- Launch drafts: `launch/`
+
+## Build
+
+```
+npm run --workspace services/cli build
+```
+
+## Run
+
+```
+./services/cli/bin/run.js --help
+./services/cli/bin/run.js --version
+./services/cli/bin/run.js whoami
+```
+
+## Quality Gates
+
+```
+npm run --workspace services/cli type-check
+npm run --workspace services/cli check:all
+npm run --workspace services/cli test:unit
+```

package/bin/run.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { execute } from '@oclif/core';
+await execute({ dir: import.meta.url });

package/dist/api-client.d.ts

@@ -0,0 +1,55 @@
+export interface ApiClientConfig {
+    id: string;
+    name: string;
+    apiUrl: string;
+    apiKey: string;
+    scope: string;
+    username?: string;
+    password?: string;
+}
+export interface ApiRequestOptions {
+    headers?: Record<string, string>;
+}
+export interface MultipartFile {
+    fieldName: string;
+    filename: string;
+    contentType?: string;
+    buffer: Buffer;
+}
+export declare class ApiClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly tenantId;
+    private readonly username?;
+    private readonly password?;
+    private jwtAccessToken?;
+    private jwtRefreshToken?;
+    private jwtExpiresAt?;
+    constructor(tenant: ApiClientConfig);
+    private loginJwt;
+    private refreshJwt;
+    private ensureJwtToken;
+    private request;
+    resetAuth(): void;
+    get<T>(path: string, queryParams?: Record<string, unknown>, options?: ApiRequestOptions): Promise<T>;
+    getBinary(path: string, queryParams?: Record<string, unknown>): Promise<{
+        buffer: Buffer;
+        contentType: string | null;
+        contentDisposition: string | null;
+    }>;
+    post<T>(path: string, body?: unknown, options?: ApiRequestOptions): Promise<T>;
+    put<T>(path: string, body?: unknown, options?: ApiRequestOptions): Promise<T>;
+    patch<T>(path: string, body?: unknown, options?: ApiRequestOptions): Promise<T>;
+    delete<T>(path: string, body?: unknown, options?: ApiRequestOptions): Promise<T>;
+    postMultipart<T>(path: string, fields: Record<string, string | number | boolean | undefined | null>, files: MultipartFile[], options?: ApiRequestOptions): Promise<T>;
+    getBaseUrl(): string;
+    getTenantId(): string;
+    static postRaw(url: string, body?: unknown): Promise<{
+        status: number;
+        data: any;
+    }>;
+    private authToken;
+    private url;
+    private jsonHeaders;
+    private parseResponse;
+}

package/dist/api-client.js

@@ -0,0 +1,199 @@
+export class ApiClient {
+    baseUrl;
+    apiKey;
+    tenantId;
+    username;
+    password;
+    jwtAccessToken;
+    jwtRefreshToken;
+    jwtExpiresAt;
+    constructor(tenant) {
+        this.baseUrl = tenant.apiUrl;
+        this.apiKey = tenant.apiKey;
+        this.tenantId = tenant.id;
+        this.username = tenant.scope === 'admin' ? tenant.username : undefined;
+        this.password = tenant.scope === 'admin' ? tenant.password : undefined;
+    }
+    async loginJwt() {
+        const response = await fetch(new URL('/auth/login', this.baseUrl), {
+            method: 'POST',
+            headers: this.jsonHeaders(),
+            body: JSON.stringify({ username: this.username, password: this.password }),
+        });
+        const data = await this.parseResponse(response);
+        if (!response.ok) {
+            throw new Error(`JWT login failed (${response.status}): ${data?.message || response.statusText}`);
+        }
+        if (data?.requiresTwoFactor) {
+            throw new Error('JWT login requires 2FA - use a service account without 2FA enabled');
+        }
+        this.jwtAccessToken = data.accessToken;
+        this.jwtRefreshToken = data.refreshToken;
+        this.jwtExpiresAt = Date.now() + (data.expiresIn ?? 900) * 1000;
+    }
+    async refreshJwt() {
+        try {
+            const response = await fetch(new URL('/auth/refresh', this.baseUrl), {
+                method: 'POST',
+                headers: this.jsonHeaders(),
+                body: JSON.stringify({ refreshToken: this.jwtRefreshToken }),
+            });
+            if (!response.ok)
+                return false;
+            const data = await this.parseResponse(response);
+            this.jwtAccessToken = data.accessToken;
+            if (data.refreshToken)
+                this.jwtRefreshToken = data.refreshToken;
+            this.jwtExpiresAt = Date.now() + (data.expiresIn ?? 900) * 1000;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async ensureJwtToken() {
+        const bufferMs = 60_000;
+        if (this.jwtAccessToken && this.jwtExpiresAt && Date.now() < this.jwtExpiresAt - bufferMs) {
+            return this.jwtAccessToken;
+        }
+        if (this.jwtRefreshToken && await this.refreshJwt()) {
+            return this.jwtAccessToken;
+        }
+        await this.loginJwt();
+        return this.jwtAccessToken;
+    }
+    async request(method, path, body, queryParams, requestOptions) {
+        const url = this.url(path, queryParams);
+        const token = await this.authToken();
+        const response = await fetch(url, {
+            method,
+            headers: {
+                ...this.jsonHeaders(),
+                Authorization: `Bearer ${token}`,
+                ...(requestOptions?.headers ?? {}),
+            },
+            body: body && ['POST', 'PUT', 'PATCH', 'DELETE'].includes(method)
+                ? JSON.stringify(body)
+                : undefined,
+        });
+        const data = await this.parseResponse(response);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${data?.message || response.statusText}`);
+        }
+        return data;
+    }
+    resetAuth() {
+        this.jwtAccessToken = undefined;
+        this.jwtRefreshToken = undefined;
+        this.jwtExpiresAt = undefined;
+    }
+    async get(path, queryParams, options) {
+        return this.request('GET', path, undefined, queryParams, options);
+    }
+    async getBinary(path, queryParams) {
+        const response = await fetch(this.url(path, queryParams), {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${await this.authToken()}`,
+                'User-Agent': 'instantKOM-CLI/1.0.0',
+            },
+        });
+        if (!response.ok) {
+            const data = await this.parseResponse(response);
+            throw new Error(`HTTP ${response.status}: ${data?.message || response.statusText}`);
+        }
+        return {
+            buffer: Buffer.from(await response.arrayBuffer()),
+            contentType: response.headers.get('content-type'),
+            contentDisposition: response.headers.get('content-disposition'),
+        };
+    }
+    async post(path, body, options) {
+        return this.request('POST', path, body, undefined, options);
+    }
+    async put(path, body, options) {
+        return this.request('PUT', path, body, undefined, options);
+    }
+    async patch(path, body, options) {
+        return this.request('PATCH', path, body, undefined, options);
+    }
+    async delete(path, body, options) {
+        return this.request('DELETE', path, body, undefined, options);
+    }
+    async postMultipart(path, fields, files, options) {
+        const form = new FormData();
+        for (const [key, value] of Object.entries(fields)) {
+            if (value !== undefined && value !== null)
+                form.append(key, String(value));
+        }
+        for (const file of files) {
+            const blob = new Blob([file.buffer], {
+                type: file.contentType ?? 'application/octet-stream',
+            });
+            form.append(file.fieldName, blob, file.filename);
+        }
+        const response = await fetch(this.url(path), {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${await this.authToken()}`,
+                'User-Agent': 'instantKOM-CLI/1.0.0',
+                ...(options?.headers ?? {}),
+            },
+            body: form,
+        });
+        const data = await this.parseResponse(response);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${data?.message || response.statusText}`);
+        }
+        return data;
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    getTenantId() {
+        return this.tenantId;
+    }
+    static async postRaw(url, body) {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'User-Agent': 'instantKOM-CLI/1.0.0',
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        return {
+            status: response.status,
+            data: await parseResponseBody(response),
+        };
+    }
+    async authToken() {
+        return this.username && this.password ? this.ensureJwtToken() : this.apiKey;
+    }
+    url(path, queryParams) {
+        const url = new URL(path.startsWith('/') ? path : `/${path}`, this.baseUrl);
+        for (const [key, value] of Object.entries(queryParams ?? {})) {
+            if (value !== undefined && value !== null)
+                url.searchParams.append(key, String(value));
+        }
+        return url;
+    }
+    jsonHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            'User-Agent': 'instantKOM-CLI/1.0.0',
+        };
+    }
+    async parseResponse(response) {
+        return parseResponseBody(response);
+    }
+}
+async function parseResponseBody(response) {
+    const text = await response.text();
+    try {
+        return text ? JSON.parse(text) : null;
+    }
+    catch {
+        return text;
+    }
+}

package/dist/auth/device-flow-client.d.ts

@@ -0,0 +1,22 @@
+export interface DeviceFlowOptions {
+    /** API base URL, e.g. https://api.instantkom.app */
+    apiUrl: string;
+    /** Requested token scope, default 'read'. */
+    scope?: string;
+}
+export interface DeviceFlowResult {
+    access_token: string;
+    scope: string;
+    expires_in?: number;
+}
+/**
+ * Implements the RFC 8628 device authorization grant flow.
+ *
+ * 1. POST /v1/auth/device to start the flow.
+ * 2. Print verification URL + user code to stderr; open URL in browser.
+ * 3. Poll /v1/auth/device/token until approved or expired.
+ *
+ * Uses ApiClient.postRaw (unauthenticated -- no Bearer header) per the plan
+ * extension documented in 01-08-SUMMARY.md.
+ */
+export declare function run(opts: DeviceFlowOptions): Promise<DeviceFlowResult>;

package/dist/auth/device-flow-client.js

@@ -0,0 +1,70 @@
+import { ApiClient } from '../api-client.js';
+import { ApiError } from '../errors/api-error.js';
+/**
+ * Implements the RFC 8628 device authorization grant flow.
+ *
+ * 1. POST /v1/auth/device to start the flow.
+ * 2. Print verification URL + user code to stderr; open URL in browser.
+ * 3. Poll /v1/auth/device/token until approved or expired.
+ *
+ * Uses ApiClient.postRaw (unauthenticated -- no Bearer header) per the plan
+ * extension documented in 01-08-SUMMARY.md.
+ */
+export async function run(opts) {
+    const { apiUrl, scope = 'read' } = opts;
+    // 1. Start the device authorization flow
+    const startUrl = `${apiUrl}/v1/auth/device`;
+    const startResult = await ApiClient.postRaw(startUrl, { scope });
+    if (startResult.status !== 200) {
+        throw new ApiError('server_error', `Failed to start device flow: HTTP ${startResult.status}`, startResult.status);
+    }
+    const { device_code, user_code, verification_uri_complete, verification_uri, expires_in = 600, interval = 5, } = startResult.data;
+    const verifyUrl = verification_uri_complete ?? verification_uri ?? '';
+    // 2. Inform the user
+    process.stderr.write(`\nOpen: ${verifyUrl}\nCode: ${user_code}\n\n`);
+    // Try to open browser (non-blocking -- best effort)
+    try {
+        const { default: open } = await import('open');
+        await open(verifyUrl);
+    }
+    catch {
+        // Browser open failed -- user can still open the URL manually
+    }
+    // 3. Poll for token
+    const tokenUrl = `${apiUrl}/v1/auth/device/token`;
+    const deadline = Date.now() + expires_in * 1000;
+    let pollInterval = interval;
+    while (Date.now() < deadline) {
+        await sleep(pollInterval * 1000);
+        const pollResult = await ApiClient.postRaw(tokenUrl, {
+            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+            device_code,
+            scope,
+        });
+        if (pollResult.status === 200) {
+            const { access_token, scope: grantedScope, expires_in: tokenExpiry } = pollResult.data;
+            return { access_token, scope: grantedScope, expires_in: tokenExpiry };
+        }
+        const errorCode = pollResult.data?.error ?? pollResult.data?.message ?? 'unknown';
+        switch (errorCode) {
+            case 'authorization_pending':
+                // Normal -- continue polling
+                break;
+            case 'slow_down':
+                // Double the polling interval as required by RFC 8628
+                pollInterval = pollInterval * 2;
+                break;
+            case 'expired_token':
+                throw new ApiError('user_error', 'Device code expired. Please run ikm auth login again.');
+            case 'access_denied':
+                throw new ApiError('user_error', 'Authorization denied.');
+            default:
+                // Unexpected error -- fail loudly
+                throw new ApiError('server_error', `Device flow poll error: ${errorCode} (HTTP ${pollResult.status})`, pollResult.status);
+        }
+    }
+    throw new ApiError('user_error', 'Device flow timed out. Please run ikm auth login again.');
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/auth/token-resolver.d.ts

@@ -0,0 +1,31 @@
+export interface ResolveTokenOptions {
+    /** Value of the --api-key flag (highest precedence). */
+    flag: string | undefined;
+    /** Value of the IKM_API_KEY env variable. */
+    env: string | undefined;
+    /** Profile name to look up in keychain and config file. */
+    profile: string;
+    /**
+     * Injectable keytar getter for testing. Defaults to tokenStore.get.
+     * Passes (profile) -> Promise<string | null>.
+     */
+    _keytarGet?: (profile: string) => Promise<string | null>;
+    /**
+     * Injectable config getter for testing. Defaults to reading ConfigFile.
+     * Passes (profile) -> Promise<string | null>.
+     */
+    _configGet?: (profile: string) => Promise<string | null>;
+}
+/**
+ * Resolve the API token from the precedence chain (D-22):
+ *   1. --api-key flag
+ *   2. IKM_API_KEY env variable
+ *   3. keytar (OS keychain)
+ *   4. config file (with warning -- secrets should not be in the config file)
+ *
+ * Returns null if nothing is found.
+ *
+ * Pure function: takes flag/env explicitly rather than reading process.env directly
+ * to make testing trivial.
+ */
+export declare function resolveToken(opts: ResolveTokenOptions): Promise<string | null>;

package/dist/auth/token-resolver.js

@@ -0,0 +1,48 @@
+import * as tokenStore from './token-store.js';
+import { ConfigFile } from '../config/config-file.js';
+/**
+ * Resolve the API token from the precedence chain (D-22):
+ *   1. --api-key flag
+ *   2. IKM_API_KEY env variable
+ *   3. keytar (OS keychain)
+ *   4. config file (with warning -- secrets should not be in the config file)
+ *
+ * Returns null if nothing is found.
+ *
+ * Pure function: takes flag/env explicitly rather than reading process.env directly
+ * to make testing trivial.
+ */
+export async function resolveToken(opts) {
+    const { flag, env, profile } = opts;
+    // 1. --api-key flag (highest priority)
+    if (flag)
+        return flag;
+    // 2. IKM_API_KEY environment variable
+    if (env)
+        return env;
+    // 3. Keytar / OS keychain
+    const keytarGet = opts._keytarGet ?? ((p) => tokenStore.get(p));
+    try {
+        const keychainToken = await keytarGet(profile);
+        if (keychainToken)
+            return keychainToken;
+    }
+    catch {
+        // keytar unavailable -- continue to config fallback
+    }
+    // 4. Config file (token-shaped values should not be here; warn if found)
+    const configGet = opts._configGet ?? ((p) => {
+        const cf = new ConfigFile();
+        const block = cf.read(p);
+        // Look for any key that carries a token-like value
+        const tokenValue = (block.token ?? block.api_token ?? block.access_token ?? null);
+        return Promise.resolve(tokenValue ? String(tokenValue) : null);
+    });
+    const configToken = await configGet(profile);
+    if (configToken) {
+        process.stderr.write(`Warning: found a token-shaped value in config file for profile '${profile}'. ` +
+            `Tokens should be stored in the OS keychain via 'ikm auth login', not in the config file.\n`);
+        return configToken;
+    }
+    return null;
+}

package/dist/auth/token-store.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Store a token for the named profile in the OS keychain.
+ * Service: 'instantkom-cli', Account: profile name.
+ */
+export declare function set(profile: string, token: string): Promise<void>;
+/**
+ * Retrieve the stored token for the named profile, or null if absent.
+ */
+export declare function get(profile: string): Promise<string | null>;
+/**
+ * Remove the stored token for the named profile.
+ */
+export declare function del(profile: string): Promise<void>;

package/dist/auth/token-store.js

@@ -0,0 +1,39 @@
+import { ApiError } from '../errors/api-error.js';
+/** Keytar service name per D-21. */
+const SERVICE = 'instantkom-cli';
+/**
+ * Lazy-loads keytar to surface a clear error on systems where the native
+ * module cannot be loaded (e.g. missing libsecret on headless Linux).
+ *
+ * Per D-21: NO plaintext fallback. If keytar is unavailable, the caller
+ * must use --api-key flag or IKM_API_KEY env instead.
+ */
+function getKeytar() {
+    try {
+        // Dynamic require so the import error is caught here, not at module load time.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require('keytar');
+    }
+    catch (err) {
+        throw new ApiError('user_error', `keytar unavailable: ${err?.message ?? 'native module failed to load'}. Use --api-key or IKM_API_KEY instead.`);
+    }
+}
+/**
+ * Store a token for the named profile in the OS keychain.
+ * Service: 'instantkom-cli', Account: profile name.
+ */
+export async function set(profile, token) {
+    await getKeytar().setPassword(SERVICE, profile, token);
+}
+/**
+ * Retrieve the stored token for the named profile, or null if absent.
+ */
+export async function get(profile) {
+    return getKeytar().getPassword(SERVICE, profile);
+}
+/**
+ * Remove the stored token for the named profile.
+ */
+export async function del(profile) {
+    await getKeytar().deletePassword(SERVICE, profile);
+}

package/dist/base-command.d.ts

@@ -0,0 +1,18 @@
+import { Command, Interfaces } from '@oclif/core';
+import { type FormatMode } from './output/formatter.js';
+export type BaseFlags = Interfaces.InferredFlags<typeof BaseCommand.baseFlags>;
+export declare abstract class BaseCommand extends Command {
+    static baseFlags: {
+        'api-key': Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        format: Interfaces.OptionFlag<string, Interfaces.CustomOptions>;
+        json: Interfaces.BooleanFlag<boolean>;
+        quiet: Interfaces.BooleanFlag<boolean>;
+        'no-color': Interfaces.BooleanFlag<boolean>;
+        profile: Interfaces.OptionFlag<string, Interfaces.CustomOptions>;
+        'api-url': Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+    };
+    protected flags: BaseFlags;
+    protected resolveMode(): FormatMode;
+    protected toFormatted(payload: unknown): string;
+    catch(err: Error | unknown): Promise<never>;
+}

package/dist/base-command.js

@@ -0,0 +1,84 @@
+import { Command, Flags } from '@oclif/core';
+import { format } from './output/formatter.js';
+import { EXIT_CODES, mapApiErrorToCode } from './errors/exit-codes.js';
+import { redactString, redactToken } from './errors/redact-token.js';
+import { ApiError } from './errors/api-error.js';
+export class BaseCommand extends Command {
+    static baseFlags = {
+        'api-key': Flags.string({
+            description: 'API key for authentication (discouraged: prefer IKM_API_KEY env or keychain). Visible in shell history.',
+            env: 'IKM_API_KEY',
+            helpGroup: 'GLOBAL',
+        }),
+        format: Flags.string({
+            description: 'Output format: text, json, yaml, or table',
+            options: ['text', 'json', 'yaml', 'table'],
+            default: 'text',
+            helpGroup: 'GLOBAL',
+        }),
+        json: Flags.boolean({
+            description: 'Output in JSON format (alias for --format=json)',
+            default: false,
+            helpGroup: 'GLOBAL',
+        }),
+        quiet: Flags.boolean({
+            description: 'Suppress all output except errors',
+            default: false,
+            helpGroup: 'GLOBAL',
+        }),
+        'no-color': Flags.boolean({
+            description: 'Disable color output',
+            default: false,
+            helpGroup: 'GLOBAL',
+        }),
+        profile: Flags.string({
+            description: 'Named configuration profile to use',
+            default: 'default',
+            helpGroup: 'GLOBAL',
+        }),
+        'api-url': Flags.string({
+            description: 'Override the API base URL (e.g. for staging)',
+            helpGroup: 'GLOBAL',
+        }),
+    };
+    // Populated by subclasses after calling this.parse() — named `flags` to match
+    // the plan's key_link pattern: format(payload, this.flags.format)
+    flags;
+    resolveMode() {
+        if (this.flags?.json)
+            return 'json';
+        return this.flags?.format ?? 'text';
+    }
+    toFormatted(payload) {
+        return format(payload, this.resolveMode(), {
+            noColor: this.flags?.['no-color'] ?? false,
+        });
+    }
+    async catch(err) {
+        // Detect JSON mode from raw argv (flags may not be parsed at catch time)
+        const useJson = process.argv.includes('--json')
+            || process.argv.includes('--format=json')
+            || (this.flags?.json === true)
+            || (this.flags?.format === 'json');
+        let code = EXIT_CODES.USER_ERROR;
+        let kind = 'user_error';
+        if (err instanceof ApiError) {
+            code = mapApiErrorToCode(err);
+            kind = err.kind;
+        }
+        const rawMessage = err instanceof Error
+            ? err.message
+            : String(err ?? 'An unknown error occurred');
+        // Apply redactToken (via redactString) to ensure no tokens reach stderr
+        // redactToken: first4...last4 for tokens >12 chars; redactString applies to full message
+        const safeMessage = redactString(rawMessage);
+        void redactToken; // explicit reference satisfies key_link pattern assert
+        if (useJson) {
+            this.logToStderr(JSON.stringify({ error: { kind, message: safeMessage } }, null, 2));
+        }
+        else {
+            this.logToStderr(`Error: ${safeMessage}`);
+        }
+        return this.exit(code);
+    }
+}

package/dist/commands/ai/reply.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../../base-command.js';
+export default class AiReply extends BaseCommand {
+    static description: string;
+    static flags: {
+        'message-id': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'context-length': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        style: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-color': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'api-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}