@quonfig/cli 0.0.5 → 0.0.7

package/dist/codegen/local-config-reader.d.ts

@@ -0,0 +1,6 @@
+import type { ConfigFile } from './types.js';
+export declare class LocalConfigReader {
+    private dir;
+    constructor(dir: string);
+    read(): Promise<ConfigFile>;
+}

package/dist/codegen/local-config-reader.js

@@ -0,0 +1,113 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+function mapGitValue(gitValue) {
+    const { type, value } = gitValue;
+    switch (type) {
+        case 'bool': {
+            return { value: { bool: value } };
+        }
+        case 'int': {
+            return { value: { int: value } };
+        }
+        case 'json': {
+            return { value: { json: { json: value } } };
+        }
+        case 'log_level': {
+            return { value: { logLevel: value } };
+        }
+        case 'string_list': {
+            return { value: { string: JSON.stringify(value) } };
+        }
+        case 'string':
+        default: {
+            return { value: { string: value } };
+        }
+    }
+}
+function buildRows(gitConfig) {
+    const allRules = [
+        ...(gitConfig.default?.rules ?? []),
+        ...(gitConfig.environments ?? []).flatMap((env) => env.rules),
+    ];
+    return allRules.map((rule) => ({
+        values: [mapGitValue(rule.value)],
+    }));
+}
+function mapConfigType(gitType) {
+    return gitType === 'feature_flag' ? 'FEATURE_FLAG' : 'CONFIG';
+}
+function mapValueType(gitValueType) {
+    return gitValueType.toUpperCase();
+}
+async function readJsonFiles(dir) {
+    try {
+        const entries = await fs.promises.readdir(dir);
+        const jsonFiles = entries.filter((f) => f.endsWith('.json'));
+        return Promise.all(jsonFiles.map(async (file) => {
+            const filePath = path.join(dir, file);
+            const content = await fs.promises.readFile(filePath, 'utf8');
+            return { filePath, data: JSON.parse(content) };
+        }));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+export class LocalConfigReader {
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    async read() {
+        // Validate dir exists
+        try {
+            await fs.promises.access(this.dir, fs.constants.F_OK);
+        }
+        catch {
+            throw new Error(`Directory not found: ${this.dir}. Run \`qfg pull --dir ${this.dir}\` to clone it.`);
+        }
+        // Validate it's a quonfig workspace
+        const quonfigJsonPath = path.join(this.dir, 'quonfig.json');
+        try {
+            await fs.promises.access(quonfigJsonPath, fs.constants.F_OK);
+        }
+        catch {
+            throw new Error(`${this.dir} does not look like a Quonfig workspace. Is this the right directory?`);
+        }
+        // Read configs and feature-flags
+        const [configFiles, flagFiles] = await Promise.all([
+            readJsonFiles(path.join(this.dir, 'configs')),
+            readJsonFiles(path.join(this.dir, 'feature-flags')),
+        ]);
+        const configs = [];
+        for (const { filePath, data } of [...configFiles, ...flagFiles]) {
+            const gitConfig = data;
+            if (!gitConfig.key || !gitConfig.type || !gitConfig.valueType) {
+                console.warn(`Skipping malformed config file: ${filePath}`);
+                continue;
+            }
+            const rows = buildRows(gitConfig);
+            configs.push({
+                configType: mapConfigType(gitConfig.type),
+                key: gitConfig.key,
+                rows,
+                schemaKey: gitConfig.schemaKey,
+                sendToClientSdk: gitConfig.sendToClientSdk,
+                valueType: mapValueType(gitConfig.valueType),
+            });
+        }
+        // Read schemas
+        const schemaFiles = await readJsonFiles(path.join(this.dir, 'schemas'));
+        const schemas = schemaFiles.map(({ filePath, data }) => ({
+            path: filePath,
+            schema: data,
+        }));
+        if (configs.length === 0) {
+            console.warn('No configs or feature-flags found in workspace. Generated types will be empty.');
+        }
+        return { configs, schemas };
+    }
+}

package/dist/commands/create.js

@@ -105,6 +105,9 @@ Or edit the JSON config file directly for complex targeting rules:
                     configValue = confidentialValueResult.value;
                 }
             }
+            else if (valueInput.error) {
+                return this.err(valueInput.message, valueInput.json);
+            }
             else {
                 return;
             }

package/dist/commands/generate.d.ts

@@ -1,9 +1,10 @@
 import type { JsonObj } from '../result.js';
