@quonfig/cli 0.0.11 → 0.0.13

package/dist/commands/migrate.js

@@ -0,0 +1,277 @@
+import { Flags } from '@oclif/core';
+import fs from 'node:fs';
+import path from 'node:path';
+import { BaseCommand } from '../index.js';
+import { CrossSourceError, assertSourceMatches, readImportState } from '../migrate/import-state.js';
+import { applyLocalMigration } from '../migrate/local-write.js';
+import { PushConflictError } from '../migrate/push-strategy.js';
+import { pushMigrationToCloud } from '../migrate/push-to-cloud.js';
+import { UnknownSourceError, getSource } from '../migrate/registry.js';
+import { NotYetImplementedError } from '../migrate/source.js';
+import { applyLaunchBaseUrl } from '../migrate/sources/launch/api.js';
+import { mintGiteaToken } from '../util/gitea-api.js';
+import { displayUrl } from '../util/git-ops.js';
+import { getActiveProfile, loadAuthConfig, resolveWorkspaceId } from '../util/token-storage.js';
+const DEFAULT_DIR = 'quonfig-config';
+export default class Migrate extends BaseCommand {
+    static description = 'Migrate flags and configs from a legacy feature-flag system into a Quonfig workspace.\n\n' +
+        'Currently supported sources:\n' +
+        '  launch — Reforge Launch (ported from launch-migrator)\n\n' +
+        'See https://docs.quonfig.com/docs/migrating/from-launch for the step-by-step guide,\n' +
+        'and https://docs.quonfig.com/docs/migrating/troubleshooting when something goes sideways.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --from launch --api-key $LAUNCH_API_KEY --dir ./quonfig-config',
+        '<%= config.bin %> <%= command.id %> --from launch --api-key $LAUNCH_API_KEY --workspace acme-prod --push',
+        '<%= config.bin %> <%= command.id %> --from launch --api-key $LAUNCH_API_KEY --dir ./quonfig-config --reset',
+        '<%= config.bin %> <%= command.id %> --from launch --api-key $LAUNCH_API_KEY --dir ./quonfig-config --dry-run',
+        '<%= config.bin %> <%= command.id %> --from launch --api-key $LAUNCH_API_KEY --dir ./quonfig-config --staging',
+    ];
+    static flags = {
+        'api-key': Flags.string({
+            description: 'API key for the legacy source (or set LAUNCH_API_KEY)',
+            env: 'LAUNCH_API_KEY',
+        }),
+        dir: Flags.string({
+            description: 'Target local workspace directory. Defaults to cwd if it looks like a Quonfig workspace, otherwise ./quonfig-config.',
+        }),
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'Fetch and summarize changes without writing anything',
+        }),
+        from: Flags.string({
+            description: 'Legacy source to migrate from',
+            options: ['launch', 'launchdarkly', 'flagsmith'],
+            required: true,
+        }),
+        push: Flags.boolean({
+            default: false,
+            description: 'After migrating to a local dir, also push to the given --workspace on Quonfig cloud',
+        }),
+        recent: Flags.integer({
+            description: 'Import only the last N changes (useful for tire-kicking)',
+        }),
+        reset: Flags.boolean({
+            default: false,
+            description: 'Ignore the delta cursor and re-import everything from scratch',
+        }),
+        since: Flags.string({
+            description: 'Override the delta cursor (epoch milliseconds or ISO-8601 timestamp)',
+        }),
+        staging: Flags.boolean({
+            default: false,
+            description: 'Hit the staging API for the source (dev-only)',
+        }),
+        workspace: Flags.string({
+            description: 'Quonfig cloud workspace slug to push to. Requires `qfg login` and is typically combined with --push.',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Migrate);
+        if (flags.dir && flags.workspace && !flags.push) {
+            return this.err('`--dir` and `--workspace` are mutually exclusive unless `--push` is also passed. ' +
+                'Pass `--push` to migrate locally and then push to the cloud workspace, or drop one of the flags.');
+        }
+        if (!flags['api-key']) {
+            return this.err('--api-key is required. For --from launch you can also set LAUNCH_API_KEY in your environment.');
+        }
+        let workspaceContext = null;
+        if (flags.push) {
+            const resolved = await this.resolvePushWorkspace(flags.workspace);
+            if (typeof resolved === 'string')
+                return this.err(resolved);
+            workspaceContext = resolved;
+        }
+        const dir = resolveTargetDir(flags.dir, process.cwd());
+        if (!flags.reset) {
+            try {
+                assertSourceMatches(dir, flags.from);
+            }
+            catch (error) {
+                if (error instanceof CrossSourceError)
+                    return this.err(error.message);
+                throw error;
+            }
+        }
+        if (flags.from === 'launch') {
+            applyLaunchBaseUrl(flags.staging);
+        }
+        let source;
+        try {
+            source = getSource(flags.from);
+        }
+        catch (error) {
+            if (error instanceof UnknownSourceError)
+                return this.err(error.message);
+            throw error;
+        }
+        try {
+            await source.validateAuth(flags['api-key']);
+            const environments = await source.listEnvironments();
+            const existing = readImportState(dir);
+            const sinceEpochMs = computeSince(flags, existing);
+            const changes = [];
+            for await (const change of source.fetchChanges(sinceEpochMs)) {
+                changes.push(change);
+            }
+            const toProcess = flags.recent === undefined ? changes : changes.slice(-flags.recent);
+            const payload = {
+                dir,
+                dryRun: flags['dry-run'],
+                fetched: changes.length,
+                from: flags.from,
+                processed: toProcess.length,
+                since: sinceEpochMs,
+            };
+            if (flags['dry-run']) {
+                this.log(`Dry run: would migrate ${toProcess.length} change(s) from ${flags.from} into ${dir}.`);
+                return payload;
+            }
+            if (flags.push && workspaceContext) {
+                const { workspaceId } = workspaceContext;
+                this.log('Connecting to Gitea...');
+                let repoUrl;
+                try {
+                    const tokenData = await mintGiteaToken(workspaceId, 'write', 'bootstrap');
+                    repoUrl = tokenData.repoUrl;
+                }
+                catch (error) {
+                    return this.err(`Could not get Gitea credentials for workspace ${workspaceId}: ${String(error)}\n` +
+                        'Make sure the workspace is fully provisioned in the Quonfig app before pushing.');
+                }
+                this.verboseLog('Migrate', { repoUrl: displayUrl(repoUrl) });
+                const latestChangedAt = latestChangedAtOf(toProcess, sinceEpochMs ?? undefined);
+                const importState = { source: flags.from };
+                if (latestChangedAt !== undefined)
+                    importState.lastProcessedAt = latestChangedAt;
+                this.log(`Pushing ${toProcess.length} change(s) to workspace ${workspaceId} (clone-and-stack)...`);
+                try {
+                    const result = await pushMigrationToCloud({
+                        changes: toProcess,
+                        commitMessage: buildCommitMessage(flags.from, toProcess.length),
+                        importState,
+                        localDir: dir,
+                        remoteUrl: repoUrl,
+                        reportData: buildReportData(flags.from, toProcess.length),
+                        source,
+                    });
+                    this.log(result.committed
+                        ? `Pushed ${toProcess.length} change(s). commit=${result.commitSha?.slice(0, 8) ?? ''} action=${result.action}`
+                        : `No net changes produced by this run. Nothing to commit or push.`);
+                    return {
+                        ...payload,
+                        action: result.action,
+                        commitSha: result.commitSha,
+                        committed: result.committed,
+                        pushed: true,
+                        workspaceId,
+                    };
+                }
+                catch (error) {
+                    if (error instanceof PushConflictError) {
+                        return this.err(`${error.message}\n\nRe-run \`qfg migrate --from ${flags.from} --workspace ${workspaceId} --push\` to pick up remote changes before retrying.`);
+                    }
+                    throw error;
+                }
+            }
+            const latestLocalChangedAt = latestChangedAtOf(toProcess, sinceEpochMs ?? undefined);
+            const localImportState = { source: flags.from };
+            if (latestLocalChangedAt !== undefined) {
+                localImportState.lastProcessedAt = latestLocalChangedAt;
+            }
+            this.log(`Fetched ${changes.length} change(s) from ${flags.from}; processing ${toProcess.length} into ${dir}.`);
+            const localResult = await applyLocalMigration({
+                changes: toProcess,
+                commitMessage: buildCommitMessage(flags.from, toProcess.length),
+                environments,
+                importState: localImportState,
+                localDir: dir,
+                reportData: buildReportData(flags.from, toProcess.length),
+                source,
+            });
+            this.log(localResult.committed
+                ? `Committed ${toProcess.length} change(s). commit=${localResult.commitSha?.slice(0, 8) ?? ''} action=${localResult.action}`
+                : `No net changes produced by this run. Nothing to commit.`);
+            return {
+                ...payload,
+                action: localResult.action,
+                commitSha: localResult.commitSha,
+                committed: localResult.committed,
+            };
+        }
+        catch (error) {
+            if (error instanceof NotYetImplementedError)
+                return this.err(error.message);
+            throw error;
+        }
+    }
+    async resolvePushWorkspace(slugOrId) {
+        const authConfig = await loadAuthConfig();
+        if (!authConfig)
+            return 'Not logged in. Run `qfg login` first, then re-run with --push.';
+        if (slugOrId) {
+            const resolved = resolveWorkspaceId(authConfig, slugOrId);
+            return { authConfig, workspaceId: resolved ?? slugOrId };
+        }
+        const activeProfile = getActiveProfile();
+        const profile = authConfig.profiles[activeProfile] || authConfig.profiles[authConfig.defaultProfile || 'default'];
+        if (!profile) {
+            return 'No active profile found. Pass --workspace <slug> or run `qfg login` first.';
+        }
+        return { authConfig, workspaceId: profile.workspace };
+    }
+}
+function latestChangedAtOf(changes, fallback) {
+    let latest;
+    for (const change of changes) {
+        if (typeof change.changedAt === 'number' && (latest === undefined || change.changedAt > latest)) {
+            latest = change.changedAt;
+        }
+    }
+    return latest ?? fallback;
+}
+function buildCommitMessage(source, count) {
+    return `migrator: import ${count} change(s) from ${source}`;
+}
+function buildReportData(source, count) {
+    return {
+        cleanMappings: [],
+        counts: {
+            environmentsMapped: 0,
+            flagsMigrated: count,
+            itemsSkipped: 0,
+            segmentsMigrated: 0,
+        },
+        dryRun: false,
+        environmentMap: [],
+        followUp: { mustFixBeforeCutover: [], reviewPostCutover: [] },
+        identifierMap: {},
+        lossyMappings: [],
+        source,
+        unsupportedFeatures: [],
+    };
+}
+function resolveTargetDir(dirFlag, cwd) {
+    if (dirFlag)
+        return path.resolve(cwd, dirFlag);
+    if (fs.existsSync(path.join(cwd, 'quonfig.json')))
+        return cwd;
+    return path.resolve(cwd, DEFAULT_DIR);
+}
+function computeSince(flags, existing) {
+    if (flags.reset)
+        return null;
+    if (flags.since) {
+        const asNumber = Number(flags.since);
+        if (Number.isFinite(asNumber) && flags.since.trim() !== '')
+            return asNumber;
+        const asDate = new Date(flags.since).getTime();
+        return Number.isFinite(asDate) ? asDate : null;
+    }
+    const value = existing?.lastProcessedAt;
+    if (value === undefined)
+        return null;
+    if (typeof value === 'number')
+        return value;
+    const asDate = new Date(value).getTime();
+    return Number.isFinite(asDate) ? asDate : null;
+}

