@quonfig/cli 0.0.37 → 0.0.39

package/dist/commands/activity/deleted.js

@@ -0,0 +1,32 @@
+import { APICommand } from '../../index.js';
+export default class ActivityDeleted extends APICommand {
+    static description = `List configs that were deleted from the workspace and have not been restored.
+
+Useful for "did somebody delete X?" — pair with \`qfg activity restore NAME\`
+to undelete a tombstoned config.`;
+    static examples = ['<%= config.bin %> <%= command.id %>', '<%= config.bin %> <%= command.id %> --json'];
+    async run() {
+        const request = await this.apiClient.post('/api/v1/activity/getDeletedItems', {
+            workspaceId: this.workspaceId,
+        });
+        if (!request.ok) {
+            const errorMsg = request.error?.error || `Failed to fetch deleted items: ${request.status}`;
+            return this.err(errorMsg, { serverError: request.error });
+        }
+        const items = (Array.isArray(request.json) ? request.json : []);
+        if (items.length === 0) {
+            this.log('No deleted items in this workspace.');
+            return { items: [] };
+        }
+        const maxTypeLen = Math.max(4, ...items.map((i) => i.configType.length));
+        const maxKeyLen = Math.max(3, ...items.map((i) => i.configKey.length));
+        const maxByLen = Math.max(2, ...items.map((i) => i.deletedBy.length));
+        const header = `${'TYPE'.padEnd(maxTypeLen)}  ${'KEY'.padEnd(maxKeyLen)}  ${'BY'.padEnd(maxByLen)}  DELETED AT`;
+        const sep = `${'-'.repeat(maxTypeLen)}  ${'-'.repeat(maxKeyLen)}  ${'-'.repeat(maxByLen)}  ${'-'.repeat(20)}`;
+        const rows = items.map((i) => `${i.configType.padEnd(maxTypeLen)}  ${i.configKey.padEnd(maxKeyLen)}  ${i.deletedBy.padEnd(maxByLen)}  ${i.deletedAt.slice(0, 19).replace('T', ' ')}`);
+        this.log([header, sep, ...rows].join('\n'));
+        this.log('');
+        this.log('Restore one with: qfg activity restore <key>');
+        return { items };
+    }
+}

package/dist/commands/activity/feed.d.ts

@@ -0,0 +1,10 @@
+import type { JsonObj } from '../../result.js';
+import { APICommand } from '../../index.js';
+export default class ActivityFeed extends APICommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        limit: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<JsonObj | void>;
+}

package/dist/commands/activity/feed.js

