@quonfig/cli 0.0.20 → 0.0.22

package/dist/commands/delete.js

@@ -0,0 +1,114 @@
+import { Args, Flags } from '@oclif/core';
+import { APICommand } from '../index.js';
+import { confirmTypedSlug } from '../push/confirm.js';
+import isInteractive from '../util/is-interactive.js';
+import { checkmark } from '../util/color.js';
+import { loadTokens } from '../util/token-storage.js';
+const DELETE_ROUTES = {
+    config: { endpoint: '/api/v1/configs/delete', keyField: 'configKey' },
+    feature_flag: { endpoint: '/api/v1/flags/delete', keyField: 'flagKey' },
+    log_level: { endpoint: '/api/v1/logLevels/delete', keyField: 'logLevelKey' },
+};
+/**
+ * Parse the fresh SHA out of a 409 conflict message of the form
+ *   "<path> was modified (expected <oldSha>, got <newSha>)"
+ */
+function parseFreshShaFromConflict(message) {
+    if (!message)
+        return undefined;
+    const match = message.match(/got\s+([\w.-]+)\)/);
+    return match?.[1];
+}
+export default class Delete extends APICommand {
+    static args = {
+        name: Args.string({ description: 'flag/config/log-level key to delete', required: true }),
+    };
+    static description = `Delete a flag, config, or log-level from the workspace.
+
+DESTRUCTIVE — removes the underlying JSON file from the workspace git repo
+and commits with the actor's identity. The commit history preserves the
+prior content; this is a hard-delete on the file but a soft-delete on
+history.
+
+Confirmation is required:
+  --yes                       skip the prompt (for scripts and CI)
+  interactive (default)       you'll be asked to type the key name back
+
+Examples
+  qfg delete my.flag --yes
+  qfg delete my.flag                          # interactive: type the key back to confirm
+  qfg delete my.config --yes`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my.flag --yes',
+        '<%= config.bin %> <%= command.id %> my.config --yes',
+    ];
+    static flags = {
+        yes: Flags.boolean({ default: false, description: 'skip confirmation prompt' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Delete);
+        const tokens = await loadTokens();
+        if (!tokens?.accessToken) {
+            return this.err('Not logged in. Run `qfg login` first.');
+        }
+        const key = args.name;
+        const metaRes = await this.apiClient.post('/api/v1/metadata/list', { workspaceId: this.workspaceId });
+        if (!metaRes.ok) {
+            return this.err(`Failed to look up ${key}: ${metaRes.status} ${JSON.stringify(metaRes.error)}`);
+        }
+        const items = metaRes.json?.configs ?? [];
+        const item = items.find((i) => i.key === key);
+        if (!item) {
+            return this.err(`${key} not found in this workspace.`);
+        }
+        const route = DELETE_ROUTES[item.type];
+        if (!route) {
+            return this.err(`Cannot delete ${key}: unsupported type "${item.type}". Supported: flag, config, log-level.`);
+        }
+        if (!flags.yes) {
+            if (!isInteractive(flags)) {
+                return this.err(`Refusing to delete ${key} without confirmation. Pass --yes or run interactively.`);
+            }
+            this.log(`About to delete ${item.type.replaceAll('_', ' ')}: ${key}`);
+            this.log('This rewrites the workspace repo and is destructive.');
+            const confirmed = await confirmTypedSlug(key, `Type "${key}" to confirm: `);
+            if (!confirmed) {
+                return this.err(`Aborted: ${key} was not typed back exactly. No changes made.`);
+            }
+        }
+        let expectedCommitSha = item.version;
+        let attempt = 0;
+        while (attempt < 2) {
+            attempt += 1;
+            const payload = {
+                workspaceId: this.workspaceId,
+                [route.keyField]: key,
+                ...(expectedCommitSha ? { expectedCommitSha } : {}),
+            };
+            this.verboseLog(`RPC ${route.endpoint}`, payload);
+            // eslint-disable-next-line no-await-in-loop
+            const res = await this.apiClient.post(route.endpoint, payload);
+            if (res.ok) {
+                const commitSha = res.json?.commitSha;
+                const shaSuffix = commitSha ? ` (commit ${commitSha})` : '';
+                return this.ok(`${checkmark} Deleted ${item.type.replaceAll('_', ' ')}: ${key}${shaSuffix}`, {
+                    key,
+                    type: item.type,
+                    ...(commitSha ? { commitSha } : {}),
+                });
+            }
+            if (res.status === 404) {
+                return this.err(`${key} not found on the server (it may have been deleted by someone else).`);
+            }
+            if (res.status === 409 && attempt === 1) {
+                const fresh = parseFreshShaFromConflict(res.error?.message);
+                if (fresh) {
+                    this.verboseLog(`Stale SHA — retrying delete with fresh SHA ${fresh}`);
+                    expectedCommitSha = fresh;
+                    continue;
+                }
+            }
+            return this.err(`Failed to delete ${key}: ${res.status} ${JSON.stringify(res.error)}`);
+        }
+    }
+}

