@quonfig/cli 0.0.1

package/dist/commands/schema.js

@@ -0,0 +1,168 @@
+import { readFileSync } from 'node:fs';
+import { Args, Flags } from '@oclif/core';
+import { APICommand } from '../index.js';
+import { checkmark } from '../util/color.js';
+const isSchemaDocument = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+const loadSchemaDocument = (input) => {
+    const source = input.trim().startsWith('@') ? readFileSync(input.trim().slice(1), 'utf8') : input;
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Schema documents must be valid JSON Schema objects: ${message}`);
+    }
+    if (!isSchemaDocument(parsed)) {
+        throw new Error('Schema documents must be JSON objects.');
+    }
+    return parsed;
+};
+export default class Schema extends APICommand {
+    static args = {
+        name: Args.string({ description: 'schema key', required: true }),
+    };
+    static description = 'Get or update first-class schema documents';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-schema --get',
+        '<%= config.bin %> <%= command.id %> my-schema --set-json-schema=\'{"type":"object","properties":{}}\'',
+        '<%= config.bin %> <%= command.id %> my-schema --set-json-schema=@schemas/my-schema.json --protected',
+    ];
+    static flags = {
+        get: Flags.boolean({ description: 'get the schema document' }),
+        protected: Flags.boolean({ default: false, description: 'store the schema in protected storage' }),
+        'set-json-schema': Flags.string({
+            description: 'set a plain JSON Schema document (inline JSON or @file path)',
+        }),
+        'set-zod': Flags.string({
+            description: 'compatibility alias for --set-json-schema; now expects plain JSON Schema',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Schema);
+        if (!this.workspaceId) {
+            return this.err('Workspace ID not found. Please run `qfg login`.');
+        }
+        const schemaKey = args.name;
+        const schemaInput = flags['set-json-schema'] ?? flags['set-zod'];
+        if (flags.get && schemaInput) {
+            return this.err('Use either --get or --set-json-schema, not both.');
+        }
+        if (!flags.get && !schemaInput) {
+            return this.err('Use --get or --set-json-schema.');
+        }
+        if (flags.get) {
+            return this.getSchema(schemaKey);
+        }
+        return this.upsertSchema(schemaKey, schemaInput, flags.protected);
+    }
+    async getSchema(schemaKey) {
+        const request = await this.apiClient.post('/api/v1/schemas/getByKey', {
+            workspaceId: this.workspaceId,
+            schemaKey,
+        });
+        if (!request.ok) {
+            if (request.status === 404) {
+                return this.err(`Schema ${schemaKey} not found`, {
+                    key: schemaKey,
+                    phase: 'lookup',
+                    serverError: request.error,
+                });
+            }
+            return this.err(`Failed to fetch schema ${schemaKey}: ${request.status} | ${JSON.stringify(request.error)}`, {
+                key: schemaKey,
+                phase: 'lookup',
+                serverError: request.error,
+            });
+        }
+        const response = request.json;
+        if (!isSchemaDocument(response.schema)) {
+            return this.err(`Schema ${schemaKey} returned an invalid document`, {
+                key: schemaKey,
+                phase: 'lookup',
+            });
+        }
+        return this.ok(JSON.stringify(response.schema, null, 2), {
+            commitSha: response.commitSha,
+            key: response.key,
+            protected: response.protected,
+            schema: response.schema,
+        });
+    }
+    async upsertSchema(schemaKey, schemaInput, protectedSchema) {
+        const schema = loadSchemaDocument(schemaInput);
+        const existing = await this.fetchSchema(schemaKey);
+        if (!existing) {
+            return this.createSchema(schemaKey, schema, protectedSchema);
+        }
+        return this.updateSchema(schemaKey, schema, existing, protectedSchema);
+    }
+    async fetchSchema(schemaKey) {
+        const request = await this.apiClient.post('/api/v1/schemas/getByKey', {
+            workspaceId: this.workspaceId,
+            schemaKey,
+        });
+        if (request.ok) {
+            const response = request.json;
+            if (isSchemaDocument(response.schema)) {
+                return response;
+            }
+            return undefined;
+        }
+        if (request.status === 404) {
+            return undefined;
+        }
+        throw new Error(`Failed to fetch schema ${schemaKey}: ${request.status} | ${JSON.stringify(request.error)}`);
+    }
+    async createSchema(schemaKey, schema, protectedSchema) {
+        const request = await this.apiClient.post('/api/v1/schemas/create', {
+            workspaceId: this.workspaceId,
+            schemaKey,
+            protected: protectedSchema,
+            schema,
+        });
+        if (!request.ok) {
+            if (request.status === 409) {
+                const current = await this.fetchSchema(schemaKey);
+                if (current) {
+                    return this.updateSchema(schemaKey, schema, current, protectedSchema);
+                }
+            }
+            return this.err(`Failed to create schema: ${schemaKey} | ${request.status} | ${JSON.stringify(request.error)}`, {
+                key: schemaKey,
+                phase: 'creation',
+                serverError: request.error,
+            });
+        }
+        const response = request.json;
+        return this.ok(`${checkmark} Created schema: ${schemaKey}`, {
+            commitSha: response.commitSha,
+            key: response.key,
+            protected: response.protected,
+            schema: response.schema,
+        });
+    }
+    async updateSchema(schemaKey, schema, existing, protectedSchema) {
+        const request = await this.apiClient.post('/api/v1/schemas/update', {
+            workspaceId: this.workspaceId,
+            schemaKey,
+            protected: protectedSchema,
+            schema,
+            expectedCommitSha: existing.commitSha,
+        });
+        if (!request.ok) {
+            return this.err(`Failed to update schema: ${schemaKey} | ${request.status} | ${JSON.stringify(request.error)}`, {
+                key: schemaKey,
+                phase: 'update',
+                serverError: request.error,
+            });
+        }
+        const response = request.json;
+        return this.ok(`${checkmark} Updated schema: ${schemaKey}`, {
+            commitSha: response.commitSha,
+            key: response.key,
+            protected: response.protected,
+            schema: response.schema,
+        });
+    }
+}

package/dist/commands/serve.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../index.js';
+export default class Serve extends BaseCommand {
+    static args: {
+        'data-file': import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        port: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private requestHandler;
+}

package/dist/commands/serve.js

@@ -0,0 +1,99 @@
+import { Args, Flags } from '@oclif/core';
+import { ConfigType } from '@quonfig/node';
+import * as fs from 'node:fs';
+import http from 'node:http';
+import { BaseCommand } from '../index.js';
+import { initQuonfig } from '../quonfig.js';
+import { valueTypeStringForConfig } from '@quonfig/node';
+import { javaScriptClientFormattedContextToContext } from '../util/context.js';
+const allowCORSPreflight = (res) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, x-quonfig-client-version, authorization');
+};
+const ALWAYS_SEND_CONFIG_TYPES = new Set([ConfigType.FeatureFlag, ConfigType.LogLevel]);
+const base64ToBytes = (base64) => {
+    const binString = Buffer.from(base64, 'base64').toString('binary');
+    return Uint8Array.from(binString, (m) => m.codePointAt(0));
+};
+export default class Serve extends BaseCommand {
+    static args = {
+        'data-file': Args.string({ description: 'file to read', required: true }),
+    };
+    static description = `Serve a datafile on a local port
+
+  You can download a datafile using the \`download\` command.
+
+  You'll need to update your JavaScript (or React) client to point to this server.
+
+  e.g. \`endpoints: ["http://localhost:3099"],\`
+`;
+    static examples = ['<%= config.bin %> <%= command.id %> ./quonfig.test.588.config.json --port=3099 '];
+    static flags = {
+        port: Flags.integer({ default: 3099, description: 'port to serve on' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Serve);
+        const file = args['data-file'];
+        if (!fs.existsSync(file)) {
+            return this.error(`File not found: ${file}`);
+        }
+        let quonfig;
+        try {
+            quonfig = await initQuonfig(this, file);
+            if (!quonfig) {
+                throw new Error('Quonfig not initialized');
+            }
+        }
+        catch (error_) {
+            const error = error_;
+            if (/No projectEnvId found in config/.test(error.message) || /Unexpected end of JSON input/.test(error.message)) {
+                return this.error(`${error.message}\nYour download file seems invalid or corrupt. Please redownload your datafile.`);
+            }
+            return this.error(error);
+        }
+        const { port } = flags;
+        const server = http.createServer(this.requestHandler(quonfig));
+        server.listen(port, (err) => {
+            if (err) {
+                return this.err(err);
+            }
+            console.log(`Server is listening on ${port}. Press ctrl-c to stop.`);
+        });
+    }
+    requestHandler(quonfig) {
+        return (req, res) => {
+            allowCORSPreflight(res);
+            // Handle CORS preflight request
+            if (req.method === 'OPTIONS') {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            const match = req.url?.match(/^\/?\/configs\/eval-with-context\/(.+)$/);
+            if (req.method === 'GET' && match) {
+                const encodedContext = match[1].split('?')[0];
+                console.log(`Received context: ${encodedContext}`);
+                console.log(`Decoded context: ${decodeURIComponent(encodedContext)}`);
+                const decoded = new TextDecoder().decode(base64ToBytes(decodeURIComponent(encodedContext)));
+                const context = javaScriptClientFormattedContextToContext(JSON.parse(decoded));
+                this.log(`${new Date().toISOString()}: Provided context: ${JSON.stringify(context)}`);
+                const config = {};
+                for (const key of quonfig.keys()) {
+                    const raw = quonfig.rawConfig(key);
+                    if (raw && (ALWAYS_SEND_CONFIG_TYPES.has(raw.type) || raw.sendToClientSdk)) {
+                        const valueType = valueTypeStringForConfig(raw) ?? '?';
+                        config[key] = { value: { [valueType]: quonfig.get(key, context) } };
+                    }
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ evaluations: config }));
+            }
+            else {
+                this.verboseLog(`No handler for ${req.method} ${req.url}`);
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Not Found. You can only GET /configs/eval-with-context/<context>');
+            }
+        };
+    }
+}

