@quonfig/cli 0.0.6 → 0.0.8

package/dist/commands/sdk-key/create.js

@@ -0,0 +1,100 @@
+import { Flags } from '@oclif/core';
+import { select } from '@inquirer/prompts';
+import { APICommand } from '../../index.js';
+import { getEnvironments } from '../../api/get-environments.js';
+export default class SdkKeyCreate extends APICommand {
+    static description = 'Create a new SDK key';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --environment production --type server',
+        '<%= config.bin %> <%= command.id %> --environment staging --type browser',
+    ];
+    static flags = {
+        environment: Flags.string({
+            char: 'e',
+            description: 'Environment name (e.g. production, staging)',
+            required: false,
+        }),
+        type: Flags.string({
+            char: 't',
+            description: 'Key type: server (backend) or browser (frontend)',
+            options: ['server', 'browser'],
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SdkKeyCreate);
+        // Fetch available environments
+        const environments = await getEnvironments(this);
+        if (environments.length === 0) {
+            return this.err('No environments found for this workspace.');
+        }
+        // Resolve environment
+        let environmentId;
+        let environmentName;
+        if (flags.environment) {
+            const match = environments.find((e) => e.name.toLowerCase() === flags.environment.toLowerCase());
+            if (!match) {
+                const names = environments.map((e) => e.name).join(', ');
+                return this.err(`Environment "${flags.environment}" not found. Available: ${names}`);
+            }
+            environmentId = match.id;
+            environmentName = match.name;
+        }
+        else {
+            if (environments.length === 1) {
+                environmentId = environments[0].id;
+                environmentName = environments[0].name;
+                this.log(`Using environment: ${environmentName}`);
+            }
+            else {
+                const chosen = await select({
+                    choices: environments.map((e) => ({ name: e.name, value: e.id })),
+                    message: 'Select environment:',
+                });
+                const match = environments.find((e) => e.id === chosen);
+                environmentId = match.id;
+                environmentName = match.name;
+            }
+        }
+        // Resolve key type
+        let keyType;
+        if (flags.type) {
+            keyType = flags.type === 'server' ? 'backend' : 'frontend';
+        }
+        else {
+            const chosen = await select({
+                choices: [
+                    { name: 'server (backend SDK — Node.js, Go, etc.)', value: 'backend' },
+                    { name: 'browser (frontend SDK — JavaScript/React)', value: 'frontend' },
+                ],
+                message: 'Select key type:',
+            });
+            keyType = chosen;
+        }
+        const request = await this.apiClient.post('/api/v1/sdkKeys/create', {
+            workspaceId: this.workspaceId,
+            environmentId,
+            keyType,
+        });
+        if (!request.ok) {
+            const errorMsg = request.error?.error || `Failed to create SDK key: ${request.status}`;
+            return this.err(errorMsg, { serverError: request.error });
+        }
+        const key = request.json;
+        const typeLabel = keyType === 'backend' ? 'server' : 'browser';
+        this.log(`\nSDK key created successfully!\n`);
+        this.log(`Environment:  ${environmentName}`);
+        this.log(`Type:         ${typeLabel}`);
+        this.log(`Key ID:       ${key.id}`);
+        this.log(`\nYour SDK key (shown only once — copy it now):\n`);
+        this.log(`  ${key.rawKey}\n`);
+        this.log(`To revoke this key:  qfg sdk-key revoke ${key.id}`);
+        return {
+            environmentId: key.environmentId,
+            environmentName: key.environmentName,
+            id: key.id,
+            keyType: typeLabel,
+            rawKey: key.rawKey,
+        };
+    }
+}

package/dist/commands/sdk-key/list.d.ts

@@ -0,0 +1,10 @@
+import type { JsonObj } from '../../result.js';
+import { APICommand } from '../../index.js';
+export default class SdkKeyList extends APICommand {
+    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>;
+    };
+    run(): Promise<JsonObj | void>;
+}

package/dist/commands/sdk-key/list.js

