@quonfig/cli 0.0.11 → 0.0.12

package/dist/migrate/sources/launch/translate.js

@@ -0,0 +1,190 @@
+export function slugify(value) {
+    return value
+        .toLowerCase()
+        .replaceAll(/[^\da-z]+/g, '-')
+        .replaceAll(/^-+|-+$/g, '');
+}
+export function isLegacyLogLevel(type) {
+    return type.toUpperCase() === 'LOG_LEVEL';
+}
+function zeroValue(valueType) {
+    switch (valueType) {
+        case 'bool': {
+            return { type: 'bool', value: false };
+        }
+        case 'double': {
+            return { type: 'double', value: '0' };
+        }
+        case 'duration': {
+            return { type: 'duration', value: 'PT0S' };
+        }
+        case 'int': {
+            return { type: 'int', value: '0' };
+        }
+        case 'json': {
+            return { type: 'json', value: {} };
+        }
+        case 'log_level': {
+            return { type: 'log_level', value: 'WARN' };
+        }
+        case 'string': {
+            return { type: 'string', value: '' };
+        }
+        case 'string_list': {
+            return { type: 'string_list', value: [] };
+        }
+        default: {
+            return { type: 'string', value: '' };
+        }
+    }
+}
+function parseJsonString(raw, configKey, path) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to parse stringified json value for config "${configKey}" at ${path}: ${message}. Raw value: ${JSON.stringify(raw)}`);
+    }
+}
+function normalizeLaunchValue(value, configKey, path) {
+    if (!value || typeof value !== 'object')
+        return;
+    const v = value;
+    if (v.type === 'json' && typeof v.value === 'string') {
+        v.value = parseJsonString(v.value, configKey, path);
+        return;
+    }
+    if (v.type === 'weighted_values' && Array.isArray(v.value)) {
+        const entries = v.value;
+        for (const [i, entry] of entries.entries()) {
+            if (entry && typeof entry === 'object' && entry.value) {
+                normalizeLaunchValue(entry.value, configKey, `${path}.weightedValues[${i}].value`);
+            }
+        }
+    }
+}
+function normalizeRules(rules, configKey, path) {
+    if (!Array.isArray(rules))
+        return;
+    for (const [i, rule] of rules.entries()) {
+        if (!rule || typeof rule !== 'object')
+            continue;
+        const r = rule;
+        if (r.value) {
+            normalizeLaunchValue(r.value, configKey, `${path}[${i}].value`);
+        }
+        if (Array.isArray(r.criteria)) {
+            for (const [j, crit] of r.criteria.entries()) {
+                if (!crit || typeof crit !== 'object')
+                    continue;
+                const c = crit;
+                if (c.valueToMatch) {
+                    normalizeLaunchValue(c.valueToMatch, configKey, `${path}[${i}].criteria[${j}].valueToMatch`);
+                }
+            }
+        }
+    }
+}
+function normalizeJsonValuesInConfig(out) {
+    const configKey = String(out.key ?? 'unknown');
+    const defaultSection = out.default;
+    if (defaultSection && Array.isArray(defaultSection.rules)) {
+        normalizeRules(defaultSection.rules, configKey, 'default.rules');
+    }
+    if (Array.isArray(out.environments)) {
+        for (const [i, env] of out.environments.entries()) {
+            const envId = typeof env.id === 'string' ? env.id : String(i);
+            normalizeRules(env.rules, configKey, `environments[${envId}].rules`);
+        }
+    }
+    if (Array.isArray(out.variants)) {
+        for (const [i, variant] of out.variants.entries()) {
+            if (variant && variant.value) {
+                normalizeLaunchValue(variant.value, configKey, `variants[${i}].value`);
+            }
+        }
+    }
+}
+export function transformConfig(config, envIdMap) {
+    const out = JSON.parse(JSON.stringify(config));
+    delete out.changedBy;
+    delete out.modifiedAt;
+    delete out.createdAt;
+    delete out.deleted;
+    if (out.type === 'feature_flag') {
+        delete out.sendToClientSdk;
+    }
+    if (typeof out.type === 'string' && out.type.toUpperCase() === 'LOG_LEVEL_V2') {
+        out.type = 'log_level';
+    }
+    if (typeof out.valueType === 'string' && out.valueType.toUpperCase() === 'LOG_LEVEL_V2') {
+        out.valueType = 'log_level';
+    }
+    if (typeof out.type === 'string' && out.type.toLowerCase() === 'schema') {
+        throw new Error(`Schema-type configs are not yet supported by qfg migrate --from launch. ` +
+            `File a bead to prioritize this: https://github.com/quonfig/cli/issues/new?title=qfg+migrate+schema+configs`);
+    }
+    if (Array.isArray(out.environments)) {
+        for (const env of out.environments) {
+            if (typeof env.id === 'string') {
+                const name = envIdMap[env.id] ?? `env-${env.id}`;
+                env.id = slugify(name);
+            }
+        }
+    }
+    if (!out.default && typeof out.valueType === 'string') {
+        out.default = {
+            rules: [
+                {
+                    criteria: [{ operator: 'ALWAYS_TRUE' }],
+                    value: zeroValue(out.valueType),
+                },
+            ],
+        };
+    }
+    normalizeJsonValuesInConfig(out);
+    return out;
+}
+export function getOutputPath(type, key) {
+    const normalizedType = type.toUpperCase();
+    switch (normalizedType) {
+        case 'FEATURE_FLAG': {
+            return `feature-flags/${key}.json`;
+        }
+        case 'LOG_LEVEL_V2': {
+            return `log-levels/${key}.json`;
+        }
+        case 'SCHEMA': {
+            return `schemas/${key}.json`;
+        }
+        case 'SEGMENT': {
+            return `segments/${key}.json`;
+        }
+        default: {
+            return `configs/${key}.json`;
+        }
+    }
+}
+export function groupChanges(changes) {
+    const groups = new Map();
+    for (const change of changes) {
+        const groupKey = `${change.changedAt}:${change.changedBy.id}`;
+        if (!groups.has(groupKey)) {
+            groups.set(groupKey, {
+                changedAt: change.changedAt,
+                changedBy: change.changedBy,
+                changes: [],
+                groupKey,
+                summary: '',
+            });
+        }
+        groups.get(groupKey).changes.push(change);
+    }
+    for (const group of groups.values()) {
+        group.summary = group.changes
+            .map((c) => (c.deleted ? `Delete ${c.key}` : (c.summary ?? `Update ${c.key}`)))
+            .join('\n');
+    }
+    return [...groups.values()].sort((a, b) => a.changedAt - b.changedAt);
+}