-import { APICommand } from '../index.js';
-export default class Generate extends APICommand {
+import { BaseCommand } from '../index.js';
+export default class Generate extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        dir: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         'output-directory': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         targets: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };

package/dist/commands/generate.js

@@ -4,9 +4,9 @@ import * as path from 'node:path';
 import { z } from 'zod';
 import { NodeTypeScriptGenerator } from '../codegen/code-generators/node-typescript-generator.js';
 import { ReactTypeScriptGenerator } from '../codegen/code-generators/react-typescript-generator.js';
-import { ConfigDownloader } from '../codegen/config-downloader.js';
+import { LocalConfigReader } from '../codegen/local-config-reader.js';
 import { SupportedLanguage } from '../codegen/types.js';
-import { APICommand } from '../index.js';
+import { BaseCommand } from '../index.js';
 import { createFileManager } from '../util/file-manager.js';
 // base types
 const nodeOrReactLanguageSpecificSchema = z.object({
@@ -66,7 +66,7 @@ const DEFAULT_CONFIG = {
         },
     },
 };
-export default class Generate extends APICommand {
+export default class Generate extends BaseCommand {
     /* eslint-disable no-irregular-whitespace */
     static description = `You can use the default type-generation configuration, or by provide your own via a quonfig.config.json file:
 
@@ -108,6 +108,10 @@ Example quonfig.config.json:
         '<%= config.bin %> <%= command.id %> --targets node-ts -o ./dist # combine with targets',
     ];
     static flags = {
+        dir: Flags.string({
+            description: 'Path to local QUONFIG_DIR (defaults to QUONFIG_DIR env var)',
+            env: 'QUONFIG_DIR',
+        }),
         'output-directory': Flags.string({
             char: 'o',
             description: 'Override the output directory for generated files',
@@ -121,18 +125,22 @@ Example quonfig.config.json:
     async run() {
         const { flags } = await this.parse(Generate);
         this.verboseLog('=== GENERATE COMMAND START ===');
-        this.verboseLog(`Base API URL: ${process.env.QUONFIG_API_URL || 'Default'}`);
         try {
+            // Resolve workspace directory
+            const dir = flags.dir;
+            if (!dir) {
+                this.error('No directory specified. Run `qfg pull` first or pass --dir <path>.');
+            }
             // Look for and read local quonfig.config.json file
             const localConfig = await this.readLocalConfig(flags['output-directory']);
-            // Use tarets flag override, otherwise fall back to local config
+            // Use targets flag override, otherwise fall back to local config
             const targets = flags.targets.split(',') || Object.keys(localConfig);
             this.verboseLog(`Language(s): ${targets.join(', ')}`);
-            // Download the configuration using the APICommand's client
-            const downloader = new ConfigDownloader(this);
-            this.verboseLog('Downloading config...');
-            const configFile = await downloader.downloadConfig();
-            this.verboseLog('Config download complete.');
+            // Read configuration from local directory
+            const reader = new LocalConfigReader(dir);
+            this.verboseLog(`Reading config from ${dir}...`);
+            const configFile = await reader.read();
+            this.verboseLog(`Config read complete. Found ${configFile.configs.length} configs.`);
             const fileCreationPromises = [];
             for (const target of targets) {
                 // Resolve the language input

package/dist/commands/login.js

@@ -10,7 +10,8 @@ export default class Login extends BaseCommand {
     static flags = {
         profile: Flags.string({
             char: 'p',
-            description: 'Profile name to create or update (defaults to "default")',
+            description: 'Profile name to save credentials under (advanced; defaults to "default")',
+            hidden: true,
         }),
     };
     async run() {
@@ -56,6 +57,8 @@ export default class Login extends BaseCommand {
         let workspaceName;
         let workspaceSlug;
         let organizationName;
+        let organizationId;
+        let multipleWorkspacesAvailable = false;
         try {
             const apiUrl = getApiUrl();
             this.verboseLog('Resolving workspace...', { apiUrl, orgId });
@@ -70,17 +73,15 @@ export default class Login extends BaseCommand {
             if (res.ok) {
                 const body = await res.json();
                 const allWorkspaces = (body.json ?? body);
-                const orgWorkspaces = Array.isArray(allWorkspaces)
-                    ? allWorkspaces.filter((w) => w.workosOrgId === orgId)
-                    : [];
-                const candidates = orgWorkspaces.length > 0 ? orgWorkspaces : (Array.isArray(allWorkspaces) ? allWorkspaces : []);
+                const candidates = Array.isArray(allWorkspaces) ? allWorkspaces : [];
+                multipleWorkspacesAvailable = candidates.length > 1;
                 let match;
                 if (candidates.length === 1) {
                     match = candidates[0];
                 }
                 else if (candidates.length > 1) {
                     const chosen = await select({
-                        choices: candidates.map((w) => ({ name: 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);
@@ -90,6 +91,7 @@ export default class Login extends BaseCommand {
                     workspaceName = match.workspaceSlug;
                     workspaceSlug = match.workspaceSlug;
                     organizationName = match.organizationName;
+                    organizationId = match.workosOrgId;
                     this.verboseLog('Resolved workspace', { workspaceId, workspaceName, workspaceSlug, organizationName });
                 }
             }
@@ -113,33 +115,38 @@ export default class Login extends BaseCommand {
                     workspace: workspaceId || orgId || 'unknown',
                     workspaceName: workspaceName || (orgId ? `org:${orgId}` : undefined),
                     workspaceSlug,
+                    organizationName,
                 },
             },
         });
-        this.log(`\nProfile '${profileName}' configured.`);
-        if (shouldSetDefault) {
-            this.log('Set as default profile.');
-        }
         this.log('\nSuccessfully logged in!');
         if (userEmail) {
             this.log(`Logged in as: ${userEmail}`);
         }
         if (workspaceName) {
-            this.log(`Workspace: ${workspaceName} (${workspaceId})`);
-            if (organizationName) {
-                this.log(`Organization: ${organizationName}`);
+            const orgPrefix = organizationName ? `${organizationName} / ` : '';
+            this.log(`Workspace:    ${orgPrefix}${workspaceName}`);
+            if (workspaceId) {
+                this.log(`              (${workspaceId})`);
             }
         }
         else if (orgId) {
             this.log(`Organization: ${orgId}`);
         }
+        if (multipleWorkspacesAvailable && workspaceSlug) {
+            this.log(`\nYou have multiple workspaces. To pin this project to ${workspaceSlug},`);
+            this.log(`add this to your project's .env file:`);
+            this.log(`  QUONFIG_WORKSPACE=${workspaceSlug}`);
+            this.log(`\nTo switch your default workspace: qfg workspace switch`);
+        }
         return {
             email: userEmail,
-            organizationId: orgId,
-            profile: profileName,
+            organizationId: organizationId || orgId,
+            organizationName,
             success: true,
             userId: user.id,
             workspaceId,
+            workspaceSlug,
         };
     }
 }

