@quonfig/cli 0.0.4 → 0.0.6

package/dist/commands/set-rollout.js

@@ -0,0 +1,260 @@
+import { Flags } from '@oclif/core';
+import { APICommand } from '../index.js';
+import getConfirmation from '../ui/get-confirmation.js';
+import getEnvironment from '../ui/get-environment.js';
+import { checkmark } from '../util/color.js';
+import isInteractive from '../util/is-interactive.js';
+import nameArg from '../util/name-arg.js';
+const WEIGHT_TOTAL = 100_000;
+export default class SetRollout extends APICommand {
+    static args = { ...nameArg };
+    static description = `Configure a percentage rollout (gradual rollout / A/B test / canary deploy) for a flag.
+
+The flag must already exist. Create it first if needed:
+  qfg create my.flag --type boolean-flag
+
+Weights are specified as whole-number percentages (0–100). They must sum to 100.
+
+For a boolean flag, use --true-percent to set the percentage of users that receive
+true (the remainder automatically receive false):
+  qfg set-rollout my.flag --environment production --true-percent 20
+  → 20% of users get true, 80% get false
+
+For multi-value flags or custom splits, use --weights with a comma-separated list:
+  qfg set-rollout my.flag --environment production --weights "red:33,green:33,blue:34"
+
+Hashing: users are bucketed by the value of hashByPropertyName (default: "user.key").
+Use --hash-by to change which property drives the bucket assignment:
+  qfg set-rollout my.flag --environment production --true-percent 10 --hash-by user.id
+
+For scripted / agent use, add --confirm to skip the interactive confirmation prompt.
+
+To combine a rollout with segment targeting (e.g. beta ON, holdout OFF, everyone else 50/50),
+you need to edit the JSON config file directly:
+  qfg config-schema           # operator reference + worked multi-rule example
+  qfg pull --dir ./config     # clone workspace to edit
+
+To revert to a single value for everyone, use:
+  qfg set-default my.flag --environment production --value false
+
+To inspect the current rollout:
+  qfg info my.flag`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my.feature.flag --environment production --true-percent 20',
+        '<%= config.bin %> <%= command.id %> my.feature.flag --environment staging --true-percent 50',
+        '<%= config.bin %> <%= command.id %> my.feature.flag --environment production --true-percent 100  # full rollout',
+        '<%= config.bin %> <%= command.id %> my.feature.flag --environment production --true-percent 0    # kill switch (all false)',
+        '<%= config.bin %> <%= command.id %> my.variant.flag --environment production --weights "control:50,treatment:50"',
+        '<%= config.bin %> <%= command.id %> my.variant.flag --environment production --weights "a:33,b:33,c:34" --hash-by user.id',
+    ];
+    static flags = {
+        environment: Flags.string({ description: 'environment to update (e.g. production, staging)' }),
+        'hash-by': Flags.string({
+            default: 'user.key',
+            description: 'user property used to assign buckets (default: user.key)',
+        }),
+        'true-percent': Flags.integer({
+            description: 'percentage of users that receive true (0–100). Remaining users receive false. Boolean flags only.',
+            max: 100,
+            min: 0,
+        }),
+        weights: Flags.string({
+            description: 'comma-separated "value:percent" pairs that must sum to 100 (e.g. "true:20,false:80" or "red:33,green:33,blue:34")',
+        }),
+        confirm: Flags.boolean({ description: 'skip the interactive confirmation prompt (useful for scripts and agents)' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SetRollout);
+        // Validate flag exclusivity
+        if (flags['true-percent'] !== undefined && flags.weights) {
+            return this.err('Use either --true-percent or --weights, not both.');
+        }
+        if (flags['true-percent'] === undefined && !flags.weights) {
+            return this.err('Either --true-percent or --weights is required.');
+        }
+        // Validate required args for non-interactive mode
+        if (!args.name && !isInteractive(flags)) {
+            return this.err("'name' argument is required when interactive mode isn't available.");
+        }
+        if (!flags.environment && !isInteractive(flags)) {
+            return this.err("'environment' is required when interactive mode isn't available.");
+        }
+        // Fetch config metadata to validate the key exists
+        const metadataRequest = await this.apiClient.post('/api/v1/metadata/list', { workspaceId: this.workspaceId });
+        if (!metadataRequest.ok) {
+            const errorMsg = metadataRequest.error?.error || `Failed to fetch configs: ${metadataRequest.status}`;
+            return this.err(errorMsg, { serverError: metadataRequest.error });
+        }
+        const metadataResponse = metadataRequest.json;
+        const configs = metadataResponse.configs;
+        let key = args.name;
+        if (!key && isInteractive(flags)) {
+            const { default: autocomplete } = await import('../util/autocomplete.js');
+            const selected = await autocomplete({
+                message: 'Which flag would you like to configure a rollout for?',
+                source: configs.map((c) => c.key),
+            });
+            if (selected)
+                key = selected;
+        }
+        if (!key) {
+            return this.err("'name' argument is required when interactive mode isn't available.");
+        }
+        const config = configs.find((c) => c.key === key);
+        if (!config) {
+            return this.err(`Could not find config named ${key}`);
+        }
+        // Get environment
+        const environment = await getEnvironment({
+            command: this,
+            flags,
+            message: 'Which environment would you like to configure the rollout for?',
+            providedEnvironment: flags.environment,
+        });
+        if (!environment)
+            return;
+        // Build weighted values
+        let weightedValues;
+        if (flags['true-percent'] !== undefined) {
+            const truePercent = flags['true-percent'];
+            const falsePercent = 100 - truePercent;
+            weightedValues = [
+                { value: { type: 'bool', value: true }, weight: truePercent * (WEIGHT_TOTAL / 100) },
+                { value: { type: 'bool', value: false }, weight: falsePercent * (WEIGHT_TOTAL / 100) },
+            ];
+        }
+        else {
+            // Parse --weights "value1:N,value2:M,..."
+            const parsed = this.parseWeights(flags.weights, config.valueType);
+            if (!parsed.ok) {
+                return this.err(parsed.error);
+            }
+            weightedValues = parsed.weights;
+        }
+        const totalWeight = weightedValues.reduce((sum, wv) => sum + wv.weight, 0);
+        if (totalWeight !== WEIGHT_TOTAL) {
+            return this.err(`Weights must sum to 100. Got: ${weightedValues.map((wv) => `${wv.weight / 1000}%`).join(' + ')} = ${totalWeight / 1000}%`);
+        }
+        const rolloutValue = {
+            type: 'weighted_values',
+            value: {
+                hashByPropertyName: flags['hash-by'],
+                weightedValues,
+            },
+        };
+        const rolloutDescription = weightedValues
+            .map((wv) => `${wv.weight / 1000}% → ${JSON.stringify(wv.value.value)}`)
+            .join(', ');
+        const message = `Confirm: set rollout for ${key} in ${environment.name} to [${rolloutDescription}]? yes/no`;
+        if (!(await getConfirmation({ flags, message }))) {
+            return;
+        }
+        // Fetch the current full config to get commitSha and existing environments
+        const detailRequest = await this.apiClient.post('/api/v1/metadata/getByKey', {
+            workspaceId: this.workspaceId,
+            key,
+        });
+        if (!detailRequest.ok) {
+            return this.err(`Failed to fetch config details: ${detailRequest.status}`);
+        }
+        const currentConfig = detailRequest.json;
+        const newRule = { criteria: [], value: rolloutValue };
+        const envKey = environment.name;
+        const existingEnvs = currentConfig.environments ?? [];
+        const hasEnv = existingEnvs.some((e) => e.id === envKey);
+        const updatedEnvironments = hasEnv
+            ? existingEnvs.map((e) => (e.id === envKey ? { ...e, rules: [newRule] } : e))
+            : [...existingEnvs, { id: envKey, rules: [newRule] }];
+        const updateFields = { environments: updatedEnvironments };
+        this.verboseLog('Update fields:', JSON.stringify(updateFields, null, 2));
+        let request;
+        if (config.type === 'feature_flag') {
+            request = await this.apiClient.post('/api/v1/flags/update', {
+                expectedCommitSha: currentConfig.commitSha,
+                flag: updateFields,
+                flagKey: key,
+                workspaceId: this.workspaceId,
+            });
+        }
+        else {
+            request = await this.apiClient.post('/api/v1/configs/update', {
+                config: updateFields,
+                configKey: key,
+                expectedCommitSha: currentConfig.commitSha,
+                workspaceId: this.workspaceId,
+            });
+        }
+        if (request.ok) {
+            this.log(`${checkmark} Rollout set: ${key} in ${environment.name} → [${rolloutDescription}]`);
+            return {
+                environment: { id: environment.id, name: environment.name },
+                hashByPropertyName: flags['hash-by'],
+                key,
+                rollout: rolloutDescription,
+                success: true,
+                weightedValues,
+            };
+        }
+        this.verboseLog(request.error);
+        return this.err(`Failed to set rollout: ${request.status} | ${JSON.stringify(request.error)}`, { key, serverError: request.error });
+    }
+    parseWeights(weightsStr, valueType) {
+        const pairs = weightsStr.split(',').map((s) => s.trim());
+        const weights = [];
+        let totalPercent = 0;
+        for (const pair of pairs) {
+            const colonIdx = pair.lastIndexOf(':');
+            if (colonIdx === -1) {
+                return {
+                    error: `Invalid weight entry "${pair}". Expected format "value:percent" (e.g. "true:20").`,
+                    ok: false,
+                };
+            }
+            const rawValue = pair.slice(0, colonIdx).trim();
+            const percentStr = pair.slice(colonIdx + 1).trim();
+            const percent = Number(percentStr);
+            if (Number.isNaN(percent) || percent < 0 || percent > 100) {
+                return { error: `Invalid percent "${percentStr}" in "${pair}". Must be 0–100.`, ok: false };
+            }
+            const typedValue = this.coerceValue(rawValue, valueType);
+            if (!typedValue.ok) {
+                return { error: typedValue.error, ok: false };
+            }
+            weights.push({ value: typedValue.typed, weight: percent * (WEIGHT_TOTAL / 100) });
+            totalPercent += percent;
+        }
+        if (Math.round(totalPercent) !== 100) {
+            return { error: `Weights must sum to 100. Got: ${totalPercent}%.`, ok: false };
+        }
+        return { ok: true, weights };
+    }
+    coerceValue(raw, valueType) {
+        const type = valueType.toLowerCase();
+        switch (type) {
+            case 'bool': {
+                if (raw !== 'true' && raw !== 'false') {
+                    return { error: `Invalid boolean value "${raw}". Must be "true" or "false".`, ok: false };
+                }
+                return { ok: true, typed: { type: 'bool', value: raw === 'true' } };
+            }
+            case 'int': {
+                const n = Number.parseInt(raw, 10);
+                if (Number.isNaN(n)) {
+                    return { error: `Invalid int value "${raw}".`, ok: false };
+                }
+                return { ok: true, typed: { type: 'int', value: n } };
+            }
+            case 'double': {
+                const n = Number.parseFloat(raw);
+                if (Number.isNaN(n)) {
+                    return { error: `Invalid double value "${raw}".`, ok: false };
+                }
+                return { ok: true, typed: { type: 'double', value: n } };
+            }
+            default: {
+                // string, json, etc — pass as-is
+                return { ok: true, typed: { type, value: raw } };
+            }
+        }
+    }
+}

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>;
+}