package/dist/migrate/sources/launch/types.d.ts

@@ -0,0 +1,68 @@
+export interface LaunchValue {
+    type: string;
+    value: unknown;
+}
+export interface LaunchCriterion {
+    operator: string;
+    propertyName?: string;
+    valueToMatch?: LaunchValue;
+}
+export interface LaunchRule {
+    criteria: LaunchCriterion[];
+    value: LaunchValue;
+}
+export interface LaunchEnvironmentRow {
+    id: string;
+    rules: LaunchRule[];
+}
+export interface LaunchChangedBy {
+    email: string;
+    fullName?: string;
+    id: string;
+    type: string;
+}
+export interface LaunchConfig {
+    allowableValues?: LaunchValue[];
+    changedBy?: LaunchChangedBy;
+    default?: {
+        rules: LaunchRule[];
+    };
+    environments: LaunchEnvironmentRow[];
+    id: string;
+    key: string;
+    projectId: string;
+    schemaKey?: string;
+    sendToClientSdk?: boolean;
+    type: string;
+    valueType: string;
+}
+export interface LaunchChangeEntry {
+    changedAt: number;
+    changedBy: LaunchChangedBy;
+    deleted: boolean;
+    key: string;
+    newConfig?: LaunchConfig;
+    newConfigId: number | string;
+    previousConfigId?: number | string;
+    summary?: string;
+    type: string;
+    version?: number | string;
+}
+export interface LaunchChangeHistoryResponse {
+    changes: LaunchChangeEntry[];
+    cursor?: string;
+}
+export interface LaunchProjectEnvironmentsResponse {
+    envs: Array<{
+        id: number;
+        name: string;
+    }>;
+    projectId: number;
+}
+export interface LaunchChangeGroup {
+    changedAt: number;
+    changedBy: LaunchChangedBy;
+    changes: LaunchChangeEntry[];
+    groupKey: string;
+    summary: string;
+}

package/dist/migrate/sources/launch/types.js

@@ -0,0 +1 @@
+export {};

package/dist/migrate/sources/launch.d.ts

@@ -0,0 +1,3 @@
+import { type MigrationSource } from '../source.js';
+export declare const launchSource: MigrationSource;
+export declare function __resetLaunchSourceForTests(): void;

package/dist/migrate/sources/launch.js