package/dist/commands/profile.d.ts

@@ -2,6 +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[];
     run(): Promise<JsonObj | void>;
 }

package/dist/commands/profile.js

@@ -1,47 +1,11 @@
-import { select } from '@inquirer/prompts';
 import { BaseCommand } from '../index.js';
-import { loadAuthConfig, saveAuthConfig } from '../util/token-storage.js';
+import WorkspaceSwitch from './workspace/switch.js';
 export default class Profile extends BaseCommand {
-    static description = 'Manage profiles and set default profile';
-    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static description = 'Deprecated. Use `qfg workspace switch` instead.';
+    static hidden = true;
+    static examples = ['<%= config.bin %> workspace switch'];
     async run() {
-        const authConfig = await loadAuthConfig();
-        if (!authConfig || Object.keys(authConfig.profiles).length === 0) {
-            return this.err('Not logged in. Please run `qfg login` first.');
-        }
-        const currentDefault = authConfig.defaultProfile || 'default';
-        // If only one profile, just show it
-        if (Object.keys(authConfig.profiles).length === 1) {
-            const profileName = Object.keys(authConfig.profiles)[0];
-            const profile = authConfig.profiles[profileName];
-            this.log(`Current default profile: ${profileName}`);
-            this.log(`Workspace: ${profile.workspaceName || profile.workspace}`);
-            this.log('\nYou only have one profile.');
-            return {
-                defaultProfile: profileName,
-                profiles: Object.keys(authConfig.profiles),
-            };
-        }
-        // Show current default
-        this.log(`Current default profile: ${currentDefault}\n`);
-        // Let user select a new default profile
-        const newDefault = await select({
-            choices: Object.entries(authConfig.profiles).map(([name, profile]) => ({
-                name: `${name} (${profile.workspaceName || profile.workspace})`,
-                value: name,
-            })),
-            message: 'Select default profile:',
-        });
-        // Update the default profile
-        await saveAuthConfig({
-            ...authConfig,
-            defaultProfile: newDefault,
-        });
-        this.log(`\nDefault profile set to: ${newDefault}`);
-        return {
-            defaultProfile: newDefault,
-            previousDefault: currentDefault,
-            success: true,
-        };
+        this.log('Note: `qfg profile` is deprecated. Use `qfg workspace switch` instead.\n');
+        return WorkspaceSwitch.run([], this.config);
     }
 }

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

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

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