package/dist/commands/workspace/switch.js

@@ -0,0 +1,90 @@
+import { select } from '@inquirer/prompts';
+import { BaseCommand } from '../../index.js';
+import { getApiUrl } from '../../util/domain-urls.js';
+import { getValidAccessToken } from '../../util/get-valid-token.js';
+import { loadAuthConfig, saveAuthConfig } from '../../util/token-storage.js';
+export default class WorkspaceSwitch extends BaseCommand {
+    static description = 'Switch to a different workspace';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        // Get a valid token — refresh silently if needed, error if not logged in
+        let accessToken;
+        try {
+            accessToken = await getValidAccessToken();
+        }
+        catch {
+            return this.err('Not logged in. Run `qfg login` first.');
+        }
+        const authConfig = await loadAuthConfig();
+        if (!authConfig) {
+            return this.err('Not logged in. Run `qfg login` first.');
+        }
+        // Fetch all workspaces the user has access to
+        const apiUrl = getApiUrl();
+        let candidates = [];
+        try {
+            const res = await fetch(`${apiUrl}/api/v1/userWorkspaces/list`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${accessToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ json: {} }),
+            });
+            if (!res.ok) {
+                return this.err(`Failed to fetch workspaces (${res.status}). Try \`qfg login\` to re-authenticate.`);
+            }
+            const body = await res.json();
+            const all = (body.json ?? body);
+            candidates = Array.isArray(all) ? all : [];
+        }
+        catch (error) {
+            return this.err(`Failed to fetch workspaces: ${String(error)}`);
+        }
+        if (candidates.length === 0) {
+            return this.err('No workspaces found for your account.');
+        }
+        // Pick workspace
+        let match;
+        if (candidates.length === 1) {
+            match = candidates[0];
+            this.log(`Only one workspace available: ${match.organizationName} / ${match.workspaceSlug}`);
+        }
+        else {
+            const chosen = await select({
+                choices: candidates.map((w) => ({
+                    name: `${w.organizationName} / ${w.workspaceSlug}`,
+                    value: w.workspaceId,
+                })),
+                message: 'Select workspace:',
+            });
+            const found = candidates.find((w) => w.workspaceId === chosen);
+            if (!found)
+                return this.err('No workspace selected.');
+            match = found;
+        }
+        // Save as the default profile
+        const defaultProfile = authConfig.defaultProfile || 'default';
+        await saveAuthConfig({
+            ...authConfig,
+            profiles: {
+                ...authConfig.profiles,
+                [defaultProfile]: {
+                    workspace: match.workspaceId,
+                    workspaceName: match.workspaceSlug,
+                    workspaceSlug: match.workspaceSlug,
+                    organizationName: match.organizationName,
+                },
+            },
+        });
+        this.log(`\nSwitched to: ${match.organizationName} / ${match.workspaceSlug}`);
+        this.log(`\nTo use this workspace in a project, add to your .env:`);
+        this.log(`  QUONFIG_WORKSPACE=${match.workspaceSlug}`);
+        return {
+            organizationName: match.organizationName,
+            success: true,
+            workspaceId: match.workspaceId,
+            workspaceSlug: match.workspaceSlug,
+        };
+    }
+}

