@quonfig/cli 0.0.11 → 0.0.13

package/dist/migrate/push-strategy.js

@@ -0,0 +1,127 @@
+import { execFile as execFileCb, spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as util from 'node:util';
+const execFile = util.promisify(execFileCb);
+const gitCommitFromStdin = (cwd, message, env) => new Promise((resolve, reject) => {
+    const child = spawn('git', ['-C', cwd, 'commit', '-F', '-'], { env });
+    let stderr = '';
+    child.stderr.on('data', (d) => {
+        stderr += d.toString();
+    });
+    child.on('error', reject);
+    child.on('close', (code) => {
+        if (code === 0)
+            resolve();
+        else
+            reject(new Error(`git commit exited ${code}: ${stderr}`));
+    });
+    child.stdin.end(message);
+});
+export const MIGRATOR_IDENTITY = {
+    name: 'quonfig migrator',
+    email: 'migrator@quonfig.com',
+};
+const redactToken = (s) => s.replaceAll(/:([^\s/@]+)@/g, ':***@');
+export class PushConflictError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PushConflictError';
+    }
+}
+const runGit = async (cwd, args) => {
+    try {
+        return await execFile('git', args, { cwd });
+    }
+    catch (error) {
+        const e = error;
+        const stderr = redactToken(e.stderr ?? '');
+        const stdout = redactToken(e.stdout ?? '');
+        const message = redactToken(e.message || String(error));
+        const wrapped = new Error(`${message}\n${stderr}`.trim());
+        wrapped.stderr = stderr;
+        wrapped.stdout = stdout;
+        throw wrapped;
+    }
+};
+const isGitRepo = async (dir) => {
+    try {
+        await execFile('git', ['-C', dir, 'rev-parse', '--git-dir']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const getOriginUrl = async (dir) => {
+    try {
+        const { stdout } = await execFile('git', ['-C', dir, 'remote', 'get-url', 'origin']);
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+};
+const normalizeRemoteUrl = (url) => redactToken(url.replace(/\.git$/, '').trim());
+const ensureCloneOrReuse = async (remoteUrl, localDir, branch) => {
+    if (fs.existsSync(localDir) && (await isGitRepo(localDir))) {
+        const origin = await getOriginUrl(localDir);
+        if (origin && normalizeRemoteUrl(origin) === normalizeRemoteUrl(remoteUrl)) {
+            // Reuse: fetch + ff-merge
+            await runGit(localDir, ['fetch', 'origin', branch]);
+            await runGit(localDir, ['checkout', branch]);
+            await runGit(localDir, ['merge', '--ff-only', `origin/${branch}`]);
+            return 'reused';
+        }
+        throw new Error(`Local dir ${localDir} is a git repo but its origin (${origin ? redactToken(origin) : 'unset'}) does not match the target remote. Refuse to clobber — pass an empty/non-existent path or a matching clone.`);
+    }
+    if (fs.existsSync(localDir)) {
+        const entries = fs.readdirSync(localDir);
+        if (entries.length > 0) {
+            throw new Error(`Local dir ${localDir} exists and is not empty, but is not a git clone of ${redactToken(remoteUrl)}. Refuse to clobber.`);
+        }
+    }
+    fs.mkdirSync(path.dirname(localDir), { recursive: true });
+    await runGit(path.dirname(localDir) || '.', ['clone', '--branch', branch, remoteUrl, localDir]);
+    return 'cloned';
+};
+const hasStagedChanges = async (dir) => {
+    const { stdout } = await execFile('git', ['-C', dir, 'status', '--porcelain']);
+    return stdout.trim().length > 0;
+};
+export const cloneAndStackPush = async (opts) => {
+    const branch = opts.branch ?? 'main';
+    const author = opts.author ?? MIGRATOR_IDENTITY;
+    const action = await ensureCloneOrReuse(opts.remoteUrl, opts.localDir, branch);
+    // Pin committer identity on the repo so commits are reproducible regardless of host git config.
+    await runGit(opts.localDir, ['config', 'user.name', author.name]);
+    await runGit(opts.localDir, ['config', 'user.email', author.email]);
+    await opts.applyDelta(opts.localDir);
+    await runGit(opts.localDir, ['add', '--all']);
+    if (!(await hasStagedChanges(opts.localDir))) {
+        return { action, committed: false, commitSha: null };
+    }
+    await gitCommitFromStdin(opts.localDir, opts.commitMessage, {
+        ...process.env,
+        GIT_AUTHOR_NAME: author.name,
+        GIT_AUTHOR_EMAIL: author.email,
+        GIT_COMMITTER_NAME: author.name,
+        GIT_COMMITTER_EMAIL: author.email,
+    });
+    const { stdout: sha } = await execFile('git', ['-C', opts.localDir, 'rev-parse', 'HEAD']);
+    try {
+        // Plain push — no force, no force-with-lease. If the remote has advanced, we fail
+        // and surface a conflict; we do NOT clobber UI edits.
+        await runGit(opts.localDir, ['push', 'origin', branch]);
+    }
+    catch (error) {
+        const e = error;
+        const stderr = e.stderr ?? '';
+        const combined = `${e.message}\n${stderr}`;
+        if (/non-fast-forward|fetch first|rejected/i.test(combined)) {
+            throw new PushConflictError(`Push to origin/${branch} was rejected: the remote has changes we do not have locally. Re-run the migrator to pick up those changes, then push again. Original git error:\n${redactToken(stderr || e.message)}`);
+        }
+        throw error;
+    }
+    return { action, committed: true, commitSha: sha.trim() };
+};

package/dist/migrate/push-to-cloud.d.ts

@@ -0,0 +1,15 @@
+import { type ImportState } from './import-state.js';
+import { type MigrationReportData } from './migration-report.js';
+import { type CloneAndStackPushResult } from './push-strategy.js';
+import type { LegacyChange, MigrationSource } from './source.js';
+export interface PushMigrationToCloudOptions {
+    branch?: string;
+    changes: LegacyChange[];
+    commitMessage: string;
+    importState: ImportState;
+    localDir: string;
+    remoteUrl: string;
+    reportData: MigrationReportData;
+    source: MigrationSource;
+}
+export declare const pushMigrationToCloud: (opts: PushMigrationToCloudOptions) => Promise<CloneAndStackPushResult>;

package/dist/migrate/push-to-cloud.js

@@ -0,0 +1,31 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { removeQfFromGitignore, writeImportState } from './import-state.js';
+import { writeMigrationReport } from './migration-report.js';
+import { cloneAndStackPush } from './push-strategy.js';
+const writeQuonfigFiles = (dir, changes, source) => {
+    for (const change of changes) {
+        const files = source.translate(change);
+        for (const file of files) {
+            const full = path.join(dir, file.path);
+            fs.mkdirSync(path.dirname(full), { recursive: true });
+            fs.writeFileSync(full, file.contents);
+        }
+    }
+};
+export const pushMigrationToCloud = async (opts) => {
+    const cloneOpts = {
+        applyDelta(dir) {
+            writeQuonfigFiles(dir, opts.changes, opts.source);
+            removeQfFromGitignore(dir);
+            writeImportState(dir, opts.importState);
+            writeMigrationReport(dir, opts.reportData);
+        },
+        commitMessage: opts.commitMessage,
+        localDir: opts.localDir,
+        remoteUrl: opts.remoteUrl,
+    };
+    if (opts.branch !== undefined)
+        cloneOpts.branch = opts.branch;
+    return cloneAndStackPush(cloneOpts);
+};

package/dist/migrate/registry.d.ts

@@ -0,0 +1,6 @@
+import { type MigrationSource } from './source.js';
+export declare class UnknownSourceError extends Error {
+    constructor(name: string);
+}
+export declare function getSource(name: string): MigrationSource;
+export declare function listSources(): string[];

package/dist/migrate/registry.js

@@ -0,0 +1,25 @@
+import { flagsmithSource } from './sources/flagsmith.js';
+import { launchSource } from './sources/launch.js';
+import { launchdarklySource } from './sources/launchdarkly.js';
+const SOURCES = {
+    flagsmith: flagsmithSource,
+    launch: launchSource,
+    launchdarkly: launchdarklySource,
+};
+export class UnknownSourceError extends Error {
+    constructor(name) {
+        const supported = Object.keys(SOURCES).sort().join(', ');
+        super(`Unknown migration source "${name}". Supported: ${supported}.`);
+        this.name = 'UnknownSourceError';
+    }
+}
+export function getSource(name) {
+    const source = SOURCES[name];
+    if (!source) {
+        throw new UnknownSourceError(name);
+    }
+    return source;
+}
+export function listSources() {
+    return Object.keys(SOURCES).sort();
+}

package/dist/migrate/source.d.ts

@@ -0,0 +1,22 @@
+export interface LegacyChange {
+    changedAt?: number;
+    key?: string;
+    raw: unknown;
+    source: string;
+}
+export interface QuonfigFile {
+    contents: string;
+    path: string;
+}
+export interface MigrationSource {
+    fetchChanges(sinceEpochMs: null | number): AsyncIterable<LegacyChange>;
+    listEnvironments(): Promise<string[]>;
+    name: string;
+    translate(change: LegacyChange): QuonfigFile[];
+    validateAuth(apiKey: string): Promise<void>;
+}
+export declare class NotYetImplementedError extends Error {
+    readonly issueUrl: string;
+    readonly sourceName: string;
+    constructor(sourceName: string, operation: string);
+}

package/dist/migrate/source.js

@@ -0,0 +1,12 @@
+export class NotYetImplementedError extends Error {
+    issueUrl;
+    sourceName;
+    constructor(sourceName, operation) {
+        const issueUrl = `https://github.com/quonfig/cli/issues/new?title=qfg+migrate+--from+${encodeURIComponent(sourceName)}`;
+        super(`qfg migrate --from ${sourceName} is not yet implemented (${operation}). ` +
+            `File a bead to prioritize this source: ${issueUrl}`);
+        this.name = 'NotYetImplementedError';
+        this.sourceName = sourceName;
+        this.issueUrl = issueUrl;
+    }
+}

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

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

package/dist/migrate/sources/flagsmith.js

@@ -0,0 +1,28 @@
+// Stub — `qfg migrate --from flagsmith` is not yet wired up. Before replacing this with a real
+// implementation, investigate:
+//   - Flagsmith API shape: what the admin/REST API returns for features, segments, identities,
+//     environments, and multivariate variations, and how that maps onto Quonfig's JSON schema.
+//   - Delta/cursor support: whether Flagsmith exposes an audit-log or change-feed endpoint with a
+//     stable cursor we can persist in `.qf/import-state.json` for re-runnable incremental
+//     imports, or whether we have to full-reimport + diff on every run (as is likely for LD).
+//   - Auth model: API key scopes (server-side vs. admin), org/project/environment hierarchy.
+//   - Schema gaps: Flagsmith's identity overrides and segment rules vs. Quonfig's rule operators
+//     — document any unsupported primitives the way `launchdarkly.README.md` does for LD.
+import { NotYetImplementedError } from '../source.js';
+const SOURCE_NAME = 'flagsmith';
+export const flagsmithSource = {
+    // 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/migrate/sources/launch/api.d.ts

@@ -0,0 +1,7 @@
+import type { LaunchChangeEntry, LaunchChangeHistoryResponse } from './types.js';
+export declare function setLaunchBaseUrl(url: string): void;
+export declare function selectLaunchBaseUrl(staging: boolean): string;
+export declare function applyLaunchBaseUrl(staging: boolean): void;
+export declare function fetchEnvironments(apiKey: string): Promise<Record<string, string>>;
+export declare function fetchChangeHistoryPage(apiKey: string, cursor?: string): Promise<LaunchChangeHistoryResponse>;
+export declare function fetchAllChangeHistory(apiKey: string, sinceEpochMs?: number): Promise<LaunchChangeEntry[]>;

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

@@ -0,0 +1,75 @@
+const PROD_BASE_URL = 'https://api.reforge.com';
+const STAGING_BASE_URL = 'https://api.goatsofreforge.com';
+const PAGE_LIMIT = 50;
+let baseUrl = PROD_BASE_URL;
+export function setLaunchBaseUrl(url) {
+    baseUrl = url;
+}
+export function selectLaunchBaseUrl(staging) {
+    return process.env.LAUNCH_API_URL ?? (staging ? STAGING_BASE_URL : PROD_BASE_URL);
+}
+export function applyLaunchBaseUrl(staging) {
+    baseUrl = selectLaunchBaseUrl(staging);
+}
+function makeToken(apiKey) {
+    return Buffer.from(`authuser:${apiKey}`).toString('base64');
+}
+async function apiFetch(path, apiKey) {
+    const url = `${baseUrl}${path}`;
+    const token = makeToken(apiKey);
+    const res = await fetch(url, {
+        headers: {
+            Accept: 'application/json',
+            Authorization: `Basic ${token}`,
+        },
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '(no body)');
+        throw new Error(`Launch API request failed: ${res.status} ${res.statusText} — ${url}\n${body}`);
+    }
+    return res.json();
+}
+export async function fetchEnvironments(apiKey) {
+    const data = (await apiFetch('/api/v1/project-environments', apiKey));
+    const envMap = {};
+    for (const env of data.envs) {
+        envMap[String(env.id)] = env.name;
+    }
+    return envMap;
+}
+export async function fetchChangeHistoryPage(apiKey, cursor) {
+    const params = new URLSearchParams({
+        expands: 'changedBy',
+        includeNewVersion: 'true',
+        includeSummary: 'true',
+        limit: String(PAGE_LIMIT),
+    });
+    if (cursor) {
+        params.set('cursor', cursor);
+    }
+    return (await apiFetch(`/api/v1/change-history?${params}`, apiKey));
+}
+export async function fetchAllChangeHistory(apiKey, sinceEpochMs) {
+    const collected = [];
+    const seenCursors = new Set();
+    let cursor;
+    let done = false;
+    while (!done) {
+        // eslint-disable-next-line no-await-in-loop
+        const page = await fetchChangeHistoryPage(apiKey, cursor);
+        if (page.changes.length === 0)
+            break;
+        for (const change of page.changes) {
+            if (sinceEpochMs !== undefined && change.changedAt <= sinceEpochMs) {
+                done = true;
+                break;
+            }
+            collected.push(change);
+        }
+        if (done || !page.cursor || seenCursors.has(page.cursor))
+            break;
+        seenCursors.add(page.cursor);
+        cursor = page.cursor;
+    }
+    return collected.reverse();
+}

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

@@ -0,0 +1,6 @@
+import type { LaunchChangeEntry, LaunchChangeGroup, LaunchConfig } from './types.js';
+export declare function slugify(value: string): string;
+export declare function isLegacyLogLevel(type: string): boolean;
+export declare function transformConfig(config: LaunchConfig, envIdMap: Record<string, string>): Record<string, unknown>;
+export declare function getOutputPath(type: string, key: string): string;
+export declare function groupChanges(changes: LaunchChangeEntry[]): LaunchChangeGroup[];

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;