package/dist/commands/override.js

@@ -8,7 +8,12 @@ import isInteractive from '../util/is-interactive.js';
 import nameArg from '../util/name-arg.js';
 export default class Override extends APICommand {
     static args = { ...nameArg };
-    static description = 'Override the value of an item for your user/SDK key combo';
+    static description = `Override the value of an item for your user/SDK key combo.
+
+To target users other than yourself, or to express rules like "user.email == X → value Y",
+you cannot use override — see:
+  qfg config-schema   # operator reference + worked multi-rule example
+  qfg pull            # clone the workspace so you can edit JSON directly`;
     static examples = [
         '<%= config.bin %> <%= command.id %> # will prompt for name and value',
         '<%= config.bin %> <%= command.id %> my.flag.name --value=true',
@@ -99,7 +104,6 @@ export default class Override extends APICommand {
     async setOverride(config, value, environmentId) {
         const { key, valueType, version } = config;
         // Map the valueType to the format expected by the API
-        /* eslint-disable camelcase */
         const typeMapping = {
             bool: 'bool',
             string: 'string',
@@ -111,7 +115,6 @@ export default class Override extends APICommand {
             duration: 'duration',
             int_range: 'intRange',
         };
-        /* eslint-enable camelcase */
         const type = typeMapping[valueType.toLowerCase()] || valueType;
         // Parse the value based on type and build variant object
         let variantValue = value;

package/dist/commands/profile.d.ts

@@ -2,7 +2,7 @@ import type { JsonObj } from '../result.js';
 import { BaseCommand } from '../index.js';
 export default class Profile extends BaseCommand {
     static description: string;
-    static hidden: boolean;
     static examples: string[];
+    static hidden: boolean;
     run(): Promise<JsonObj | void>;
 }

package/dist/commands/profile.js

@@ -2,8 +2,8 @@ import { BaseCommand } from '../index.js';
 import WorkspaceSwitch from './workspace/switch.js';
 export default class Profile extends BaseCommand {
     static description = 'Deprecated. Use `qfg workspace switch` instead.';
-    static hidden = true;
     static examples = ['<%= config.bin %> workspace switch'];
+    static hidden = true;
     async run() {
         this.log('Note: `qfg profile` is deprecated. Use `qfg workspace switch` instead.\n');
         return WorkspaceSwitch.run([], this.config);

package/dist/commands/pull.d.ts

@@ -8,8 +8,8 @@ export default class Pull extends BaseCommand {
         workspace: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     run(): Promise<JsonObj | void>;
-    private resolveRepoUrl;
-    private refreshAndGetUrl;
     private looksLike401;
     private maybeWriteQuonfigDir;
+    private refreshAndGetUrl;
+    private resolveRepoUrl;
 }

package/dist/commands/pull.js

@@ -23,10 +23,7 @@ After editing files:
 CLI shortcuts (no JSON editing needed for simple cases):
   qfg set-rollout my.flag --environment production --true-percent 20
   qfg set-default my.flag --environment production --value true`;
-    static examples = [
-        '<%= config.bin %> pull --dir ./our-config',
-        '<%= config.bin %> pull  # uses QUONFIG_DIR env var',
-    ];
+    static examples = ['<%= config.bin %> pull --dir ./our-config', '<%= config.bin %> pull  # uses QUONFIG_DIR env var'];
     static flags = {
         dir: Flags.string({
             description: 'Local directory to clone/update (defaults to QUONFIG_DIR env var)',
@@ -62,26 +59,7 @@ CLI shortcuts (no JSON editing needed for simple cases):
         const repoUrl = await this.resolveRepoUrl(workspaceId);
         // Perform git operation
         const isRepo = await isGitRepo(resolvedDir);
-        if (!isRepo) {
-            // Clone fresh
-            this.log(`Cloning workspace into ${resolvedDir}...`);
-            try {
-                await gitClone(repoUrl, resolvedDir);
-            }
-            catch (err) {
-                // On 401, refresh token and retry once
-                if (this.looksLike401(err)) {
-                    this.verboseLog('Pull', 'Got 401, refreshing Gitea token...');
-                    const freshUrl = await this.refreshAndGetUrl(workspaceId);
-                    await gitClone(freshUrl, resolvedDir);
-                }
-                else {
-                    throw err;
-                }
-            }
-            this.log(`Cloned successfully into ${resolvedDir}`);
-        }
-        else {
+        if (isRepo) {
             // Existing repo — check remote
             const existingRemote = await getRemoteUrl(resolvedDir);
             const expectedUrlBase = stripAuth(repoUrl);
@@ -100,15 +78,15 @@ CLI shortcuts (no JSON editing needed for simple cases):
             try {
                 await gitFetch(resolvedDir);
             }
-            catch (err) {
-                if (this.looksLike401(err)) {
+            catch (error) {
+                if (this.looksLike401(error)) {
                     this.verboseLog('Pull', 'Got 401 on fetch, refreshing Gitea token...');
                     const freshUrl = await this.refreshAndGetUrl(workspaceId);
                     await gitSetRemote(resolvedDir, freshUrl);
                     await gitFetch(resolvedDir);
                 }
                 else {
-                    throw err;
+                    throw error;
                 }
             }
             const ff = await canFastForward(resolvedDir);
@@ -132,24 +110,29 @@ CLI shortcuts (no JSON editing needed for simple cases):
                 this.log('Updated successfully.');
             }
         }
+        else {
+            // Clone fresh
+            this.log(`Cloning workspace into ${resolvedDir}...`);
+            try {
+                await gitClone(repoUrl, resolvedDir);
+            }
+            catch (error) {
+                // On 401, refresh token and retry once
+                if (this.looksLike401(error)) {
+                    this.verboseLog('Pull', 'Got 401, refreshing Gitea token...');
+                    const freshUrl = await this.refreshAndGetUrl(workspaceId);
+                    await gitClone(freshUrl, resolvedDir);
+                }
+                else {
+                    throw error;
+                }
+            }
+            this.log(`Cloned successfully into ${resolvedDir}`);
+        }
         // Write QUONFIG_DIR to ~/.quonfig/config if not set
         await this.maybeWriteQuonfigDir(resolvedDir);
         return { dir: resolvedDir, workspaceId };
     }
-    async resolveRepoUrl(workspaceId) {
-        let entry = await loadGiteaToken(workspaceId);
-        if (!entry || isGiteaTokenExpired(entry)) {
-            this.verboseLog('Pull', 'Minting new Gitea read token...');
-            entry = await mintAndStoreGiteaReadToken(workspaceId);
-        }
-        return entry.repoUrl;
-    }
-    async refreshAndGetUrl(workspaceId) {
-        const data = await mintGiteaToken(workspaceId, 'read', 'pull');
-        const entry = { token: data.token, repoUrl: data.repoUrl, expiresAt: data.expiresAt };
-        await saveGiteaToken(workspaceId, entry);
-        return entry.repoUrl;
-    }
     looksLike401(err) {
         const msg = err instanceof Error ? err.message : String(err);
         return msg.includes('401') || msg.toLowerCase().includes('authentication failed');
@@ -172,6 +155,20 @@ CLI shortcuts (no JSON editing needed for simple cases):
             // Non-fatal
         }
     }
+    async refreshAndGetUrl(workspaceId) {
+        const data = await mintGiteaToken(workspaceId, 'read', 'pull');
+        const entry = { token: data.token, repoUrl: data.repoUrl, expiresAt: data.expiresAt };
+        await saveGiteaToken(workspaceId, entry);
+        return entry.repoUrl;
+    }
+    async resolveRepoUrl(workspaceId) {
+        let entry = await loadGiteaToken(workspaceId);
+        if (!entry || isGiteaTokenExpired(entry)) {
+            this.verboseLog('Pull', 'Minting new Gitea read token...');
+            entry = await mintAndStoreGiteaReadToken(workspaceId);
+        }
+        return entry.repoUrl;
+    }
 }
 /**
  * Strip auth credentials from a git URL for comparison purposes.

package/dist/commands/schema.d.ts

@@ -13,9 +13,9 @@ export default class Schema extends APICommand {
         'set-zod': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     run(): Promise<JsonObj | void>;
-    private getSchema;
-    private upsertSchema;
-    private fetchSchema;
     private createSchema;
+    private fetchSchema;
+    private getSchema;
     private updateSchema;
+    private upsertSchema;
 }

package/dist/commands/schema.js

@@ -56,47 +56,34 @@ export default class Schema extends APICommand {
         }
         return this.upsertSchema(schemaKey, schemaInput, flags.protected);
     }
-    async getSchema(schemaKey) {
-        const request = await this.apiClient.post('/api/v1/schemas/getByKey', {
+    async createSchema(schemaKey, schema, protectedSchema) {
+        const request = await this.apiClient.post('/api/v1/schemas/create', {
             workspaceId: this.workspaceId,
             schemaKey,
+            protected: protectedSchema,
+            schema,
         });
         if (!request.ok) {
-            if (request.status === 404) {
-                return this.err(`Schema ${schemaKey} not found`, {
-                    key: schemaKey,
-                    phase: 'lookup',
-                    serverError: request.error,
-                });
+            if (request.status === 409) {
+                const current = await this.fetchSchema(schemaKey);
+                if (current) {
+                    return this.updateSchema(schemaKey, schema, current, protectedSchema);
+                }
             }
-            return this.err(`Failed to fetch schema ${schemaKey}: ${request.status} | ${JSON.stringify(request.error)}`, {
+            return this.err(`Failed to create schema: ${schemaKey} | ${request.status} | ${JSON.stringify(request.error)}`, {
                 key: schemaKey,
-                phase: 'lookup',
+                phase: 'creation',
                 serverError: request.error,
             });
         }
         const response = request.json;
-        if (!isSchemaDocument(response.schema)) {
-            return this.err(`Schema ${schemaKey} returned an invalid document`, {
-                key: schemaKey,
-                phase: 'lookup',
-            });
-        }
-        return this.ok(JSON.stringify(response.schema, null, 2), {
+        return this.ok(`${checkmark} Created schema: ${schemaKey}`, {
             commitSha: response.commitSha,
             key: response.key,
             protected: response.protected,
             schema: response.schema,
         });
     }
-    async upsertSchema(schemaKey, schemaInput, protectedSchema) {
-        const schema = loadSchemaDocument(schemaInput);
-        const existing = await this.fetchSchema(schemaKey);
-        if (!existing) {
-            return this.createSchema(schemaKey, schema, protectedSchema);
-        }
-        return this.updateSchema(schemaKey, schema, existing, protectedSchema);
-    }
     async fetchSchema(schemaKey) {
         const request = await this.apiClient.post('/api/v1/schemas/getByKey', {
             workspaceId: this.workspaceId,
@@ -114,28 +101,33 @@ export default class Schema extends APICommand {
         }
         throw new Error(`Failed to fetch schema ${schemaKey}: ${request.status} | ${JSON.stringify(request.error)}`);
     }
-    async createSchema(schemaKey, schema, protectedSchema) {
-        const request = await this.apiClient.post('/api/v1/schemas/create', {
+    async getSchema(schemaKey) {
+        const request = await this.apiClient.post('/api/v1/schemas/getByKey', {
             workspaceId: this.workspaceId,
             schemaKey,
-            protected: protectedSchema,
-            schema,
         });
         if (!request.ok) {
-            if (request.status === 409) {
-                const current = await this.fetchSchema(schemaKey);
-                if (current) {
-                    return this.updateSchema(schemaKey, schema, current, protectedSchema);
-                }
+            if (request.status === 404) {
+                return this.err(`Schema ${schemaKey} not found`, {
+                    key: schemaKey,
+                    phase: 'lookup',
+                    serverError: request.error,
+                });
             }
-            return this.err(`Failed to create schema: ${schemaKey} | ${request.status} | ${JSON.stringify(request.error)}`, {
+            return this.err(`Failed to fetch schema ${schemaKey}: ${request.status} | ${JSON.stringify(request.error)}`, {
                 key: schemaKey,
-                phase: 'creation',
+                phase: 'lookup',
                 serverError: request.error,
             });
         }
         const response = request.json;
-        return this.ok(`${checkmark} Created schema: ${schemaKey}`, {
+        if (!isSchemaDocument(response.schema)) {
+            return this.err(`Schema ${schemaKey} returned an invalid document`, {
+                key: schemaKey,
+                phase: 'lookup',
+            });
+        }
+        return this.ok(JSON.stringify(response.schema, null, 2), {
             commitSha: response.commitSha,
             key: response.key,
             protected: response.protected,
@@ -165,4 +157,12 @@ export default class Schema extends APICommand {
             schema: response.schema,
         });
     }
+    async upsertSchema(schemaKey, schemaInput, protectedSchema) {
+        const schema = loadSchemaDocument(schemaInput);
+        const existing = await this.fetchSchema(schemaKey);
+        if (!existing) {
+            return this.createSchema(schemaKey, schema, protectedSchema);
+        }
+        return this.updateSchema(schemaKey, schema, existing, protectedSchema);
+    }
 }

package/dist/commands/sdk-key/create.js

@@ -40,21 +40,19 @@ export default class SdkKeyCreate extends APICommand {
             environmentId = match.id;
             environmentName = match.name;
         }
+        else if (environments.length === 1) {
+            environmentId = environments[0].id;
+            environmentName = environments[0].name;
+            this.log(`Using environment: ${environmentName}`);
+        }
         else {
-            if (environments.length === 1) {
-                environmentId = environments[0].id;
-                environmentName = environments[0].name;
-                this.log(`Using environment: ${environmentName}`);
-            }
-            else {
-                const chosen = await select({
-                    choices: environments.map((e) => ({ name: e.name, value: e.id })),
-                    message: 'Select environment:',
-                });
-                const match = environments.find((e) => e.id === chosen);
-                environmentId = match.id;
-                environmentName = match.name;
-            }
+            const chosen = await select({
+                choices: environments.map((e) => ({ name: e.name, value: e.id })),
+                message: 'Select environment:',
+            });
+            const match = environments.find((e) => e.id === chosen);
+            environmentId = match.id;
+            environmentName = match.name;
         }
         // Resolve key type
         let keyType;

package/dist/commands/sdk-key/revoke.d.ts

@@ -1,10 +1,10 @@
 import type { JsonObj } from '../../result.js';
 import { APICommand } from '../../index.js';
 export default class SdkKeyRevoke extends APICommand {
-    static description: string;
     static args: {
         keyId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
     };
+    static description: string;
     static examples: string[];
     run(): Promise<JsonObj | void>;
 }

package/dist/commands/sdk-key/revoke.js

@@ -1,16 +1,14 @@
 import { Args } from '@oclif/core';
 import { APICommand } from '../../index.js';
 export default class SdkKeyRevoke extends APICommand {
-    static description = 'Revoke an SDK key by its ID';
     static args = {
         keyId: Args.string({
             description: 'ID of the SDK key to revoke',
             required: true,
         }),
     };
-    static examples = [
-        '<%= config.bin %> <%= command.id %> a1b2c3d4-e5f6-7890-abcd-ef1234567890',
-    ];
+    static description = 'Revoke an SDK key by its ID';
+    static examples = ['<%= config.bin %> <%= command.id %> a1b2c3d4-e5f6-7890-abcd-ef1234567890'];
     async run() {
         const { args } = await this.parse(SdkKeyRevoke);
         const request = await this.apiClient.post('/api/v1/sdkKeys/delete', {