@@ -0,0 +1,77 @@
+import { Flags } from '@oclif/core';
+import { APICommand } from '../../index.js';
+const MS_PER_MINUTE = 60_000;
+const MS_PER_HOUR = 60 * MS_PER_MINUTE;
+const MS_PER_DAY = 24 * MS_PER_HOUR;
+/** Compact relative date — "5m ago", "3h ago", "2d ago", or ISO when older. */
+function relativeTime(iso, now = Date.now()) {
+    const t = new Date(iso).getTime();
+    if (!Number.isFinite(t))
+        return iso;
+    const diff = now - t;
+    if (diff < MS_PER_MINUTE)
+        return 'just now';
+    if (diff < MS_PER_HOUR)
+        return `${Math.floor(diff / MS_PER_MINUTE)}m ago`;
+    if (diff < MS_PER_DAY)
+        return `${Math.floor(diff / MS_PER_HOUR)}h ago`;
+    if (diff < 14 * MS_PER_DAY)
+        return `${Math.floor(diff / MS_PER_DAY)}d ago`;
+    return iso.slice(0, 10); // YYYY-MM-DD for older entries
+}
+/** Author column — fall back to email when authorName is empty (gitea bots). */
+function authorLabel(item) {
+    if (item.authorName && item.authorName.trim().length > 0)
+        return item.authorName;
+    return item.authorEmail || '(unknown)';
+}
+export default class ActivityFeed extends APICommand {
+    static description = `Recent activity across the workspace, newest first.
+
+Each entry shows who changed which config, the action (created/updated/deleted/restored),
+and the human-readable audit message produced by the server. The server already
+translates JSON diffs into messages — this command does not re-translate.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --limit 5',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        limit: Flags.integer({
+            default: 30,
+            description: 'Maximum number of feed entries (1-100)',
+            max: 100,
+            min: 1,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ActivityFeed);
+        const request = await this.apiClient.post('/api/v1/activity/getWorkspaceFeed', {
+            workspaceId: this.workspaceId,
+            limit: flags.limit,
+        });
+        if (!request.ok) {
+            const errorMsg = request.error?.error || `Failed to fetch activity feed: ${request.status}`;
+            return this.err(errorMsg, { serverError: request.error });
+        }
+        const items = (Array.isArray(request.json) ? request.json : []);
+        if (items.length === 0) {
+            this.log('No recent activity in this workspace.');
+            return { items: [] };
+        }
+        const lines = [];
+        for (const item of items) {
+            const sha = item.sha.slice(0, 8);
+            const who = authorLabel(item);
+            const when = relativeTime(item.date);
+            const target = item.configType && item.configKey ? `${item.configType}/${item.configKey}` : '(workspace)';
+            lines.push(`${sha}  ${item.action.padEnd(9)}  ${target}  by ${who}  ${when}`);
+            for (const m of item.messages) {
+                lines.push(`    - ${m.message}`);
+            }
+            lines.push('');
+        }
+        this.log(lines.join('\n').trimEnd());
+        return { items };
+    }
+}

package/dist/commands/activity/history.d.ts

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

package/dist/commands/activity/history.js

@@ -0,0 +1,61 @@
+import { APICommand } from '../../index.js';
+import { resolveConfigByKey } from '../../util/activity-lookup.js';
+import nameArg from '../../util/name-arg.js';
+function authorLabel(entry) {
+    if (entry.authorName && entry.authorName.trim().length > 0)
+        return entry.authorName;
+    return entry.authorEmail || '(unknown)';
+}
+export default class ActivityHistory extends APICommand {
+    static args = { ...nameArg };
+    static description = `Per-config audit trail for a flag, config, log-level, segment, or schema.
+
+Resolves NAME against the workspace metadata (no need to specify type) and
+returns the full commit history for that file with audit messages translated
+by the server. Restored entries are rendered distinctly so a recovery doesn't
+look like a fresh create.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my.flag',
+        '<%= config.bin %> <%= command.id %> request.timeout --json',
+    ];
+    async run() {
+        const { args } = await this.parse(ActivityHistory);
+        if (!args.name) {
+            return this.err('Key is required. Usage: qfg activity history <name>');
+        }
+        const resolved = await resolveConfigByKey(this, args.name);
+        if ('error' in resolved) {
+            return this.err(resolved.error);
+        }
+        const request = await this.apiClient.post('/api/v1/activity/getRichHistory', {
+            workspaceId: this.workspaceId,
+            configType: resolved.configType,
+            configKey: resolved.configKey,
+        });
+        if (!request.ok) {
+            const errorMsg = request.error?.error || `Failed to fetch history: ${request.status}`;
+            return this.err(errorMsg, { serverError: request.error });
+        }
+        const entries = (Array.isArray(request.json) ? request.json : []);
+        this.log(`History for ${resolved.configType}/${resolved.configKey}:`);
+        this.log('');
+        if (entries.length === 0) {
+            this.log('  (no commits found)');
+            return { configType: resolved.configType, configKey: resolved.configKey, entries: [] };
+        }
+        const lines = [];
+        for (const entry of entries) {
+            const sha = entry.sha.slice(0, 8);
+            const who = authorLabel(entry);
+            const date = entry.date.slice(0, 19).replace('T', ' ');
+            const marker = entry.action === 'restored' ? '★ restored' : entry.action;
+            lines.push(`${sha}  ${marker.padEnd(11)}  ${date}  by ${who}`);
+            for (const m of entry.messages) {
+                lines.push(`    - ${m.message}`);
+            }
+            lines.push('');
+        }
+        this.log(lines.join('\n').trimEnd());
+        return { configType: resolved.configType, configKey: resolved.configKey, entries };
+    }
+}