@@ -0,0 +1,100 @@
+import { Flags } from '@oclif/core';
+import { select } from '@inquirer/prompts';
+import { APICommand } from '../../index.js';
+import { getEnvironments } from '../../api/get-environments.js';
+export default class SdkKeyCreate extends APICommand {
+    static description = 'Create a new SDK key';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --environment production --type server',
+        '<%= config.bin %> <%= command.id %> --environment staging --type browser',
+    ];
+    static flags = {
+        environment: Flags.string({
+            char: 'e',
+            description: 'Environment name (e.g. production, staging)',
+            required: false,
+        }),
+        type: Flags.string({
+            char: 't',
+            description: 'Key type: server (backend) or browser (frontend)',
+            options: ['server', 'browser'],
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SdkKeyCreate);
+        // Fetch available environments
+        const environments = await getEnvironments(this);
+        if (environments.length === 0) {
+            return this.err('No environments found for this workspace.');
+        }
+        // Resolve environment
+        let environmentId;
+        let environmentName;
+        if (flags.environment) {
+            const match = environments.find((e) => e.name.toLowerCase() === flags.environment.toLowerCase());
+            if (!match) {
+                const names = environments.map((e) => e.name).join(', ');
+                return this.err(`Environment "${flags.environment}" not found. Available: ${names}`);
+            }
+            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 {
+                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;
+        if (flags.type) {
+            keyType = flags.type === 'server' ? 'backend' : 'frontend';
+        }
+        else {
+            const chosen = await select({
+                choices: [
+                    { name: 'server (backend SDK — Node.js, Go, etc.)', value: 'backend' },
+                    { name: 'browser (frontend SDK — JavaScript/React)', value: 'frontend' },
+                ],
+                message: 'Select key type:',
+            });
+            keyType = chosen;
+        }
+        const request = await this.apiClient.post('/api/v1/sdkKeys/create', {
+            workspaceId: this.workspaceId,
+            environmentId,
+            keyType,
+        });
+        if (!request.ok) {
+            const errorMsg = request.error?.error || `Failed to create SDK key: ${request.status}`;
+            return this.err(errorMsg, { serverError: request.error });
+        }
+        const key = request.json;
+        const typeLabel = keyType === 'backend' ? 'server' : 'browser';
+        this.log(`\nSDK key created successfully!\n`);
+        this.log(`Environment:  ${environmentName}`);
+        this.log(`Type:         ${typeLabel}`);
+        this.log(`Key ID:       ${key.id}`);
+        this.log(`\nYour SDK key (shown only once — copy it now):\n`);
+        this.log(`  ${key.rawKey}\n`);
+        this.log(`To revoke this key:  qfg sdk-key revoke ${key.id}`);
+        return {
+            environmentId: key.environmentId,
+            environmentName: key.environmentName,
+            id: key.id,
+            keyType: typeLabel,
+            rawKey: key.rawKey,
+        };
+    }
+}

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

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

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

@@ -0,0 +1,48 @@
+import { Flags } from '@oclif/core';
+import { APICommand } from '../../index.js';
+export default class SdkKeyList extends APICommand {
+    static description = 'List SDK keys for your workspace';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --environment production',
+    ];
+    static flags = {
+        environment: Flags.string({
+            char: 'e',
+            description: 'Filter by environment name',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SdkKeyList);
+        const request = await this.apiClient.post('/api/v1/sdkKeys/list', { workspaceId: this.workspaceId });
+        if (!request.ok) {
+            const errorMsg = request.error?.error || `Failed to fetch SDK keys: ${request.status}`;
+            return this.err(errorMsg, { serverError: request.error });
+        }
+        let keys = (Array.isArray(request.json) ? request.json : []);
+        if (flags.environment) {
+            const envFilter = flags.environment.toLowerCase();
+            keys = keys.filter((k) => k.environmentName.toLowerCase() === envFilter);
+        }
+        if (keys.length === 0) {
+            const envSuffix = flags.environment ? ` for environment "${flags.environment}"` : '';
+            this.log(`No SDK keys found${envSuffix}.`);
+            this.log(`\nCreate one with: qfg sdk-key create --environment <name> --type server|browser`);
+            return { keys: [] };
+        }
+        const maxEnvLength = Math.max(11, ...keys.map((k) => k.environmentName.length));
+        const maxTypeLength = 7; // "browser" is longest
+        const maxIdLength = Math.max(2, ...keys.map((k) => k.id.length));
+        const header = `${'ID'.padEnd(maxIdLength)}  ${'ENVIRONMENT'.padEnd(maxEnvLength)}  ${'TYPE'.padEnd(maxTypeLength)}  ${'PREFIX'.padEnd(28)}  CREATED`;
+        const separator = `${'-'.repeat(maxIdLength)}  ${'-'.repeat(maxEnvLength)}  ${'-'.repeat(maxTypeLength)}  ${'-'.repeat(28)}  ${'-'.repeat(24)}`;
+        const rows = keys.map((k) => {
+            const typeLabel = k.keyType === 'backend' ? 'server' : 'browser';
+            const prefix = k.keyType === 'backend' ? `qf_sk_${k.environmentName}_...` : `qf_pk_${k.environmentName}_...`;
+            const created = k.createdAt ? new Date(k.createdAt).toISOString().slice(0, 10) : 'unknown';
+            return `${k.id.padEnd(maxIdLength)}  ${k.environmentName.padEnd(maxEnvLength)}  ${typeLabel.padEnd(maxTypeLength)}  ${prefix.padEnd(28)}  ${created}`;
+        });
+        this.log([header, separator, ...rows].join('\n'));
+        return { keys };
+    }
+}

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

@@ -0,0 +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 examples: string[];
+    run(): Promise<JsonObj | void>;
+}

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

@@ -0,0 +1,30 @@
+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',
+    ];
+    async run() {
+        const { args } = await this.parse(SdkKeyRevoke);
+        const request = await this.apiClient.post('/api/v1/sdkKeys/delete', {
+            workspaceId: this.workspaceId,
+            keyId: args.keyId,
+        });
+        if (!request.ok) {
+            if (request.status === 404) {
+                return this.err(`SDK key "${args.keyId}" not found or already revoked.`);
+            }
+            const errorMsg = request.error?.error || `Failed to revoke SDK key: ${request.status}`;
+            return this.err(errorMsg, { serverError: request.error });
+        }
+        this.log(`SDK key ${args.keyId} has been revoked.`);
+        return { keyId: args.keyId, revoked: true };
+    }
+}

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