package/dist/commands/generate.d.ts

@@ -7,6 +7,7 @@ export default class Generate extends BaseCommand {
         dir: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         'output-directory': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         targets: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        workspace: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     static summary: string;
     run(): Promise<JsonObj | void>;

package/dist/commands/generate.js

@@ -4,6 +4,7 @@ import * as path from 'node:path';
 import { z } from 'zod';
 import { NodeTypeScriptGenerator } from '../codegen/code-generators/node-typescript-generator.js';
 import { ReactTypeScriptGenerator } from '../codegen/code-generators/react-typescript-generator.js';
+import { fetchWorkspaceSnapshot } from '../codegen/fetch-workspace-snapshot.js';
 import { LocalConfigReader } from '../codegen/local-config-reader.js';
 import { SupportedLanguage } from '../codegen/types.js';
 import { BaseCommand } from '../index.js';
@@ -109,7 +110,7 @@ Example quonfig.config.json:
     ];
     static flags = {
         dir: Flags.string({
-            description: 'Path to local QUONFIG_DIR (defaults to QUONFIG_DIR env var)',
+            description: 'Path to local QUONFIG_DIR (defaults to QUONFIG_DIR env var). When omitted, fetches the workspace from the server using your active credentials.',
             env: 'QUONFIG_DIR',
         }),
         'output-directory': Flags.string({
@@ -120,16 +121,25 @@ Example quonfig.config.json:
             default: SupportedLanguage.React,
             description: `Determines for language/framework to generate code for (${Object.values(SupportedLanguage).join(', ')})`,
         }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace slug or UUID for the remote-fetch path (defaults to QUONFIG_WORKSPACE env var or active profile). Only used when --dir is omitted.',
+        }),
     };
     static summary = 'Generate type definitions for your Quonfig configuration';
     async run() {
         const { flags } = await this.parse(Generate);
         this.verboseLog('=== GENERATE COMMAND START ===');
+        let snapshot;
         try {
-            // Resolve workspace directory
-            const dir = flags.dir;
+            // When --dir/QUONFIG_DIR is set, read the local checkout (so users
+            // who edit flag JSON in place keep that workflow). Otherwise clone
+            // the workspace into a tmp dir for codegen-only callers.
+            let dir = flags.dir;
             if (!dir) {
-                this.error('No directory specified. Run `qfg pull` first or pass --dir <path>.');
+                this.verboseLog('No --dir/QUONFIG_DIR set; fetching workspace snapshot from server...');
+                snapshot = await fetchWorkspaceSnapshot(this, { workspace: flags.workspace });
+                dir = snapshot.dir;
             }
             // Look for and read local quonfig.config.json file
             const localConfig = await this.readLocalConfig(flags['output-directory']);
@@ -142,6 +152,7 @@ Example quonfig.config.json:
             const configFile = await reader.read();
             this.verboseLog(`Config read complete. Found ${configFile.configs.length} configs.`);
             const fileCreationPromises = [];
+            let needsMustache = false;
             for (const target of targets) {
                 // Resolve the language input
                 const language = this.resolveLanguage(target);
@@ -154,6 +165,9 @@ Example quonfig.config.json:
                 console.log(`Generating ${language} code for configs...`);
                 const generatedCode = generator.generate();
                 this.verboseLog(`Code generation complete. Size: ${generatedCode.length}`);
+                if (generatedCode.includes("from 'mustache'")) {
+                    needsMustache = true;
+                }
                 const fileManager = createFileManager({ outputDirectory: outputDir, verboseLog: this.verboseLog.bind(this) });
                 fileCreationPromises.push(fileManager.writeFile({ data: generatedCode, filename: targetConfig.clientFileName }));
                 if ([SupportedLanguage.Node, SupportedLanguage.React].includes(language)) {
@@ -163,11 +177,26 @@ Example quonfig.config.json:
                 }
             }
             await Promise.all(fileCreationPromises);
+            if (needsMustache) {
+                console.log('\nNote: generated code imports `mustache` for templated config values.\n' +
+                    '      Add it to your project: `npm install mustache @types/mustache`\n' +
+                    '      (or pnpm/yarn equivalent).');
+            }
         }
         catch (error) {
             console.error('ERROR:', error);
             this.error(error);
         }
+        finally {
+            if (snapshot) {
+                try {
+                    await snapshot.cleanup();
+                }
+                catch (cleanupError) {
+                    this.verboseLog('Generate', `Snapshot cleanup failed: ${String(cleanupError)}`);
+                }
+            }
+        }
         this.verboseLog('=== GENERATE COMMAND END ===');
         return { success: true };
     }