@@ -0,0 +1,70 @@
+import { fetchAllChangeHistory, fetchEnvironments } from './launch/api.js';
+import { getOutputPath, isLegacyLogLevel, slugify, transformConfig } from './launch/translate.js';
+const SOURCE_NAME = 'launch';
+const state = { apiKey: null, envIdMap: null };
+class MissingAuthError extends Error {
+    constructor(operation) {
+        super(`launch source ${operation} requires validateAuth(apiKey) to be called first (no API key configured).`);
+        this.name = 'MissingAuthError';
+    }
+}
+function requireApiKey(operation) {
+    if (!state.apiKey)
+        throw new MissingAuthError(operation);
+    return state.apiKey;
+}
+async function* fetchChangesImpl(sinceEpochMs) {
+    const apiKey = requireApiKey('fetchChanges');
+    const since = sinceEpochMs === null ? undefined : sinceEpochMs;
+    const changes = await fetchAllChangeHistory(apiKey, since);
+    for (const change of changes) {
+        yield {
+            changedAt: change.changedAt,
+            key: change.key,
+            raw: change,
+            source: SOURCE_NAME,
+        };
+    }
+}
+async function listEnvironmentsImpl() {
+    const apiKey = requireApiKey('listEnvironments');
+    const rawEnvIdMap = await fetchEnvironments(apiKey);
+    const envIdMap = {};
+    for (const [id, name] of Object.entries(rawEnvIdMap)) {
+        envIdMap[id] = slugify(name);
+    }
+    state.envIdMap = envIdMap;
+    return [...new Set(Object.values(envIdMap))];
+}
+function translateImpl(change) {
+    const raw = change.raw;
+    if (!raw || typeof raw !== 'object')
+        return [];
+    if (typeof raw.type === 'string' && isLegacyLogLevel(raw.type))
+        return [];
+    if (raw.deleted)
+        return [];
+    if (!raw.newConfig)
+        return [];
+    const envIdMap = state.envIdMap ?? {};
+    const transformed = transformConfig(raw.newConfig, envIdMap);
+    const path = getOutputPath(raw.type, raw.key);
+    return [{ contents: JSON.stringify(transformed, null, 2), path }];
+}
+async function validateAuthImpl(apiKey) {
+    await fetchEnvironments(apiKey);
+    state.apiKey = apiKey;
+}
+export const launchSource = {
+    fetchChanges(sinceEpochMs) {
+        return fetchChangesImpl(sinceEpochMs);
+    },
+    listEnvironments: listEnvironmentsImpl,
+    name: SOURCE_NAME,
+    translate: translateImpl,
+    validateAuth: validateAuthImpl,
+};
+export function __resetLaunchSourceForTests() {
+    state.apiKey = null;
+    state.envIdMap = null;
+}

package/dist/migrate/sources/launchdarkly.d.ts

@@ -0,0 +1,2 @@
+import { type MigrationSource } from '../source.js';
+export declare const launchdarklySource: MigrationSource;

package/dist/migrate/sources/launchdarkly.js

@@ -0,0 +1,18 @@
+import { NotYetImplementedError } from '../source.js';
+const SOURCE_NAME = 'launchdarkly';
+export const launchdarklySource = {
+    // eslint-disable-next-line require-yield
+    async *fetchChanges() {
+        throw new NotYetImplementedError(SOURCE_NAME, 'fetchChanges');
+    },
+    listEnvironments() {
+        throw new NotYetImplementedError(SOURCE_NAME, 'listEnvironments');
+    },
+    name: SOURCE_NAME,
+    translate() {
+        throw new NotYetImplementedError(SOURCE_NAME, 'translate');
+    },
+    validateAuth() {
+        throw new NotYetImplementedError(SOURCE_NAME, 'validateAuth');
+    },
+};

package/dist/ui/get-confirmation.d.ts

@@ -1,9 +1,10 @@
 export declare const confirmFlag: {
     confirm: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
 };
