@quonfig/cli 0.0.5 → 0.0.7

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/interactive-prompt.js

@@ -1,12 +1,10 @@
 import Create from './commands/create.js';
-import Download from './commands/download.js';
 import GenerateNewHexKey from './commands/generate-new-hex-key.js';
 import Get from './commands/get.js';
 import Info from './commands/info.js';
 import List from './commands/list.js';
 import Mcp from './commands/mcp.js';
 import Override from './commands/override.js';
-import Serve from './commands/serve.js';
 import SetDefault from './commands/set-default.js';
 import { APICommand } from './index.js';
 import getString from './ui/get-string.js';
@@ -23,11 +21,9 @@ const commands = [
     Create,
     Get,
     Info,
-    Download,
     Mcp,
     Override,
     List,
-    Serve,
 ].map((command) => {
     const id = convertToKebabCase(command.name);
     return {

package/dist/ui/get-value.js

@@ -7,7 +7,10 @@ const getValue = async ({ allowBlank = true, desiredValue, environment, flags, k
         return failure(`No value provided for ${key}`);
     }
     if (!key) {
-        const value = desiredValue ?? (await promptForValue({ allowBlank, message }));
+        if (desiredValue !== undefined) {
+            return success(desiredValue);
+        }
+        const value = await promptForValue({ allowBlank, message });
         if (value === undefined || value === null) {
             return noop();
         }

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;

package/dist/verify/validate.js

@@ -387,12 +387,22 @@ export function validateWorkspace(workspaceDir) {
                 }
                 segmentKeys.add(config.key);
             }
-            if (config.type === "log_level" && config.valueType !== "log_level") {
-                issues.push({
-                    file: relPath,
-                    message: `Log level must have valueType "log_level", got "${config.valueType}"`,
-                    severity: "error",
-                });
+            if (config.type === "log_level") {
+                if (config.valueType !== "log_level") {
+                    issues.push({
+                        file: relPath,
+                        message: `Log level must have valueType "log_level", got "${config.valueType}"`,
+                        severity: "error",
+                    });
+                }
+                if (!config.key.startsWith("log-level.")) {
+                    issues.push({
+                        file: relPath,
+                        message: `Log level key "${config.key}" must start with "log-level."`,
+                        severity: "error",
+                        suggestion: `Rename to "log-level.${config.key}" (and rename the file to "log-level.${config.key}.json")`,
+                    });
+                }
             }
             // Validate environment IDs are slugs, not UUIDs
             validateEnvironmentIds(config.environments, relPath, issues);
@@ -661,8 +671,18 @@ export function validateFileMap(files) {
             }
             segmentKeys.add(config.key);
         }
-        if (config.type === "log_level" && config.valueType !== "log_level") {
-            issues.push({ file: relPath, message: `Log level must have valueType "log_level", got "${config.valueType}"`, severity: "error" });
+        if (config.type === "log_level") {
+            if (config.valueType !== "log_level") {
+                issues.push({ file: relPath, message: `Log level must have valueType "log_level", got "${config.valueType}"`, severity: "error" });
+            }
+            if (!config.key.startsWith("log-level.")) {
+                issues.push({
+                    file: relPath,
+                    message: `Log level key "${config.key}" must start with "log-level."`,
+                    severity: "error",
+                    suggestion: `Rename to "log-level.${config.key}" (and rename the file to "log-level.${config.key}.json")`,
+                });
+            }
         }
         validateEnvironmentIds(config.environments, relPath, issues);
         validateRules(config.default.rules, relPath, "default", config.valueType, issues, config.variants);