package/dist/commands/workspace.js

@@ -1,38 +1,29 @@
 import { BaseCommand } from '../index.js';
 import { getActiveProfile, loadAuthConfig } from '../util/token-storage.js';
 export default class Workspace extends BaseCommand {
-    static description = 'Display current workspace. To switch workspaces, run `qfg login --profile <name>`.';
+    static description = 'Show the current workspace';
     static examples = ['<%= config.bin %> <%= command.id %>'];
     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.');
+            return this.err('Not logged in. Run `qfg login` first.');
         }
-        // Get the active profile
-        const activeProfile = getActiveProfile();
-        const profile = authConfig.profiles[activeProfile] || authConfig.profiles[authConfig.defaultProfile || 'default'];
+        const activeProfileName = getActiveProfile();
+        const profile = authConfig.profiles[activeProfileName] || authConfig.profiles[authConfig.defaultProfile || 'default'];
         if (!profile) {
-            return this.err('No active profile found. Please run `qfg login` first.');
-        }
-        this.log(`Active profile: ${activeProfile}`);
-        this.log(`Workspace: ${profile.workspaceName || profile.workspace}`);
-        // Show all profiles if more than one
-        const profileNames = Object.keys(authConfig.profiles);
-        if (profileNames.length > 1) {
-            this.log('\nAll profiles:');
-            for (const name of profileNames) {
-                const p = authConfig.profiles[name];
-                const marker = name === activeProfile ? ' (active)' : '';
-                this.log(`  ${name}: ${p.workspaceName || p.workspace}${marker}`);
-            }
-            this.log('\nTo switch, use: qfg login --profile <name>');
-            this.log('To change default: qfg profile');
+            return this.err('No workspace configured. Run `qfg login` first.');
         }