package/dist/commands/login.js

@@ -3,7 +3,7 @@ import { select } from '@inquirer/prompts';
 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';
+import { getAuthConfigFilePath, getTokenFilePath, 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'];
@@ -47,14 +47,22 @@ export default class Login extends BaseCommand {
         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,
-        });
+        // Save tokens — verifies the file actually persisted before returning.
+        this.verboseLog('Saving tokens to', getTokenFilePath());
+        let tokensPath;
+        try {
+            tokensPath = await saveTokens({
+                accessToken: tokenResponse.access_token,
+                expiresAt,
+                refreshToken: tokenResponse.refresh_token,
+                userEmail,
+                userId: user.id,
+            });
+        }
+        catch (error) {
+            return this.err(`Login failed: could not save tokens. ${error.message}`);
+        }
+        this.verboseLog('Tokens saved at', tokensPath);
         // Resolve org_id → workspace UUID via the API
         let workspaceId;
         let workspaceName;
@@ -113,18 +121,26 @@ export default class Login extends BaseCommand {
         // 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),
-                    workspaceSlug,
-                    organizationName,
+        this.verboseLog('Saving auth config to', getAuthConfigFilePath());
+        let configPath;
+        try {
+            configPath = await saveAuthConfig({
+                defaultProfile: shouldSetDefault ? profileName : existingConfig?.defaultProfile,
+                profiles: {
+                    ...existingConfig?.profiles,
+                    [profileName]: {
+                        workspace: workspaceId || orgId || 'unknown',
+                        workspaceName: workspaceName || (orgId ? `org:${orgId}` : undefined),
+                        workspaceSlug,
+                        organizationName,
+                    },
                 },
-            },
-        });
+            });
+        }
+        catch (error) {
+            return this.err(`Login failed: could not save auth config. ${error.message}`);
+        }
+        this.verboseLog('Auth config saved at', configPath);
         this.log('\nSuccessfully logged in!');
         if (userEmail) {
             this.log(`Logged in as: ${userEmail}`);

package/dist/commands/override.d.ts

@@ -1,17 +1,23 @@
 import { APICommand } from '../index.js';
-import { JsonObj } from '../result.js';
+import type { 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>>;
+        value: 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>;
+        clear: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        env: 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;
+    private callFindOrCreate;
+    private callRemove;
+    private fetchFlag;
+    private runClear;
+    private runList;
+    private runRemove;
+    private runSet;
 }