-declare const getConfirmation: ({ flags, message }: {
+declare const getConfirmation: ({ flags, message, }: {
     flags: {
         confirm?: boolean;
+        interactive?: boolean;
     };
     message: string;
 }) => Promise<boolean>;

package/dist/ui/get-confirmation.js

@@ -1,4 +1,12 @@
 import { Flags, ux } from '@oclif/core';
+import isInteractive from '../util/is-interactive.js';
 export const confirmFlag = { confirm: Flags.boolean({ description: 'confirm without prompt' }) };
-const getConfirmation = async ({ flags, message }) => flags.confirm || ux.confirm(message);
+const getConfirmation = async ({ flags, message, }) => {
+    if (flags.confirm)
+        return true;
+    if (!isInteractive(flags)) {
+        throw new Error('Cannot prompt for confirmation in a non-interactive context. Pass --confirm to skip the confirmation prompt.');
+    }
+    return ux.confirm(message);
+};
 export default getConfirmation;

package/dist/ui/get-value.d.ts

@@ -9,7 +9,7 @@ declare const getValue: ({ allowBlank, desiredValue, environment, flags, key, me
     desiredValue: string | undefined;
     environment?: Environment;
     flags: {
-        interactive: boolean;
+        interactive?: boolean;
     };
     key?: string;
     message: string;

package/dist/ui/get-value.js

@@ -1,10 +1,11 @@
 import { defaultValueFor } from '../quonfig.js';
 import { failure, noop, success } from '../result.js';
+import isInteractive from '../util/is-interactive.js';
 import validateValue from '../validations/value.js';
 import getString from './get-string.js';
 const getValue = async ({ allowBlank = true, desiredValue, environment, flags, key, message, quonfig, }) => {
-    if (desiredValue === undefined && !flags.interactive) {
-        return failure(`No value provided for ${key}`);
+    if (desiredValue === undefined && !isInteractive(flags)) {
+        return failure(`No value provided for ${key ?? message}. Pass --value=<value> (or use --env-var) when running non-interactively.`);
     }
     if (!key) {
         if (desiredValue !== undefined) {

package/dist/util/is-interactive.d.ts

@@ -1,5 +1,25 @@
 type Flags = {
     interactive?: boolean;
 };
-declare const isInteractive: (flags: Flags) => boolean | undefined;
+/**
+ * Returns true when the CLI can safely prompt the user.
+ *
+ * Rules, in order:
+ *   1. `--no-interactive` (flags.interactive === false) always wins → non-interactive.
+ *   2. Otherwise require both stdin and stdout to be a TTY.
+ *
+ * Historical bug: this used to return `true` whenever `flags.interactive` was
+ * truthy, which effectively bypassed the TTY check because the global
+ * `--interactive` flag defaults to `true`. Under non-TTY stdio (CI, piped
+ * stdin, `nohup`) the prompt helpers (`ux.prompt`, inquirer autocomplete)
+ * would be invoked with no way to read input, leaving an unsettled
+ * top-level await and emitting a raw Node warning (`Detected unsettled
+ * top-level await`) with exit code 13. Now we always AND with the TTY check
+ * so non-TTY contexts fall through to the command-level "pass --value and
+ * --no-interactive" error message instead of hanging.
+ *
+ * @param flags - the parsed oclif flags (at minimum `interactive` is inspected)
+ * @returns true if prompting is safe, false otherwise
+ */
+declare const isInteractive: (flags: Flags) => boolean;
 export default isInteractive;

package/dist/util/is-interactive.js

@@ -1,7 +1,27 @@
+/**
+ * Returns true when the CLI can safely prompt the user.
+ *
+ * Rules, in order:
+ *   1. `--no-interactive` (flags.interactive === false) always wins → non-interactive.
+ *   2. Otherwise require both stdin and stdout to be a TTY.
+ *
+ * Historical bug: this used to return `true` whenever `flags.interactive` was
+ * truthy, which effectively bypassed the TTY check because the global
+ * `--interactive` flag defaults to `true`. Under non-TTY stdio (CI, piped
+ * stdin, `nohup`) the prompt helpers (`ux.prompt`, inquirer autocomplete)
+ * would be invoked with no way to read input, leaving an unsettled
+ * top-level await and emitting a raw Node warning (`Detected unsettled
+ * top-level await`) with exit code 13. Now we always AND with the TTY check
+ * so non-TTY contexts fall through to the command-level "pass --value and
+ * --no-interactive" error message instead of hanging.
+ *
+ * @param flags - the parsed oclif flags (at minimum `interactive` is inspected)
+ * @returns true if prompting is safe, false otherwise
+ */
 const isInteractive = (flags) => {
     if (flags.interactive === false) {
         return false;
     }
-    return (process.stdout.isTTY && process.stdin.isTTY) || flags.interactive;
+    return Boolean(process.stdout.isTTY && process.stdin.isTTY);
 };
 export default isInteractive;

package/dist/verify/validate.js

@@ -74,7 +74,12 @@ const BoolValueSchema = z.object({ type: z.literal("bool"), value: z.boolean() }
 const StringValueSchema = z.object({ type: z.literal("string"), value: z.string() });
 const IntValueSchema = z.object({ type: z.literal("int"), value: z.union([z.number(), z.string()]) });
 const DoubleValueSchema = z.object({ type: z.literal("double"), value: z.union([z.number(), z.string()]) });
-const JsonValueSchema = z.object({ type: z.literal("json"), value: z.unknown() });
+const JsonValueSchema = z.object({
+    type: z.literal("json"),
+    value: z.any().refine((v) => typeof v !== "string", {
+        message: 'json values must be native JSON (object/array/number/boolean/null). Stringified JSON is no longer allowed — use { "a": 1 } instead of "{\\"a\\":1}".',
+    }),
+});
 const StringListValueSchema = z.object({ type: z.literal("string_list"), value: z.array(z.string()) });
 const DurationValueSchema = z.object({ type: z.literal("duration"), value: z.string() });
 const LogLevelValueSchema = z.object({ type: z.literal("log_level"), value: LogLevelSchema });