+        const workspaceSlug = profile.workspaceSlug || profile.workspaceName || profile.workspace;
+        const orgLine = profile.organizationName ? `${profile.organizationName} / ` : '';
+        this.log(`Workspace:    ${orgLine}${workspaceSlug}`);
+        this.log(`ID:           ${profile.workspace}`);
+        this.log(`\nTo switch:    qfg workspace switch`);
+        this.log(`To pin in a project, add to .env:`);
+        this.log(`  QUONFIG_WORKSPACE=${workspaceSlug}`);
         return {
-            activeProfile,
-            profiles: Object.fromEntries(profileNames.map((name) => [name, authConfig.profiles[name]])),
+            organizationName: profile.organizationName,
             workspace: profile.workspace,
-            workspaceName: profile.workspaceName,
+            workspaceSlug,
         };
     }
 }

package/dist/index.d.ts

@@ -23,6 +23,7 @@ export declare abstract class BaseCommand extends Command {
 }
 export declare abstract class APICommand extends BaseCommand {
     static baseFlags: {
+        workspace: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         profile: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         interactive: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         'no-color': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;

package/dist/index.js

@@ -84,10 +84,17 @@ export class BaseCommand extends Command {
 export class APICommand extends BaseCommand {
     static baseFlags = {
         ...globalFlags,
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace slug to use (overrides QUONFIG_WORKSPACE env var and saved default)',
+            helpGroup: 'GLOBAL',
+            required: false,
+        }),
         profile: Flags.string({
             char: 'p',
-            description: 'Profile to use (defaults to ENV var QUONFIG_PROFILE or "default")',
+            description: 'Deprecated: use --workspace instead',
             helpGroup: 'GLOBAL',
+            hidden: true,
             required: false,
         }),
     };
@@ -104,7 +111,7 @@ export class APICommand extends BaseCommand {
     async init() {
         await super.init();
         const { flags } = await this.parse();
-        this.rawApiClient = await rawGetClient(this, undefined, flags.profile);
+        this.rawApiClient = await rawGetClient(this, undefined, flags.workspace ?? flags.profile);
         // For JWT-based auth, we'll need to get environment info from the token
         // For now, set a placeholder - this should be enhanced later
         this.currentEnvironment = { id: 'unknown', projectId: 0 };

package/dist/util/get-client.js

@@ -1,7 +1,7 @@
 import { Client } from '@quonfig/node';
 import { getApiUrl } from '../util/domain-urls.js';
 import jsonMaybe from '../util/json-maybe.js';
-import { getActiveProfile, loadAuthConfig, loadTokens } from '../util/token-storage.js';
+import { getActiveProfile, loadAuthConfig, loadTokens, resolveWorkspaceId } from '../util/token-storage.js';
 import { getValidAccessToken } from '../util/get-valid-token.js';
 import version from '../version.js';
 let clientInstance;
@@ -39,16 +39,39 @@ const getClient = async (command, sdkKey, profile) => {
         catch {
             command.error('Session expired. Please run `qfg login` to re-authenticate.', { exit: 401 });
         }
-        // Get the active profile to find the workspace
-        const activeProfile = getActiveProfile(profile);
-        const profileData = authConfig.profiles[activeProfile] || authConfig.profiles[authConfig.defaultProfile || 'default'];
-        command.verboseLog('Profile lookup', {
-            activeProfile,
-            hasProfileData: Boolean(profileData),
-            workspaceId: profileData?.workspace,
-        });
-        if (profileData) {
-            workspaceId = profileData.workspace;
+        // Resolve workspace: --workspace/QUONFIG_WORKSPACE (slug) → QUONFIG_PROFILE (profile name) → default
+        const workspaceSlugOverride = profile ?? process.env.QUONFIG_WORKSPACE;
+        const profileNameOverride = process.env.QUONFIG_PROFILE;
+        if (workspaceSlugOverride) {
+            // Try slug resolution first, then fall back to treating it as a profile name
+            const resolved = resolveWorkspaceId(authConfig, workspaceSlugOverride);
+            if (resolved) {
+                workspaceId = resolved;
+                command.verboseLog('Workspace lookup', { source: 'slug', slug: workspaceSlugOverride, workspaceId });
+            }
+            else {
+                const profileData = authConfig.profiles[workspaceSlugOverride];
+                if (profileData) {
+                    workspaceId = profileData.workspace;
+                    command.verboseLog('Workspace lookup', { source: 'profile-name', profile: workspaceSlugOverride, workspaceId });
+                }
+                else {
+                    command.error(`Workspace '${workspaceSlugOverride}' not found. Run \`qfg workspace switch\` to select and save a workspace.`, { exit: 1 });
+                }
+            }
+        }
+        else {
+            const activeProfile = getActiveProfile(profileNameOverride);
+            const profileData = authConfig.profiles[activeProfile] || authConfig.profiles[authConfig.defaultProfile || 'default'];
+            command.verboseLog('Workspace lookup', {
+                source: 'default-profile',
+                activeProfile,
+                hasProfileData: Boolean(profileData),
+                workspaceId: profileData?.workspace,
+            });
+            if (profileData) {
+                workspaceId = profileData.workspace;
+            }
         }
     }
     // Store workspaceId on the command for use in building URLs and cache it

package/dist/util/token-storage.d.ts

@@ -15,9 +15,15 @@ export interface AuthConfig {
             workspace: string;
             workspaceName?: string;
             workspaceSlug?: string;
+            organizationName?: string;
         };
     };
 }
+/**
+ * Find a workspace ID by slug across all saved profiles.
+ * Used to resolve QUONFIG_WORKSPACE and --workspace flag values.
+ */
+export declare const resolveWorkspaceId: (config: AuthConfig, slug: string) => string | undefined;
 export declare const saveTokens: (tokens: TokenData, options?: TokenStorageOptions) => Promise<void>;
 export declare const loadTokens: (options?: TokenStorageOptions) => Promise<TokenData | null>;
 export declare const saveAuthConfig: (config: AuthConfig, options?: TokenStorageOptions) => Promise<void>;

package/dist/util/token-storage.js

@@ -9,6 +9,18 @@ const getTokenFile = (options) => {
     return path.join(getQuonfigDir(options), filename);
 };
 const getConfigFile = (options) => path.join(getQuonfigDir(options), 'config');
+/**
+ * Find a workspace ID by slug across all saved profiles.
+ * Used to resolve QUONFIG_WORKSPACE and --workspace flag values.
+ */
+export const resolveWorkspaceId = (config, slug) => {
+    for (const profile of Object.values(config.profiles)) {
+        if (profile.workspaceSlug === slug || profile.workspaceName === slug) {
+            return profile.workspace;
+        }
+    }
+    return undefined;
+};
 const ensureQuonfigDir = async (options) => {
     const quonfigDir = getQuonfigDir(options);
     try {
@@ -52,6 +64,9 @@ export const saveAuthConfig = async (config, options) => {
         if (profileData.workspaceSlug) {
             configContent += `workspace_slug = ${profileData.workspaceSlug}\n`;
         }
+        if (profileData.organizationName) {
+            configContent += `organization_name = ${profileData.organizationName}\n`;
+        }
         configContent += '\n';
     }
     const configTarget = getConfigFile(options);
@@ -78,12 +93,14 @@ export const loadAuthConfig = async (options) => {
             const block = match[2];
             const workspaceMatch = block.match(/workspace\s*=\s*([^\s#]+)(?:\s*#\s*(.+))?/);
             const slugMatch = block.match(/workspace_slug\s*=\s*(\S+)/);
+            const orgMatch = block.match(/organization_name\s*=\s*(.+)/);
             if (!workspaceMatch)
                 continue;
             config.profiles[profileName] = {
                 workspace: workspaceMatch[1],
                 workspaceName: workspaceMatch[2]?.trim(),
                 workspaceSlug: slugMatch?.[1]?.trim(),
+                organizationName: orgMatch?.[1]?.trim(),
             };
         }
         return Object.keys(config.profiles).length > 0 ? config : null;