@quonfig/cli 0.0.1

package/dist/commands/login.js

@@ -0,0 +1,124 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../index.js';
+import { decodeJWT, pollForToken, requestDeviceCode } from '../util/oauth-client.js';
+import { getApiUrl } from '../util/domain-urls.js';
+import { loadAuthConfig, saveAuthConfig, saveTokens } from '../util/token-storage.js';
+export default class Login extends BaseCommand {
+    static description = 'Log in to Quonfig via WorkOS device authorization';
+    static examples = ['<%= config.bin %> <%= command.id %>', '<%= config.bin %> <%= command.id %> --profile myprofile'];
+    static flags = {
+        profile: Flags.string({
+            char: 'p',
+            description: 'Profile name to create or update (defaults to "default")',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Login);
+        const profileName = flags.profile || 'default';
+        // Step 1: Request device code from WorkOS
+        this.verboseLog('Requesting device authorization code...');
+        const deviceAuth = await requestDeviceCode();
+        // Step 2: Display code and URL to user
+        this.log(`\nTo authenticate, visit:\n`);
+        this.log(`  ${deviceAuth.verification_uri_complete}\n`);
+        this.log(`Or go to ${deviceAuth.verification_uri} and enter code: ${deviceAuth.user_code}\n`);
+        this.log('Waiting for authentication...');
+        // Step 3: Poll for token
+        const tokenResponse = await pollForToken(deviceAuth.device_code, deviceAuth.interval, deviceAuth.expires_in, this.isVerbose);
+        const user = tokenResponse.user;
+        const userEmail = user.email;
+        // Decode JWT to inspect claims
+        if (this.isVerbose) {
+            const payload = decodeJWT(tokenResponse.access_token);
+            this.verboseLog('\n=== Decoded JWT Payload ===');
+            this.verboseLog(JSON.stringify(payload, null, 2));
+            this.verboseLog('===========================\n');
+        }
+        // Extract org_id from JWT (WorkOS scopes the token to the selected org)
+        const jwtPayload = decodeJWT(tokenResponse.access_token);
+        const orgId = jwtPayload.org_id || user.organization_id;
+        // Use the JWT's actual exp claim for expiry
+        let expiresAt = Date.now() + 300 * 1000; // fallback: 5 minutes
+        if (typeof jwtPayload.exp === 'number') {
+            expiresAt = jwtPayload.exp * 1000;
+        }
+        // Save tokens
+        await saveTokens({
+            accessToken: tokenResponse.access_token,
+            expiresAt,
+            refreshToken: tokenResponse.refresh_token,
+            userEmail,
+            userId: user.id,
+        });
+        // Resolve org_id → workspace UUID via the API
+        let workspaceId;
+        let workspaceName;
+        try {
+            const apiUrl = getApiUrl();
+            this.verboseLog('Resolving workspace...', { apiUrl, orgId });
+            const res = await fetch(`${apiUrl}/api/v1/userWorkspaces/list`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${tokenResponse.access_token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ json: {} }),
+            });
+            if (res.ok) {
+                const body = await res.json();
+                const workspaces = body.json ?? body;
+                const match = Array.isArray(workspaces)
+                    ? workspaces.find((w) => w.workosOrgId === orgId) ?? workspaces[0]
+                    : undefined;
+                if (match) {
+                    workspaceId = match.workspaceId;
+                    workspaceName = match.organizationName;
+                    this.verboseLog('Resolved workspace', { workspaceId, workspaceName });
+                }
+            }
+            else {
+                this.verboseLog('Failed to resolve workspace', { status: res.status });
+            }
+        }
+        catch (error) {
+            this.verboseLog('Failed to resolve workspace', { error: String(error) });
+        }
+        // Get or create config with profile
+        const existingConfig = await loadAuthConfig();
+        // Save auth config
+        const isFirstProfile = !existingConfig || Object.keys(existingConfig.profiles).length === 0;
+        const shouldSetDefault = isFirstProfile || profileName === 'default' || !existingConfig?.defaultProfile;
+        await saveAuthConfig({
+            defaultProfile: shouldSetDefault ? profileName : existingConfig?.defaultProfile,
+            profiles: {
+                ...existingConfig?.profiles,
+                [profileName]: {
+                    workspace: workspaceId || orgId || 'unknown',
+                    workspaceName: workspaceName || (orgId ? `org:${orgId}` : undefined),
+                },
+            },
+        });
+        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})`);
+        }
+        else if (orgId) {
+            this.log(`Organization: ${orgId}`);
+        }
+        return {
+            email: userEmail,
+            organizationId: orgId,
+            profile: profileName,
+            success: true,
+            userId: user.id,
+            workspaceId,
+        };
+    }
+}

package/dist/commands/logout.d.ts

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

package/dist/commands/logout.js

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../index.js';
+import { clearAuth } from '../util/token-storage.js';
+export default class Logout extends BaseCommand {
+    static description = 'Log out and clear stored authentication tokens';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        await clearAuth();
+        this.log('Successfully logged out!');
+        this.log('Authentication tokens have been cleared.');
+        return { success: true };
+    }
+}

package/dist/commands/mcp.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../index.js';
+export default class Mcp extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        editor: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        url: 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>;
+        verbose: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/mcp.js

@@ -0,0 +1,145 @@
+import { Flags } from '@oclif/core';
+import { parse as parseJSON, stringify as stringifyJSON } from 'comment-json';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { BaseCommand } from '../index.js';
+import { ConfigPaths, SupportedEditors, getServersConfig, resolveConfigPath } from '../services/mcp.js';
+import autocomplete from '../util/autocomplete.js';
+import { green } from '../util/color.js';
+import isInteractive from '../util/is-interactive.js';
+export default class Mcp extends BaseCommand {
+    static description = 'Configure Quonfig MCP server for your AI assistant';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --editor cursor',
+        '<%= config.bin %> <%= command.id %> --url http://local-app.goatsofquonfig.com:3003/api/v1/mcp',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        editor: Flags.string({
+            description: 'Editor to configure (cursor, vscode, claude, windsurf)',
+            options: [...SupportedEditors],
+        }),
+        url: Flags.string({
+            description: 'Internal URL for testing (defaults to https://app.quonfig.com/api/v1/mcp)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Mcp);
+        // Select Editor
+        let selectedEditor;
+        if (flags.editor) {
+            selectedEditor = flags.editor;
+        }
+        else if (isInteractive(flags)) {
+            const editorChoice = await autocomplete({
+                message: green('Which editor do you want to configure?'),
+                source: SupportedEditors.map((editor) => ConfigPaths[editor].name),
+            });
+            if (!editorChoice) {
+                return this.error('Editor selection is required');
+            }
+            // Find the editor key by name
+            selectedEditor = Object.keys(ConfigPaths).find((key) => ConfigPaths[key].name === editorChoice);
+        }
+        else {
+            return this.error('--editor flag is required when interactive mode is not available');
+        }
+        // Determine config paths
+        const cwd = process.cwd();
+        const globalPath = resolveConfigPath(selectedEditor, false);
+        const localPath = resolveConfigPath(selectedEditor, true);
+        const fullLocalPath = localPath ? join(cwd, localPath) : undefined;
+        if (!globalPath) {
+            return this.error(`Unsupported platform for editor: ${selectedEditor}`);
+        }
+        // Determine scope (global vs local)
+        let configPathType = 'global';
+        if (fullLocalPath && isInteractive(flags)) {
+            const scopeChoice = await autocomplete({
+                message: green('Configure global or project-local settings?'),
+                source: [`Local (${relative(cwd, fullLocalPath)})`, `Global (${globalPath})`],
+            });
+            if (!scopeChoice) {
+                return this.error('Scope selection is required');
+            }
+            configPathType = scopeChoice.startsWith('Local') ? 'local' : 'global';
+        }
+        const configPath = configPathType === 'local' ? fullLocalPath : globalPath;
+        const displayConfigPath = configPathType === 'local' ? relative(cwd, configPath) : configPath;
+        this.log(`Configuring ${ConfigPaths[selectedEditor].name} at ${displayConfigPath}`);
+        // Read/Parse existing config
+        let editorConfig = {};
+        if (existsSync(configPath)) {
+            try {
+                const content = readFileSync(configPath, 'utf8');
+                const parsed = parseJSON(content);
+                editorConfig = (parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {});
+                this.log(`✓ Read existing configuration`);
+            }
+            catch (error) {
+                return this.error(`Failed to parse configuration file: ${error}`);
+            }
+        }
+        else {
+            this.log(`Configuration file not found, creating new one`);
+        }
+        // Get servers config section
+        const serversConfig = getServersConfig(editorConfig);
+        // Check for existing Quonfig entries
+        const existingQuonfigEntries = Object.keys(serversConfig).filter((key) => /quonfig/i.test(key));
+        // Determine entry key
+        let targetEntryKey = 'quonfig';
+        if (existingQuonfigEntries.length > 0 && isInteractive(flags)) {
+            const choices = [`Add: ${targetEntryKey}`, ...existingQuonfigEntries.map((key) => `Update: ${key}`)];
+            const choice = await autocomplete({
+                message: green('Add a new MCP server or update an existing one?'),
+                source: choices,
+            });
+            if (!choice) {
+                return this.error('MCP server selection is required');
+            }
+            if (choice.startsWith('Update:')) {
+                targetEntryKey = choice.replace('Update: ', '');
+                this.log(`Updating existing MCP server entry: ${targetEntryKey}`);
+            }
+            else {
+                this.log(`Adding new MCP server entry: ${targetEntryKey}`);
+            }
+        }
+        else if (existingQuonfigEntries.length > 0) {
+            // Non-interactive mode with existing entries - update the first one
+            targetEntryKey = existingQuonfigEntries[0];
+            this.log(`Updating existing MCP server entry: ${targetEntryKey}`);
+        }
+        else {
+            this.log(`Adding new MCP server entry: ${targetEntryKey}`);
+        }
+        // Construct MCP endpoint URL and config
+        const mcpUrl = flags.url || 'https://app.quonfig.com/api/v1/mcp';
+        if (selectedEditor === 'claude-code') {
+            serversConfig[targetEntryKey] = {
+                type: 'http',
+                url: mcpUrl,
+            };
+        }
+        else {
+            serversConfig[targetEntryKey] = {
+                url: mcpUrl,
+            };
+        }
+        // Write config file
+        try {
+            // Ensure directory exists
+            mkdirSync(dirname(configPath), { recursive: true });
+            const configString = stringifyJSON(editorConfig, null, 2);
+            writeFileSync(configPath, configString);
+            this.log(`✓ Configuration updated successfully`);
+            this.log('');
+            this.log('You may need to restart your editor for changes to take effect.');
+        }
+        catch (error) {
+            return this.error(`Failed to write configuration file: ${error}`);
+        }
+    }
+}

package/dist/commands/override.d.ts

@@ -0,0 +1,17 @@
+import { APICommand } from '../index.js';
+import { JsonObj } from '../result.js';
+export default class Override extends APICommand {
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    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>;
+        remove: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        value: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<JsonObj | void>;
+    private removeOverride;
+    private setOverride;
+}

package/dist/commands/override.js

@@ -0,0 +1,170 @@
+import { Flags } from '@oclif/core';
+import { APICommand } from '../index.js';
+import getEnvironment from '../ui/get-environment.js';
+import getString from '../ui/get-string.js';
+import autocomplete from '../util/autocomplete.js';
+import { checkmark } from '../util/color.js';
+import isInteractive from '../util/is-interactive.js';
+import nameArg from '../util/name-arg.js';
+export default class Override extends APICommand {
+    static args = { ...nameArg };
+    static description = 'Override the value of an item for your user/SDK key combo';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> # will prompt for name and value',
+        '<%= config.bin %> <%= command.id %> my.flag.name --value=true',
+        '<%= config.bin %> <%= command.id %> my.flag.name --remove',
+        '<%= config.bin %> <%= command.id %> my.double.config --value=3.14159',
+    ];
+    static flags = {
+        environment: Flags.string({ description: 'environment to override in' }),
+        remove: Flags.boolean({ default: false, description: 'remove your override (if present)' }),
+        value: Flags.string({ description: 'value to use for your override' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Override);
+        if (flags.remove && flags.value) {
+            this.err('remove and value flags are mutually exclusive');
+        }
+        // Fetch all configs from metadata endpoint
+        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;
+        // Get the environment
+        const environment = await getEnvironment({
+            command: this,
+            flags,
+            message: 'Which environment would you like to override in?',
+            providedEnvironment: flags.environment,
+        });
+        if (!environment) {
+            return;
+        }
+        // Get the key - from args or prompt
+        let key = args.name;
+        if (!key && isInteractive(flags)) {
+            const configKeys = configs.map((c) => c.key);
+            const selectedKey = await autocomplete({
+                message: 'Which item would you like to override?',
+                source: configKeys,
+            });
+            if (selectedKey) {
+                key = selectedKey;
+            }
+        }
+        if (!key) {
+            return this.err('Key is required');
+        }
+        const config = configs.find((c) => c.key === key);
+        if (!config) {
+            return this.err(`Could not find config named ${key}`);
+        }
+        this.verboseLog('Selected config:', config);
+        if (flags.remove) {
+            return this.removeOverride(key, environment.id, config.version);
+        }
+        // Get the value
+        let value = flags.value;
+        if (!value && isInteractive(flags)) {
+            value = await getString({
+                allowBlank: false,
+                message: 'Override value',
+            });
+        }
+        if (!value) {
+            return this.err('Value is required');
+        }
+        return this.setOverride(config, value, environment.id);
+    }
+    async removeOverride(key, environmentId, currentVersionId) {
+        const request = await this.apiClient.post('/internal/ops/v1/remove-variant', {
+            configKey: key,
+            currentVersionId,
+            environmentId,
+        });
+        if (request.ok) {
+            this.log(`${checkmark} Override removed`);
+            return;
+        }
+        // Handle 404 case - no override exists to remove
+        if (request.status === 404) {
+            this.log(`No override found for ${key}`);
+            return;
+        }
+        this.err(`Failed to remove override: ${request.status}`, { key, serverError: request.error });
+    }
+    async setOverride(config, value, environmentId) {
+        const { key, valueType, version } = config;
+        // Map the valueType to the format expected by the API
+        /* eslint-disable camelcase */
+        const typeMapping = {
+            bool: 'bool',
+            string: 'string',
+            int: 'int',
+            double: 'double',
+            string_list: 'stringList',
+            json: 'json',
+            limit_definition: 'limitDefinition',
+            duration: 'duration',
+            int_range: 'intRange',
+        };
+        /* eslint-enable camelcase */
+        const type = typeMapping[valueType.toLowerCase()] || valueType;
+        // Parse the value based on type and build variant object
+        let variantValue = value;
+        let variantType = type;
+        switch (type) {
+            case 'stringList': {
+                variantValue = value.split(',');
+                variantType = 'string_list';
+                break;
+            }
+            case 'bool': {
+                variantValue = value.toLowerCase() === 'true';
+                break;
+            }
+            case 'int': {
+                variantValue = Number.parseInt(value, 10);
+                break;
+            }
+            case 'double': {
+                variantValue = Number.parseFloat(value);
+                break;
+            }
+            case 'json': {
+                try {
+                    variantValue = JSON.parse(value);
+                }
+                catch {
+                    return this.err(`Invalid JSON value: ${value}`);
+                }
+                break;
+            }
+            case 'string': {
+                variantValue = value;
+                break;
+            }
+            // No default
+        }
+        const request = await this.apiClient.post('/internal/ops/v1/assign-variant', {
+            configKey: key,
+            currentVersionId: version,
+            environmentId,
+            variant: {
+                type: variantType,
+                value: variantValue,
+            },
+        });
+        if (request.ok) {
+            this.log(`${checkmark} Override set`);
+            return { key, success: true };
+        }
+        const errMsg = request.status === 400
+            ? `Failed to override value: ${request.status} -- is ${value} a valid ${type}?`
+            : `Failed to override value: ${request.status}`;
+        this.err(errMsg, { key, serverError: request.error });
+    }
+}

package/dist/commands/profile.d.ts

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

package/dist/commands/profile.js

@@ -0,0 +1,47 @@
+import { select } from '@inquirer/prompts';
+import { BaseCommand } from '../index.js';
+import { loadAuthConfig, saveAuthConfig } from '../util/token-storage.js';
+export default class Profile extends BaseCommand {
+    static description = 'Manage profiles and set default profile';
+    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.');
+        }
+        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,
+        };
+    }
+}

package/dist/commands/schema.d.ts

@@ -0,0 +1,21 @@
+import { APICommand } from '../index.js';
+import { JsonObj } from '../result.js';
+export default class Schema extends APICommand {
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        get: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        protected: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'set-json-schema': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'set-zod': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<JsonObj | void>;
+    private getSchema;
+    private upsertSchema;
+    private fetchSchema;
+    private createSchema;
+    private updateSchema;
+}