@quonfig/cli 0.0.12 → 0.0.14

package/dist/commands/login.js

@@ -17,6 +17,9 @@ export default class Login extends BaseCommand {
     async run() {
         const { flags } = await this.parse(Login);
         const profileName = flags.profile || 'default';
+        if (process.env.QUONFIG_API_KEY && process.env.QUONFIG_API_KEY.length > 0) {
+            this.log('Note: QUONFIG_API_KEY is set — runtime will prefer it over the login session.');
+        }
         // Step 1: Request device code from WorkOS
         this.verboseLog('Requesting device authorization code...');
         const deviceAuth = await requestDeviceCode();
@@ -65,13 +68,13 @@ export default class Login extends BaseCommand {
             const res = await fetch(`${apiUrl}/api/v1/userWorkspaces/list`, {
                 method: 'POST',
                 headers: {
-                    'Authorization': `Bearer ${tokenResponse.access_token}`,
+                    Authorization: `Bearer ${tokenResponse.access_token}`,
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify({ json: {} }),
             });
             if (res.ok) {
-                const body = await res.json();
+                const body = (await res.json());
                 const allWorkspaces = (body.json ?? body);
                 const candidates = Array.isArray(allWorkspaces) ? allWorkspaces : [];
                 multipleWorkspacesAvailable = candidates.length > 1;
@@ -81,7 +84,10 @@ export default class Login extends BaseCommand {
                 }
                 else if (candidates.length > 1) {
                     const chosen = await select({
-                        choices: candidates.map((w) => ({ name: `${w.organizationName} / ${w.workspaceSlug}`, value: w.workspaceId })),
+                        choices: candidates.map((w) => ({
+                            name: `${w.organizationName} / ${w.workspaceSlug}`,
+                            value: w.workspaceId,
+                        })),
                         message: 'Select workspace:',
                     });
                     match = candidates.find((w) => w.workspaceId === chosen);

package/dist/commands/migrate/doctor.js

@@ -1,6 +1,6 @@
 import { Flags } from '@oclif/core';
 import { BaseCommand } from '../../index.js';
-import { formatHumanReport, runDoctor, } from '../../migrate/doctor.js';
+import { formatHumanReport, runDoctor } from '../../migrate/doctor.js';
 import { loadTokens } from '../../util/token-storage.js';
 const SUPPORTED_SOURCES = new Set(['launch']);
 const defaultLoadSession = async () => {

package/dist/commands/migrate/my-code.d.ts

@@ -0,0 +1,11 @@
+import type { JsonObj } from '../../result.js';
+import { BaseCommand } from '../../index.js';
+export default class MigrateMyCode extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'dry-run': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        from: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<JsonObj | void>;
+}

package/dist/commands/migrate/my-code.js

@@ -0,0 +1,80 @@
+import { Flags } from '@oclif/core';
+import fs from 'node:fs';
+import path from 'node:path';
+import { BaseCommand } from '../../index.js';
+const SKILL_NAME = 'qfg-migrate-code';
+const SUPPORTED_SOURCES = new Set(['launch']);
+function findIdentifierMap(startDir) {
+    let dir = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(dir, '.qf', 'identifier-map.json');
+        if (fs.existsSync(candidate)) {
+            const raw = fs.readFileSync(candidate, 'utf8');
+            return { dir, map: JSON.parse(raw) };
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+export default class MigrateMyCode extends BaseCommand {
+    static description = 'Migrate Launch SDK call sites in your codebase to Quonfig SDK call sites (invokes the qfg-migrate-code Claude skill)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --from launch',
+        '<%= config.bin %> <%= command.id %> --dry-run',
+    ];
+    static flags = {
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'Show what would be migrated without editing any files',
+        }),
+        from: Flags.string({
+            default: 'launch',
+            description: 'Legacy SDK to migrate from',
+            options: ['launch'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(MigrateMyCode);
+        if (!SUPPORTED_SOURCES.has(flags.from)) {
+            return this.err(`Unsupported --from source: ${flags.from}. Only 'launch' is supported today; 'launchdarkly' and 'flagsmith' will follow.`);
+        }
+        const found = findIdentifierMap(process.cwd());
+        if (!found) {
+            return this.err(`Could not find .qf/identifier-map.json in the current directory or any parent.\n\n` +
+                `This file is produced by \`qfg migrate --from ${flags.from}\` and maps legacy keys to their Quonfig equivalents.\n` +
+                `Run \`qfg migrate --from ${flags.from} --dir <your-workspace-dir>\` first, then re-run this command from your codebase.`);
+        }
+        const { dir: workspaceDir, map: mappings } = found;
+        const mappingCount = Object.keys(mappings).length;
+        const relativeMapPath = path.relative(process.cwd(), path.join(workspaceDir, '.qf', 'identifier-map.json')) || '.qf/identifier-map.json';
+        this.log(`Skill:         ${SKILL_NAME}`);
+        this.log(`From:          ${flags.from}`);
+        this.log(`Identifier map: ${relativeMapPath}`);
+        this.log(`Found:         ${mappingCount} identifier remapping${mappingCount === 1 ? '' : 's'}`);
+        if (flags['dry-run']) {
+            this.log(`Mode:          dry-run (no files will be modified)`);
+        }
+        this.log('');
+        this.log(`To run the migration, invoke Claude with the ${SKILL_NAME} skill. For example:`);
+        this.log('');
+        this.log(`  claude "/${SKILL_NAME}${flags['dry-run'] ? ' --dry-run' : ''}"`);
+        this.log('');
+        this.log(`The skill will:`);
+        this.log(`  1. Scan for ${flags.from} SDK imports and call sites`);
+        this.log(`  2. Propose edits using the ${mappingCount} key remapping${mappingCount === 1 ? '' : 's'} above`);
+        this.log(`  3. Ask for approval before editing files`);
+        this.log(`  4. Run your tests / typecheck afterwards if available`);
+        this.log(`  5. Summarize anything it could not auto-migrate`);
+        return {
+            dryRun: flags['dry-run'],
+            from: flags.from,
+            identifierMapPath: path.join(workspaceDir, '.qf', 'identifier-map.json'),
+            mappingCount,
+            mappings,
+            skill: SKILL_NAME,
+        };
+    }
+}

package/dist/commands/migrate/status.js

@@ -10,10 +10,7 @@ const NO_STATE_MESSAGE = 'No migration state found. Run qfg migrate --from <sour
 function countJsonFiles(dir) {
     if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory())
         return 0;
-    return fs
-        .readdirSync(dir)
-        .filter((name) => name.endsWith('.json') && !name.startsWith('.'))
-        .length;
+    return fs.readdirSync(dir).filter((name) => name.endsWith('.json') && !name.startsWith('.')).length;
 }
 function countEnvironments(dir) {
     const file = path.join(dir, WORKSPACE_FILE);
@@ -35,7 +32,7 @@ function workspaceCounts(dir) {
     };
 }
 function toIsoTimestamp(value) {
-    if (value == null)
+    if (value === null || value === undefined)
         return null;
     const date = typeof value === 'number' ? new Date(value) : new Date(value);
     if (Number.isNaN(date.getTime()))
@@ -50,17 +47,7 @@ function nextHint(source, counts) {
 }
 function formatHuman(payload) {
     const lines = [];
-    lines.push(`Source:            ${payload.source}`);
-    lines.push(`Source workspace:  ${payload.sourceWorkspaceId ?? '(not recorded)'}`);
-    lines.push(`Last processed at: ${payload.lastProcessedAtIso ?? '(not recorded)'}`);
-    lines.push(`Workspace dir:     ${payload.dir}`);
-    lines.push('');
-    lines.push('Counts:');
-    lines.push(`  Flags:         ${payload.counts.flags}`);
-    lines.push(`  Segments:      ${payload.counts.segments}`);
-    lines.push(`  Environments:  ${payload.counts.environments}`);
-    lines.push('');
-    lines.push(`Next: ${payload.next}`);
+    lines.push(`Source:            ${payload.source}`, `Source workspace:  ${payload.sourceWorkspaceId ?? '(not recorded)'}`, `Last processed at: ${payload.lastProcessedAtIso ?? '(not recorded)'}`, `Workspace dir:     ${payload.dir}`, '', 'Counts:', `  Flags:         ${payload.counts.flags}`, `  Segments:      ${payload.counts.segments}`, `  Environments:  ${payload.counts.environments}`, '', `Next: ${payload.next}`);
     return lines.join('\n');
 }
 export default class MigrateStatus extends BaseCommand {

package/dist/commands/migrate.js

@@ -2,7 +2,8 @@ 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 { 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';
@@ -10,7 +11,7 @@ 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';
+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' +
@@ -105,7 +106,7 @@ export default class Migrate extends BaseCommand {
         }
         try {
             await source.validateAuth(flags['api-key']);
-            await source.listEnvironments();
+            const environments = await source.listEnvironments();
             const existing = readImportState(dir);
             const sinceEpochMs = computeSince(flags, existing);
             const changes = [];
@@ -172,9 +173,30 @@ export default class Migrate extends BaseCommand {
                     throw error;
                 }
             }
-            this.log(`Fetched ${changes.length} change(s) from ${flags.from}; processing ${toProcess.length}.\n` +
-                'Writing files to a local dir without --push ships in follow-on beads (see qfg-zfl.10).');
-            return payload;
+            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)
@@ -191,8 +213,7 @@ export default class Migrate extends BaseCommand {
             return { authConfig, workspaceId: resolved ?? slugOrId };
         }
         const activeProfile = getActiveProfile();
-        const profile = authConfig.profiles[activeProfile] ||
-            authConfig.profiles[authConfig.defaultProfile || 'default'];
+        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.';
         }

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

@@ -5,7 +5,7 @@ import { BaseCommand } from '../index.js';
 import { getActiveProfile, loadAuthConfig } from '../util/token-storage.js';
 import { loadGiteaToken, isGiteaTokenExpired, saveGiteaToken } from '../util/gitea-token-storage.js';
 import { mintAndStoreGiteaReadToken, mintGiteaToken } from '../util/gitea-api.js';
-import { isGitRepo, getRemoteUrl, isWorkingTreeClean, gitFetch, gitSetRemote, canFastForward, hasDivergedFromRemote, gitMergeFfOnly, gitClone, displayUrl, } from '../util/git-ops.js';
+import { isGitRepo, getRemoteUrl, gitFetch, gitSetRemote, canFastForward, hasDivergedFromRemote, gitMergeFfOnly, gitClone, displayUrl, } from '../util/git-ops.js';
 export default class Pull extends BaseCommand {
     static description = `Clone or update a local copy of your workspace config files.
 
@@ -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);
@@ -90,25 +68,26 @@ CLI shortcuts (no JSON editing needed for simple cases):
             }
             // Update the remote URL to use current (possibly refreshed) token
             await gitSetRemote(resolvedDir, repoUrl);
-            // Check working tree
-            const clean = await isWorkingTreeClean(resolvedDir);
-            if (!clean) {
-                return this.err('Local changes present — commit, stash, or run `git reset --hard origin/main` to discard.');
-            }
+            // Note: we intentionally don't pre-check for untracked or modified files.
+            // Plain `git pull` is fine with untracked files, and `git merge --ff-only`
+            // below will fail loudly on real conflicts (tracked modifications, or an
+            // incoming commit that would overwrite an untracked file). Pre-checking
+            // just creates a self-trap when qfg itself writes files like
+            // `.qfg-friction.log` into the workspace dir (qfg-q2l).
             // Fetch
             this.log('Fetching from remote...');
             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 +111,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 +156,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>;
 }