@@ -0,0 +1,48 @@
+import { Flags } from '@oclif/core';
+import { APICommand } from '../../index.js';
+export default class SdkKeyList extends APICommand {
+    static description = 'List SDK keys for your workspace';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --environment production',
+    ];
+    static flags = {
+        environment: Flags.string({
+            char: 'e',
+            description: 'Filter by environment name',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SdkKeyList);
+        const request = await this.apiClient.post('/api/v1/sdkKeys/list', { workspaceId: this.workspaceId });
+        if (!request.ok) {
+            const errorMsg = request.error?.error || `Failed to fetch SDK keys: ${request.status}`;
+            return this.err(errorMsg, { serverError: request.error });
+        }
+        let keys = (Array.isArray(request.json) ? request.json : []);
+        if (flags.environment) {
+            const envFilter = flags.environment.toLowerCase();
+            keys = keys.filter((k) => k.environmentName.toLowerCase() === envFilter);
+        }
+        if (keys.length === 0) {
+            const envSuffix = flags.environment ? ` for environment "${flags.environment}"` : '';
+            this.log(`No SDK keys found${envSuffix}.`);
+            this.log(`\nCreate one with: qfg sdk-key create --environment <name> --type server|browser`);
+            return { keys: [] };
+        }
+        const maxEnvLength = Math.max(11, ...keys.map((k) => k.environmentName.length));
+        const maxTypeLength = 7; // "browser" is longest
+        const maxIdLength = Math.max(2, ...keys.map((k) => k.id.length));
+        const header = `${'ID'.padEnd(maxIdLength)}  ${'ENVIRONMENT'.padEnd(maxEnvLength)}  ${'TYPE'.padEnd(maxTypeLength)}  ${'PREFIX'.padEnd(28)}  CREATED`;
+        const separator = `${'-'.repeat(maxIdLength)}  ${'-'.repeat(maxEnvLength)}  ${'-'.repeat(maxTypeLength)}  ${'-'.repeat(28)}  ${'-'.repeat(24)}`;
+        const rows = keys.map((k) => {
+            const typeLabel = k.keyType === 'backend' ? 'server' : 'browser';
+            const prefix = k.keyType === 'backend' ? `qf_sk_${k.environmentName}_...` : `qf_pk_${k.environmentName}_...`;
+            const created = k.createdAt ? new Date(k.createdAt).toISOString().slice(0, 10) : 'unknown';
+            return `${k.id.padEnd(maxIdLength)}  ${k.environmentName.padEnd(maxEnvLength)}  ${typeLabel.padEnd(maxTypeLength)}  ${prefix.padEnd(28)}  ${created}`;
+        });
+        this.log([header, separator, ...rows].join('\n'));
+        return { keys };
+    }
+}

package/dist/commands/sdk-key/revoke.d.ts

@@ -0,0 +1,10 @@
+import type { JsonObj } from '../../result.js';
+import { APICommand } from '../../index.js';
+export default class SdkKeyRevoke extends APICommand {
+    static description: string;
+    static args: {
+        keyId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static examples: string[];
+    run(): Promise<JsonObj | void>;
+}

package/dist/commands/sdk-key/revoke.js

@@ -0,0 +1,30 @@
+import { Args } from '@oclif/core';
+import { APICommand } from '../../index.js';
+export default class SdkKeyRevoke extends APICommand {
+    static description = 'Revoke an SDK key by its ID';
+    static args = {
+        keyId: Args.string({
+            description: 'ID of the SDK key to revoke',
+            required: true,
+        }),
+    };
+    static examples = [
+        '<%= config.bin %> <%= command.id %> a1b2c3d4-e5f6-7890-abcd-ef1234567890',
+    ];
+    async run() {
+        const { args } = await this.parse(SdkKeyRevoke);
+        const request = await this.apiClient.post('/api/v1/sdkKeys/delete', {
+            workspaceId: this.workspaceId,
+            keyId: args.keyId,
+        });
+        if (!request.ok) {
+            if (request.status === 404) {
+                return this.err(`SDK key "${args.keyId}" not found or already revoked.`);
+            }
+            const errorMsg = request.error?.error || `Failed to revoke SDK key: ${request.status}`;
+            return this.err(errorMsg, { serverError: request.error });
+        }
+        this.log(`SDK key ${args.keyId} has been revoked.`);
+        return { keyId: args.keyId, revoked: true };
+    }
+}

package/dist/commands/sdk-key.d.ts

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

package/dist/commands/sdk-key.js

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../index.js';
+export default class SdkKey extends BaseCommand {
+    static description = 'Manage SDK keys for your workspace';
+    static examples = [
+        '<%= config.bin %> sdk-key list',
+        '<%= config.bin %> sdk-key create --environment production --type server',
+        '<%= config.bin %> sdk-key revoke <key-id>',
+    ];
+    async run() {
+        this.log('Use one of the sdk-key subcommands:');
+        this.log('  qfg sdk-key list');
+        this.log('  qfg sdk-key create --environment <name> --type server|browser');
+        this.log('  qfg sdk-key revoke <key-id>');
+    }
+}

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