package/dist/commands/set-default.d.ts

@@ -0,0 +1,20 @@
+import { APICommand } from '../index.js';
+import { JsonObj } from '../result.js';
+export default class SetDefault 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: {
+        secret: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'secret-key-name': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        confirm: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        confidential: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'env-var': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        environment: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        value: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<JsonObj | void>;
+    private submitChange;
+}

package/dist/commands/set-default.js

@@ -0,0 +1,273 @@
+import { Flags } from '@oclif/core';
+import { ProvidedSource } from '@quonfig/node';
+import { APICommand } from '../index.js';
+import { ConfigValueType } from '@quonfig/node';
+import getConfirmation, { confirmFlag } from '../ui/get-confirmation.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 { mapConfigValueToDto } from '../util/config-value-dto.js';
+import { makeConfidentialValue } from '../util/encryption.js';
+import isInteractive from '../util/is-interactive.js';
+import nameArg from '../util/name-arg.js';
+import secretFlags, { parsedSecretFlags } from '../util/secret-flags.js';
+export default class SetDefault extends APICommand {
+    static args = { ...nameArg };
+    static description = 'Set/update the default value for an environment (other rules still apply)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my.flag.name # will prompt for value and env',
+        '<%= config.bin %> <%= command.id %> my.flag.name --value=true --environment=staging',
+        '<%= config.bin %> <%= command.id %> my.flag.name --value=true --secret',
+        '<%= config.bin %> <%= command.id %> my.config.name --env-var=MY_ENV_VAR_NAME --environment=production',
+    ];
+    static flags = {
+        confidential: Flags.boolean({ default: false, description: 'mark the value as confidential' }),
+        'env-var': Flags.string({ description: 'environment variable to use as default value' }),
+        environment: Flags.string({ description: 'environment to change' }),
+        value: Flags.string({ description: 'new default value' }),
+        ...confirmFlag,
+        ...secretFlags('encrypt the value of this item'),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SetDefault);
+        let secret = parsedSecretFlags(flags);
+        if (flags['env-var'] && flags.value) {
+            return this.err('cannot specify both --env-var and --value');
+        }
+        if (flags['env-var'] && secret.selected) {
+            return this.err('cannot specify both --env-var and --secret');
+        }
+        if (flags.confidential && secret.selected) {
+            console.warn("Note: --confidential is implied when using --secret, so you don't need to specify both.");
+        }
+        // Validate required arguments before making API calls
+        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 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 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 change the default for?',
+                source: configKeys,
+            });
+            if (selectedKey) {
+                key = selectedKey;
+            }
+        }
+        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}`);
+        }
+        this.verboseLog('Selected config:', config);
+        // Check if existing config has encrypted values
+        if (!secret.selected) {
+            const configDetailsRequest = await this.apiClient.post('/api/v1/metadata/getByKey', { workspaceId: this.workspaceId, key });
+            if (configDetailsRequest.ok) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const configDetails = configDetailsRequest.json;
+                this.verboseLog('Config details:', configDetails);
+                // Check if any existing rules have encrypted values
+                if (configDetails.default?.rules) {
+                    for (const rule of configDetails.default.rules) {
+                        if (rule.value?.decryptWith) {
+                            this.verboseLog('Auto-detected encryption from existing config');
+                            secret = {
+                                keyName: secret.keyName,
+                                selected: true,
+                            };
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        // Get the environment
+        const environment = await getEnvironment({
+            command: this,
+            flags,
+            message: 'Which environment would you like to change the default for?',
+            providedEnvironment: flags.environment,
+        });
+        this.verboseLog({ environment });
+        if (!environment) {
+            return;
+        }
+        const { confidential } = flags;
+        // Get the value
+        if (flags['env-var']) {
+            if (!(await getConfirmation({
+                flags,
+                message: `Confirm: change the default for ${key} in ${environment.name} to be provided by \`${flags['env-var']}\`? yes/no`,
+            }))) {
+                return;
+            }
+            return this.submitChange({
+                confidential,
+                config,
+                envVar: flags['env-var'],
+                environment,
+                environmentId: environment.id,
+                key,
+                secret,
+            });
+        }
+        let value = flags.value;
+        if (!value && isInteractive(flags)) {
+            value = await getString({
+                allowBlank: true,
+                message: 'Default value',
+            });
+        }
+        if (value === undefined) {
+            return this.err('Value is required');
+        }
+        const secretMaybe = secret.selected ? ' (encrypted)' : '';
+        const message = `Confirm: change the default for ${key} in ${environment.name} to \`${value}\`${secretMaybe}? yes/no`;
+        if (!(await getConfirmation({ flags, message }))) {
+            return;
+        }
+        return this.submitChange({
+            confidential,
+            config,
+            environment,
+            environmentId: environment.id,
+            key,
+            secret,
+            value,
+        });
+    }
+    async submitChange({ confidential, config, envVar, environment, environmentId, key, secret, value, }) {
+        /* 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[config.valueType.toLowerCase()] || config.valueType;
+        let configValue;
+        let successMessage;
+        if (envVar === undefined) {
+            successMessage = `Successfully changed default to \`${value}\``;
+            if (secret.selected) {
+                // Handle encrypted values using shared utility
+                const encryptedValueResult = await makeConfidentialValue(this, value, secret, environmentId);
+                if (!encryptedValueResult.ok) {
+                    return this.err(encryptedValueResult.message || 'Failed to encrypt value');
+                }
+                configValue = mapConfigValueToDto(encryptedValueResult.value, ConfigValueType.String);
+                successMessage += ' (encrypted)';
+            }
+            else {
+                // Parse the value based on type and build value object
+                let variantValue = value;
+                let variantType = type;
+                switch (type) {
+                    case 'stringList': {
+                        variantValue = value.split(',');
+                        variantType = 'string_list';
+                        break;
+                    }
+                    case 'bool': {
+                        const lowerValue = value.toLowerCase();
+                        if (lowerValue !== 'true' && lowerValue !== 'false') {
+                            return this.err(`'${value}' is not a valid value for ${key}`);
+                        }
+                        variantValue = lowerValue === 'true';
+                        break;
+                    }
+                    case 'int': {
+                        variantValue = Number.parseInt(value, 10);
+                        if (Number.isNaN(variantValue)) {
+                            return this.err(`Invalid default value for int: ${value}`);
+                        }
+                        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
+                }
+                configValue = {
+                    type: variantType,
+                    value: variantValue,
+                };
+            }
+        }
+        else {
+            configValue = {
+                provided: {
+                    lookup: envVar,
+                    source: ProvidedSource.EnvVar,
+                },
+            };
+            successMessage = `Successfully changed default to be provided by \`${envVar}\``;
+        }
+        if (confidential && !secret.selected) {
+            configValue.confidential = true;
+            successMessage += ' (confidential)';
+        }
+        const payload = {
+            configKey: key,
+            currentVersionId: config.version,
+            environmentId: environmentId ? Number.parseInt(environmentId, 10) : 0,
+            value: configValue,
+        };
+        this.verboseLog('Payload:', payload);
+        const request = await this.apiClient.post('/internal/ops/v1/set-default', payload);
+        if (request.ok) {
+            this.log(`${checkmark} ${successMessage}`);
+            return {
+                environment: {
+                    id: environmentId,
+                    name: environment.name,
+                },
+                key,
+                success: true,
+                value,
+            };
+        }
+        this.verboseLog(request.error);
+        const errMsg = request.status === 400
+            ? `Failed to change default: ${request.status} -- is ${value || envVar} a valid value?`
+            : `Failed to change default: ${request.status}`;
+        return this.err(errMsg, { key, serverError: request.error });
+    }
+}

package/dist/commands/verify.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../index.js';
+export default class Verify extends BaseCommand {
+    static args: {
+        path: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        strict: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<object>;
+}

package/dist/commands/verify.js

@@ -0,0 +1,48 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../index.js';
+import { formatResult, validateWorkspace } from '../verify/validate.js';
+export default class Verify extends BaseCommand {
+    static args = {
+        path: Args.string({
+            default: '.',
+            description: 'Path to workspace directory',
+        }),
+    };
+    static description = 'Validate a Quonfig workspace directory';
+    static examples = [
+        '<%= config.bin %> verify',
+        '<%= config.bin %> verify ./my-workspace',
+        '<%= config.bin %> verify --json',
+    ];
+    static flags = {
+        strict: Flags.boolean({
+            default: false,
+            description: 'Treat warnings as errors',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Verify);
+        const dir = args.path;
+        const result = validateWorkspace(dir);
+        if (flags.strict) {
+            // Promote warnings to errors
+            for (const issue of result.issues) {
+                if (issue.severity === 'warning') {
+                    issue.severity = 'error';
+                }
+            }
+            result.valid = !result.issues.some((i) => i.severity === 'error');
+        }
+        if (this.jsonEnabled()) {
+            if (!result.valid) {
+                this.exit(1);
+            }
+            return result;
+        }
+        this.log(formatResult(result));
+        if (!result.valid) {
+            this.exit(1);
+        }
+        return result;
+    }
+}

package/dist/commands/whoami.d.ts

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