package/dist/commands/activity/restore.d.ts

@@ -0,0 +1,21 @@
+import type { JsonObj } from '../../result.js';
+import { APICommand } from '../../index.js';
+export default class ActivityRestore 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: {
+        type: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<JsonObj | void>;
+    /**
+     * When the user omits --type, fall back to listing live metadata so we can
+     * still find configType for keys that were *renamed-then-deleted* (live
+     * record gone, deletion history exists). Returns the unique config types
+     * that match the key — empty when nothing matches.
+     */
+    private findCandidateTypes;
+}

package/dist/commands/activity/restore.js

@@ -0,0 +1,113 @@
+import { Flags } from '@oclif/core';
+import { APICommand } from '../../index.js';
+import { confirmYesNo } from '../../push/confirm.js';
+import { normalizeConfigType, resolveConfigByKey } from '../../util/activity-lookup.js';
+import { getAppUrl } from '../../util/domain-urls.js';
+import isInteractive from '../../util/is-interactive.js';
+import nameArg from '../../util/name-arg.js';
+const RESTORABLE_TYPES = ['feature_flag', 'config', 'log_level', 'segment'];
+export default class ActivityRestore extends APICommand {
+    static args = { ...nameArg };
+    static description = `Undelete a config that was previously removed.
+
+Looks up the most recent deletion for the key (so you see who deleted it and when),
+then asks for confirmation before re-creating the file from the prior content.
+Schemas cannot be restored — use git history instead.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my.flag --yes',
+        '<%= config.bin %> <%= command.id %> request.timeout --type config --yes',
+    ];
+    static flags = {
+        type: Flags.string({
+            description: 'Config type. Optional — inferred from history when omitted.',
+            options: ['feature_flag', 'config', 'log_level', 'segment', 'flag', 'log-level'],
+            required: false,
+        }),
+        yes: Flags.boolean({ default: false, description: 'Skip the confirmation prompt' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ActivityRestore);
+        if (!args.name) {
+            return this.err('Key is required. Usage: qfg activity restore <name>');
+        }
+        const key = args.name;
+        // Resolve configType. We try the explicit --type first, then fall back to
+        // metadata/list (which only finds *live* configs). For deleted-only keys
+        // the user must pass --type since metadata/list won't see them.
+        let configType = flags.type ? normalizeConfigType(flags.type) : null;
+        if (flags.type && !configType) {
+            return this.err(`Unsupported --type "${flags.type}".`);
+        }
+        if (!configType) {
+            const candidates = await this.findCandidateTypes(key);
+            if (candidates.length === 0) {
+                return this.err(`Cannot infer config type for "${key}". Pass --type=<feature_flag|config|log_level|segment>.`);
+            }
+            if (candidates.length > 1) {
+                return this.err(`Ambiguous: "${key}" has deletion history for multiple types (${candidates.join(', ')}). Pass --type to disambiguate.`);
+            }
+            configType = candidates[0];
+        }
+        if (!RESTORABLE_TYPES.includes(configType)) {
+            return this.err(`Cannot restore type "${configType}". Restorable types: ${RESTORABLE_TYPES.join(', ')}.`);
+        }
+        const tombstoneRes = await this.apiClient.post('/api/v1/activity/getDeletionForKey', {
+            workspaceId: this.workspaceId,
+            configType,
+            configKey: key,
+        });
+        if (!tombstoneRes.ok) {
+            const errorMsg = tombstoneRes.error?.error || `Failed to look up deletion: ${tombstoneRes.status}`;
+            return this.err(errorMsg, { serverError: tombstoneRes.error });
+        }
+        const tombstone = tombstoneRes.json;
+        if (!tombstone) {
+            // The bead phrasing — kept verbatim so the friction-log entries that
+            // motivated this work map onto the new error message cleanly.
+            return this.err(`${key} is not currently deleted; nothing to restore.`);
+        }
+        if (!flags.yes) {
+            if (!isInteractive(flags)) {
+                return this.err(`Refusing to restore ${key} without confirmation. Pass --yes or run interactively.`);
+            }
+            const shortSha = tombstone.commitSha.slice(0, 8);
+            const confirmed = await confirmYesNo(`Restore ${configType}/${key}? Last deleted by ${tombstone.deletedBy} on ${tombstone.deletedAt} (sha ${shortSha}) [y/N] `);
+            if (!confirmed) {
+                return this.err(`Aborted: restore of ${key} not confirmed.`);
+            }
+        }
+        const restoreRes = await this.apiClient.post('/api/v1/activity/restoreItem', {
+            workspaceId: this.workspaceId,
+            configType,
+            configKey: key,
+        });
+        if (!restoreRes.ok) {
+            const errorMsg = restoreRes.error?.error || `Failed to restore: ${restoreRes.status}`;
+            return this.err(errorMsg, { serverError: restoreRes.error });
+        }
+        const result = restoreRes.json;
+        const url = `${getAppUrl()}/workspaces/${this.workspaceId}/flags/${result.configKey}`;
+        this.log(`Restored ${result.configType}/${result.configKey}`);
+        this.log(`  commit: ${result.commitSha.slice(0, 8)}`);
+        this.log(`  url:    ${url}`);
+        return {
+            configType: result.configType,
+            configKey: result.configKey,
+            commitSha: result.commitSha,
+            url,
+        };
+    }
+    /**
+     * When the user omits --type, fall back to listing live metadata so we can
+     * still find configType for keys that were *renamed-then-deleted* (live
+     * record gone, deletion history exists). Returns the unique config types
+     * that match the key — empty when nothing matches.
+     */
+    async findCandidateTypes(key) {
+        const resolved = await resolveConfigByKey(this, key);
+        if ('configType' in resolved && RESTORABLE_TYPES.includes(resolved.configType)) {
+            return [resolved.configType];
+        }
+        return [];
+    }
+}

package/dist/commands/activity.d.ts

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

package/dist/commands/activity.js

@@ -0,0 +1,17 @@
+import { BaseCommand } from '../index.js';
+export default class Activity extends BaseCommand {
+    static description = 'Inspect what changed in the workspace (recent commits, per-config history, deletions).';
+    static examples = [
+        '<%= config.bin %> activity feed',
+        '<%= config.bin %> activity history my.flag',
+        '<%= config.bin %> activity deleted',
+        '<%= config.bin %> activity restore my.flag --yes',
+    ];
+    async run() {
+        this.log('Use one of the activity subcommands:');
+        this.log('  qfg activity feed [--limit N] [--json]    # recent workspace changes');
+        this.log('  qfg activity history NAME [--json]        # per-config audit trail');
+        this.log('  qfg activity deleted [--json]             # tombstones for deleted items');
+        this.log('  qfg activity restore NAME [--yes] [--json]  # undelete a config');
+    }
+}

package/dist/commands/audit-log.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../index.js';
+/**
+ * Discoverability wrapper. Friction-log entries show agents reaching for
+ * `qfg audit-log` (with and without a positional). Dispatch by argument
+ * presence so both phrasings land on the right activity subcommand.
+ *
+ * Strategy A from qfg-d6cn.3: a thin top-level command that re-routes via
+ * `this.config.runCommand(...)`. We forward unknown flags as-is so
+ * `--limit`, `--json`, etc. flow through to the underlying command.
+ */
+export default class AuditLog extends BaseCommand {
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    run(): Promise<void>;
+}

package/dist/commands/audit-log.js

@@ -0,0 +1,30 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../index.js';
+/**
+ * Discoverability wrapper. Friction-log entries show agents reaching for
+ * `qfg audit-log` (with and without a positional). Dispatch by argument
+ * presence so both phrasings land on the right activity subcommand.
+ *
+ * Strategy A from qfg-d6cn.3: a thin top-level command that re-routes via
+ * `this.config.runCommand(...)`. We forward unknown flags as-is so
+ * `--limit`, `--json`, etc. flow through to the underlying command.
+ */
+export default class AuditLog extends BaseCommand {
+    static args = {
+        name: Args.string({
+            description: 'Optional config key. If present, dispatches to `activity history NAME`; otherwise `activity feed`.',
+        }),
+    };
+    static description = 'Alias: `qfg audit-log` → `qfg activity feed`; `qfg audit-log NAME` → `qfg activity history NAME`.';
+    static examples = ['<%= config.bin %> <%= command.id %>', '<%= config.bin %> <%= command.id %> my.flag'];
+    static strict = false;
+    async run() {
+        const { args, argv } = await this.parse(AuditLog);
+        const passthrough = argv.filter((token) => token.startsWith('-'));
+        if (args.name) {
+            await this.config.runCommand('activity:history', [args.name, ...passthrough]);
+            return;
+        }
+        await this.config.runCommand('activity:feed', passthrough);
+    }
+}

package/dist/commands/config-schema.d.ts

@@ -1,5 +1,6 @@
 import { BaseCommand } from '../index.js';
 import { JsonObj } from '../result.js';
+export declare const REFERENCE: string;
 export default class ConfigSchema extends BaseCommand {
     static description: string;
     static examples: string[];

package/dist/commands/config-schema.js

@@ -1,7 +1,7 @@
 import { Flags } from '@oclif/core';
 import { BaseCommand } from '../index.js';
 import { storedConfigJsonSchema } from '../init/schema.js';
-const REFERENCE = `
+export const REFERENCE = `
 ────────────────────────────────────────────────────────────
 FILE LAYOUT
 ────────────────────────────────────────────────────────────
@@ -104,6 +104,9 @@ OPERATOR REFERENCE
   PROP_LESS_THAN_OR_EQUAL          int or double
   PROP_GREATER_THAN                int or double
   PROP_GREATER_THAN_OR_EQUAL       int or double
+  PROP_SEMVER_LESS_THAN            string               semver comparison; valueToMatch is a semver string like "4.0.9"
+  PROP_SEMVER_EQUAL                string               semver comparison; valueToMatch is a semver string like "4.0.9"
+  PROP_SEMVER_GREATER_THAN         string               semver comparison; valueToMatch is a semver string like "4.0.9"
   PROP_BEFORE                      string (ISO 8601)    date/time comparison
   PROP_AFTER                       string (ISO 8601)
   PROP_MATCHES                     string               regex match

package/dist/commands/history.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../index.js';
+/**
+ * Discoverability wrapper for `qfg history NAME` — friction logs show agents
+ * reaching for this phrasing. Always dispatches to `activity history`.
+ */
+export default class History extends BaseCommand {
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    run(): Promise<void>;
+}

package/dist/commands/history.js

@@ -0,0 +1,19 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../index.js';
+/**
+ * Discoverability wrapper for `qfg history NAME` — friction logs show agents
+ * reaching for this phrasing. Always dispatches to `activity history`.
+ */
+export default class History extends BaseCommand {
+    static args = {
+        name: Args.string({ description: 'Config key to inspect', required: true }),
+    };
+    static description = 'Alias: `qfg history NAME` → `qfg activity history NAME`.';
+    static examples = ['<%= config.bin %> <%= command.id %> my.flag'];
+    static strict = false;
+    async run() {
+        const { args, argv } = await this.parse(History);
+        const passthrough = argv.filter((token) => token.startsWith('-'));
+        await this.config.runCommand('activity:history', [args.name, ...passthrough]);
+    }
+}

package/dist/commands/info.js

@@ -201,7 +201,7 @@ Related commands:
             // eslint-disable-next-line no-await-in-loop
             const request = await this.apiClient.post('/api/v1/analytics/evaluationStats', {
                 workspaceId: this.workspaceId,
-                environment: env.id,
+                environment: env.name,
                 configKey: key,
                 days: 1,
             });

package/dist/commands/log.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../index.js';
+/**
+ * Discoverability wrapper. `qfg log` is muscle memory from `git log`; route
+ * it to the workspace activity feed.
+ */
+export default class Log extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    run(): Promise<void>;
+}

package/dist/commands/log.js

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../index.js';
+/**
+ * Discoverability wrapper. `qfg log` is muscle memory from `git log`; route
+ * it to the workspace activity feed.
+ */
+export default class Log extends BaseCommand {
+    static description = 'Alias: `qfg log` → `qfg activity feed`.';
+    static examples = ['<%= config.bin %> <%= command.id %>', '<%= config.bin %> <%= command.id %> --limit 5'];
+    static strict = false;
+    async run() {
+        const { argv } = await this.parse(Log);
+        const passthrough = argv.filter((token) => token.startsWith('-'));
+        await this.config.runCommand('activity:feed', passthrough);
+    }
+}

package/dist/init/schema.js

@@ -6,33 +6,10 @@
  *
  * Derived from the Zod schemas in verify/validate.ts — keep in sync.
  */
+import { OPERATORS as operators } from '../verify/validate.js';
 const configTypes = ['config', 'feature_flag', 'log_level', 'segment'];
 const valueTypes = ['bool', 'string', 'int', 'double', 'json', 'string_list', 'duration', 'log_level'];
 const logLevels = ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL'];
-const operators = [
-    'ALWAYS_TRUE',
-    'PROP_IS_ONE_OF',
-    'PROP_IS_NOT_ONE_OF',
-    'PROP_STARTS_WITH_ONE_OF',
-    'PROP_DOES_NOT_START_WITH_ONE_OF',
-    'PROP_ENDS_WITH_ONE_OF',
-    'PROP_DOES_NOT_END_WITH_ONE_OF',
-    'PROP_CONTAINS_ONE_OF',
-    'PROP_DOES_NOT_CONTAIN_ONE_OF',
-    'PROP_LESS_THAN',
-    'PROP_LESS_THAN_OR_EQUAL',
-    'PROP_GREATER_THAN',
-    'PROP_GREATER_THAN_OR_EQUAL',
-    'PROP_BEFORE',
-    'PROP_AFTER',
-    'PROP_MATCHES',
-    'PROP_DOES_NOT_MATCH',
-    'IN_SEG',
-    'NOT_IN_SEG',
-    'IN_INT_RANGE',
-    'LOOKUP_KEY_IN',
-    'LOOKUP_KEY_NOT_IN',
-];
 // ── Value sub-schemas ──────────────────────────────────────────────────
 const boolValue = {
     type: 'object',

package/dist/quonfig.js

@@ -23,7 +23,7 @@ export const initQuonfig = async (_ctx, flagsOrDatafile) => {
         contextUploadMode: 'none',
         datafile,
         enableSSE: false,
-        apiUrl,
+        apiUrls: [apiUrl],
     });
     await quonfig.init();
     return quonfig;

package/dist/util/activity-lookup.d.ts

@@ -0,0 +1,25 @@
+import { APICommand } from '../index.js';
+export interface MetadataItem {
+    description?: string;
+    key: string;
+    name?: string;
+    type: string;
+    valueType: string;
+    version?: string;
+}
+export declare const ACTIVITY_CONFIG_TYPES: Set<string>;
+/**
+ * Resolve a user-provided NAME to (configType, configKey) by listing metadata
+ * and matching on key. Returns either the matched item or an error string.
+ *
+ * Mirrors the resolution pattern in `cli/src/commands/delete.ts` so callers
+ * can pass any of: feature_flag, config, log_level, segment, schema.
+ */
+export declare function resolveConfigByKey(command: APICommand, key: string): Promise<{
+    configType: string;
+    configKey: string;
+    item: MetadataItem;
+} | {
+    error: string;
+}>;
+export declare function normalizeConfigType(input: string): string | null;

package/dist/util/activity-lookup.js

@@ -0,0 +1,36 @@
+export const ACTIVITY_CONFIG_TYPES = new Set(['feature_flag', 'config', 'log_level', 'segment', 'schema']);
+/**
+ * Resolve a user-provided NAME to (configType, configKey) by listing metadata
+ * and matching on key. Returns either the matched item or an error string.
+ *
+ * Mirrors the resolution pattern in `cli/src/commands/delete.ts` so callers
+ * can pass any of: feature_flag, config, log_level, segment, schema.
+ */
+export async function resolveConfigByKey(command, key) {
+    const metaRes = await command.apiClient.post('/api/v1/metadata/list', { workspaceId: command.workspaceId });
+    if (!metaRes.ok) {
+        return { error: `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 { error: `${key} not found in this workspace.` };
+    }
+    if (!ACTIVITY_CONFIG_TYPES.has(item.type)) {
+        return { error: `Cannot inspect ${key}: unsupported type "${item.type}".` };
+    }
+    return { configType: item.type, configKey: item.key, item };
+}
+/** Map shorthand --type values onto the server's configType enum. */
+const TYPE_ALIASES = {
+    flag: 'feature_flag',
+    feature_flag: 'feature_flag',
+    config: 'config',
+    log_level: 'log_level',
+    'log-level': 'log_level',
+    segment: 'segment',
+    schema: 'schema',
+};
+export function normalizeConfigType(input) {
+    return TYPE_ALIASES[input] ?? null;
+}

