@quonfig/cli 0.0.5 → 0.0.6

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/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;