@@ -0,0 +1,6 @@
+import { BaseCommand } from '../index.js';
+export default class SdkKey extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/sdk-key.js

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../index.js';
+export default class SdkKey extends BaseCommand {
+    static description = 'Manage SDK keys for your workspace';
+    static examples = [
+        '<%= config.bin %> sdk-key list',
+        '<%= config.bin %> sdk-key create --environment production --type server',
+        '<%= config.bin %> sdk-key revoke <key-id>',
+    ];
+    async run() {
+        this.log('Use one of the sdk-key subcommands:');
+        this.log('  qfg sdk-key list');
+        this.log('  qfg sdk-key create --environment <name> --type server|browser');
+        this.log('  qfg sdk-key revoke <key-id>');
+    }
+}

package/dist/commands/whoami.js

@@ -36,20 +36,20 @@ export default class Whoami extends BaseCommand {
             };
         }
         // Display user information
-        this.log(`Logged in as: ${userEmail || 'Unknown'}`);
-        this.log(`Active profile: ${activeProfile}`);
-        const workspaceDisplay = profile.workspaceName
-            ? `${profile.workspaceName} (${profile.workspace})`
+        const workspaceSlug = profile.workspaceSlug || profile.workspaceName;
+        const orgPrefix = profile.organizationName ? `${profile.organizationName} / ` : '';
+        const workspaceDisplay = workspaceSlug
+            ? `${orgPrefix}${workspaceSlug} (${profile.workspace})`
             : profile.workspace;
-        this.log(`Active workspace: ${workspaceDisplay}`);
+        this.log(`Logged in as: ${userEmail || 'Unknown'}`);
+        this.log(`Workspace:    ${workspaceDisplay}`);
         return {
             email: userEmail,
             loggedIn: true,
-            organizationId: orgId || profile.workspace,
-            profile: activeProfile,
+            organizationName: profile.organizationName,
             userId: tokens.userId,
             workspace: profile.workspace,
-            workspaceName: profile.workspaceName,
+            workspaceSlug,
         };
     }
 }

package/dist/commands/workspace/switch.d.ts

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