package/dist/verify/validate.d.ts

@@ -19,6 +19,7 @@
  *  - Value type consistency
  *  - Weighted values non-empty and consistent
  */
+export declare const OPERATORS: readonly ["ALWAYS_TRUE", "PROP_IS_ONE_OF", "PROP_IS_NOT_ONE_OF", "PROP_STARTS_WITH_ONE_OF", "PROP_DOES_NOT_START_WITH_ONE_OF", "PROP_ENDS_WITH_ONE_OF", "PROP_DOES_NOT_END_WITH_ONE_OF", "PROP_CONTAINS_ONE_OF", "PROP_DOES_NOT_CONTAIN_ONE_OF", "PROP_LESS_THAN", "PROP_LESS_THAN_OR_EQUAL", "PROP_GREATER_THAN", "PROP_GREATER_THAN_OR_EQUAL", "PROP_SEMVER_LESS_THAN", "PROP_SEMVER_EQUAL", "PROP_SEMVER_GREATER_THAN", "PROP_BEFORE", "PROP_AFTER", "PROP_MATCHES", "PROP_DOES_NOT_MATCH", "IN_SEG", "NOT_IN_SEG", "IN_INT_RANGE", "LOOKUP_KEY_IN", "LOOKUP_KEY_NOT_IN"];
 export type Severity = 'error' | 'warning';
 export interface ValidationIssue {
     file: string;

package/dist/verify/validate.js

@@ -28,7 +28,7 @@ const LOG_LEVELS = ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL'];
 // ── Schemas (subset of app-quonfig config-schemas.ts) ───────────────────
 const ConfigTypeSchema = z.enum(['feature_flag', 'config', 'log_level', 'segment', 'schema']);
 const ValueTypeSchema = z.enum(['bool', 'string', 'int', 'double', 'json', 'string_list', 'duration', 'log_level']);
-const OperatorSchema = z.enum([
+export const OPERATORS = [
     'ALWAYS_TRUE',
     'PROP_IS_ONE_OF',
     'PROP_IS_NOT_ONE_OF',
@@ -54,7 +54,8 @@ const OperatorSchema = z.enum([
     'IN_INT_RANGE',
     'LOOKUP_KEY_IN',
     'LOOKUP_KEY_NOT_IN',
-]);
+];
+const OperatorSchema = z.enum(OPERATORS);
 const LogLevelSchema = z.enum(LOG_LEVELS);
 const BoolValueSchema = z.object({ type: z.literal('bool'), value: z.boolean() });
 const StringValueSchema = z.object({ type: z.literal('string'), value: z.string() });