@quonfig/cli 0.0.11 → 0.0.13

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/quonfig.d.ts

@@ -7,7 +7,7 @@ type Flags = {
 type FlagsOrDatafile = Flags | string;
 export declare const initQuonfig: (_ctx: CommandLike, flagsOrDatafile: FlagsOrDatafile) => Promise<Quonfig>;
 export declare const getQuonfig: () => Quonfig;
-export declare const overrideFor: ({ currentEnvironmentId, key, }: {
+export declare const overrideFor: ({ currentEnvironmentId: _currentEnvironmentId, key, }: {
     currentEnvironmentId: string;
     key: string;
 }) => Value | undefined;

package/dist/quonfig.js

@@ -32,16 +32,12 @@ export const getQuonfig = () => quonfig;
  * Get the raw ConfigResponse for a key (new quonfig JSON format).
  * The new format uses `default.rules` and `environment.rules` instead of `rows`.
  */
-const getRawConfig = (key) => {
-    return quonfig.rawConfig?.(key);
-};
+const getRawConfig = (key) => quonfig.rawConfig?.(key);
 /**
  * Find rules in an environment that target a specific user via criteria.
  */
-const getEnvironmentRules = (config) => {
-    return config.environment?.rules;
-};
-export const overrideFor = ({ currentEnvironmentId, key, }) => {
+const getEnvironmentRules = (config) => config.environment?.rules;
+export const overrideFor = ({ currentEnvironmentId: _currentEnvironmentId, key, }) => {
     const config = getRawConfig(key);
     if (!config)
         return undefined;
@@ -65,11 +61,11 @@ export const defaultValueFor = (_envId, key) => {
     // In the new format, the default value is the last rule in environment rules, or default rules
     const envRules = config.environment?.rules;
     if (envRules && envRules.length > 0) {
-        return envRules[envRules.length - 1]?.value;
+        return envRules.at(-1)?.value;
     }
     const defaultRules = config.default?.rules;
     if (defaultRules && defaultRules.length > 0) {
-        return defaultRules[defaultRules.length - 1]?.value;
+        return defaultRules.at(-1)?.value;
     }
     return undefined;
 };

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) {
@@ -37,7 +38,7 @@ const valueToString = (v) => {
         return '';
     return String(v.value);
 };
-const promptForValue = async ({ allowBlank, config, currentDefault, message, }) => {
+const promptForValue = async ({ allowBlank, config: _config, currentDefault, message, }) => {
     // In the new quonfig format, allowable values aren't stored at the config level.
     // Just prompt for a string input.
     if (!currentDefault) {

package/dist/util/config-value-dto.js

@@ -38,7 +38,23 @@ export function mapConfigValueToDto(configValue, valueType) {
         value = configValue.stringList.values;
     }
     else if (configValue.json !== undefined) {
-        value = configValue.json;
+        // ConfigValue.json is wrapped as {json: "<raw JSON string>"} (see coerceIntoType).
+        // The API expects the parsed JSON value, not the wrapper or the raw string —
+        // otherwise the server stores the default as {} (see qfg-c0q).
+        const rawJson = configValue.json.json;
+        if (typeof rawJson === 'string') {
+            try {
+                value = JSON.parse(rawJson);
+            }
+            catch {
+                // Fall back to raw string if somehow it isn't valid JSON — coerceIntoType
+                // should have already rejected this case, so this is defensive only.
+                value = rawJson;
+            }
+        }
+        else {
+            value = rawJson ?? configValue.json;
+        }
     }
     else if (configValue.duration !== undefined) {
         value = configValue.duration;

package/dist/util/encryption.js

@@ -72,7 +72,10 @@ export async function makeConfidentialValue(command, value, secret, environmentI
         });
     }
     // Fetch the encryption key config
-    const configRequest = await command.apiClient.post('/api/v1/metadata/getByKey', { workspaceId: command.workspaceId, key: secret.keyName });
+    const configRequest = await command.apiClient.post('/api/v1/metadata/getByKey', {
+        workspaceId: command.workspaceId,
+        key: secret.keyName,
+    });
     if (!configRequest.ok) {
         const message = configRequest.status === 404
             ? `Failed to create secret: ${secret.keyName} not found`

package/dist/util/friction-log.d.ts

@@ -4,7 +4,7 @@ export interface FrictionEntry {
     exitCode: number;
     ts: string;
 }
-export declare function getFrictionLogPath(envValue: string | undefined, cwd?: string): null | string;
+export declare function getFrictionLogPath(envValue?: string | undefined, cwd?: string): null | string;
 export declare function buildFrictionEntry(opts: {
     argv?: string[];
     binName?: string;

package/dist/util/friction-log.js

@@ -29,8 +29,12 @@ const MAX_STDERR_CAPTURE = 4000;
 export function extractLastErrorLine(stderr) {
     if (!stderr)
         return undefined;
+    // eslint-disable-next-line no-control-regex
     const stripped = stderr.replaceAll(/\u001B\[[\d;]*[A-Za-z]/g, '');
-    const lines = stripped.split('\n').map((l) => l.trim()).filter(Boolean);
+    const lines = stripped
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean);
     if (lines.length === 0)
         return undefined;
     const errorLine = [...lines].reverse().find((l) => /^(error|»|×|✖)/i.test(l));

package/dist/util/get-client.js

@@ -20,10 +20,58 @@ const getClient = async (command, sdkKey, profile) => {
     }
     let jwt;
     let workspaceId;
-    // If no SDK key provided, use WorkOS OAuth tokens
-    if (!sdkKey) {
+    const apiKey = process.env.QUONFIG_API_KEY;
+    // Auth precedence: explicit SDK key → QUONFIG_API_KEY env (CI) → WorkOS OAuth tokens.
+    if (sdkKey) {
+        // No jwt / workspace resolution — SDK-key path talks to api-delivery.
+    }
+    else if (apiKey && apiKey.length > 0) {
+        // API-key (workspace-scoped bearer) path. getValidAccessToken short-circuits
+        // when QUONFIG_API_KEY is set, so this never touches disk.
+        try {
+            jwt = await getValidAccessToken();
+        }
+        catch (error) {
+            command.error(error instanceof Error ? error.message : String(error), { exit: 1 });
+        }
+        const workspaceOverride = profile ?? process.env.QUONFIG_WORKSPACE;
+        if (!workspaceOverride) {
+            command.error('QUONFIG_API_KEY is set but no workspace was specified. Set QUONFIG_WORKSPACE=<slug-or-uuid> or pass --workspace=<slug-or-uuid>.', { exit: 1 });
+        }
+        const uuidPattern = /^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/i;
+        if (uuidPattern.test(workspaceOverride)) {
+            workspaceId = workspaceOverride;
+            command.verboseLog('ApiKey auth', { source: 'uuid', workspaceId });
+        }
+        else {
+            let res;
+            try {
+                res = await fetch(`${getApiUrl()}/api/v1/userWorkspaces/list`, {
+                    method: 'POST',
+                    headers: { Authorization: `Bearer ${jwt}`, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ json: {} }),
+                });
+            }
+            catch (error) {
+                command.error(`Failed to resolve workspace slug "${workspaceOverride}": ${error instanceof Error ? error.message : String(error)}`, { exit: 1 });
+            }
+            if (!res.ok) {
+                command.error(`Failed to resolve workspace slug "${workspaceOverride}" (HTTP ${res.status}). Check that QUONFIG_API_KEY is valid.`, { exit: 1 });
+            }
+            const body = (await res.json());
+            const entries = body.json ?? body ?? [];
+            const match = entries.find((w) => w.workspaceSlug === workspaceOverride);
+            if (!match) {
+                const available = entries.map((w) => w.workspaceSlug).join(', ') || '(none)';
+                command.error(`No workspace with slug "${workspaceOverride}" is accessible with this API key. Available: ${available}.`, { exit: 1 });
+            }
+            workspaceId = match.workspaceId;
+            command.verboseLog('ApiKey auth', { source: 'slug', slug: workspaceOverride, workspaceId });
+        }
+    }
+    else {
         const authConfig = await loadAuthConfig();
-        let tokens = await loadTokens();
+        const tokens = await loadTokens();
         command.verboseLog('OAuth auth', {
             hasAuthConfig: Boolean(authConfig),
             hasAccessToken: Boolean(tokens?.accessToken),

package/dist/util/get-valid-token.d.ts

@@ -1,5 +1,9 @@
 /**
  * Returns a valid (non-expired) WorkOS access token, refreshing if needed.
  * Throws if not logged in or if refresh fails.
+ *
+ * If `QUONFIG_API_KEY` is set in the environment (non-empty), it is used
+ * directly as a bearer token and no disk reads/writes or refresh calls
+ * are made. This is the non-interactive (CI) path.
  */
 export declare function getValidAccessToken(): Promise<string>;

package/dist/util/get-valid-token.js

@@ -1,10 +1,21 @@
 /**
  * Returns a valid (non-expired) WorkOS access token, refreshing if needed.
  * Throws if not logged in or if refresh fails.
+ *
+ * If `QUONFIG_API_KEY` is set in the environment (non-empty), it is used
+ * directly as a bearer token and no disk reads/writes or refresh calls
+ * are made. This is the non-interactive (CI) path.
  */
 import { decodeJWT, refreshAccessToken } from './oauth-client.js';
 import { loadTokens, saveTokens } from './token-storage.js';
 export async function getValidAccessToken() {
+    const envKey = process.env.QUONFIG_API_KEY;
+    if (envKey && envKey.length > 0) {
+        if (!envKey.startsWith('qf_uk_')) {
+            throw new Error(`QUONFIG_API_KEY must start with "qf_uk_" (got "${envKey.slice(0, 8)}..."). Generate one from the web UI under Settings → API Keys.`);
+        }
+        return envKey;
+    }
     const tokens = await loadTokens();
     if (!tokens?.accessToken) {
         throw new Error('Not authenticated. Please run `qfg login` first.');
@@ -17,7 +28,9 @@ export async function getValidAccessToken() {
             expired = payload.exp * 1000 < Date.now();
         }
     }
-    catch { /* use stored expiresAt */ }
+    catch {
+        /* use stored expiresAt */
+    }
     if (!expired) {
         return tokens.accessToken;
     }
@@ -32,7 +45,9 @@ export async function getValidAccessToken() {
             expiresAt = payload.exp * 1000;
         }
     }
-    catch { /* use fallback */ }
+    catch {
+        /* use fallback */
+    }
     const updated = {
         ...tokens,
         accessToken: refreshed.access_token,

package/dist/util/git-ops.js

@@ -4,7 +4,7 @@ const execFile = util.promisify(execFileCb);
 /**
  * Redact a token from a URL string so it is safe to display to users.
  */
-export const redactToken = (url) => url.replace(/:([^@/]+)@/, ':***@');
+export const redactToken = (url) => url.replace(/:([^/@]+)@/, ':***@');
 /**
  * Wrap execFile errors to strip tokens from the message.
  */
@@ -12,9 +12,9 @@ const safeExec = async (file, args, options) => {
     try {
         return await execFile(file, args, { cwd: options?.cwd });
     }
-    catch (err) {
-        const e = err;
-        const message = redactToken(e.message || String(err));
+    catch (error) {
+        const e = error;
+        const message = redactToken(e.message || String(error));
         const stderr = redactToken(e.stderr ?? '');
         const safeErr = new Error(message);
         safeErr.stderr = stderr;
@@ -136,11 +136,11 @@ export const gitMergeFfOnly = async (dir) => {
  */
 export const gitSetRemote = async (dir, url) => {
     const existing = await getRemoteUrl(dir);
-    if (existing !== null) {
-        await safeExec('git', ['-C', dir, 'remote', 'set-url', 'origin', url]);
+    if (existing === null) {
+        await safeExec('git', ['-C', dir, 'remote', 'add', 'origin', url]);
     }
     else {
-        await safeExec('git', ['-C', dir, 'remote', 'add', 'origin', url]);
+        await safeExec('git', ['-C', dir, 'remote', 'set-url', 'origin', url]);
     }
 };
 export const gitPushForceLease = async (dir) => {

package/dist/util/gitea-api.d.ts

@@ -1,8 +1,8 @@
 import { GiteaTokenEntry } from './gitea-token-storage.js';
 export interface GiteaTokenResponse {
-    token: string;
-    repoUrl: string;
     expiresAt: string | null;
+    repoUrl: string;
+    token: string;
 }
 export declare const mintGiteaToken: (workspaceId: string, scope: "read" | "write", purpose: "pull" | "bootstrap") => Promise<GiteaTokenResponse>;
 /**

package/dist/util/gitea-api.js

@@ -7,7 +7,7 @@ export const mintGiteaToken = async (workspaceId, scope, purpose) => {
     const res = await fetch(`${apiUrl}/api/v1/gitea/token`, {
         method: 'POST',
         headers: {
-            'Authorization': `Bearer ${accessToken}`,
+            Authorization: `Bearer ${accessToken}`,
             'Content-Type': 'application/json',
         },
         body: JSON.stringify({ json: { scope, workspaceId, purpose } }),
@@ -23,10 +23,12 @@ export const mintGiteaToken = async (workspaceId, scope, purpose) => {
             else if (body?.message)
                 message = body.message;
         }
-        catch { /* use raw text */ }
+        catch {
+            /* use raw text */
+        }
         throw new Error(message || text);
     }
-    const body = await res.json();
+    const body = (await res.json());
     const data = body.json ?? body;
     return data;
 };

package/dist/util/gitea-token-storage.d.ts

@@ -1,7 +1,7 @@
 export interface GiteaTokenEntry {
-    token: string;
-    repoUrl: string;
     expiresAt: string | null;
+    repoUrl: string;
+    token: string;
 }
 export declare const loadGiteaToken: (workspaceId: string) => Promise<GiteaTokenEntry | null>;
 export declare const saveGiteaToken: (workspaceId: string, entry: GiteaTokenEntry) => Promise<void>;

package/dist/util/gitea-token-storage.js

@@ -6,7 +6,7 @@ const BUFFER_MS = 5 * 60 * 1000; // 5 minutes
 const getQuonfigDir = () => path.join(os.homedir(), '.quonfig');
 const getGiteaTokenFile = () => {
     const domain = getDomain();
-    const filename = domain !== 'quonfig.com' ? `gitea-tokens-${domain.replaceAll('.', '-')}.json` : 'gitea-tokens.json';
+    const filename = domain === 'quonfig.com' ? 'gitea-tokens.json' : `gitea-tokens-${domain.replaceAll('.', '-')}.json`;
     return path.join(getQuonfigDir(), filename);
 };
 const ensureQuonfigDir = async () => {

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/util/oauth-client.js

@@ -53,7 +53,7 @@ export const pollForToken = async (deviceCode, interval, expiresIn, verbose) =>
             return response.json();
         }
         // eslint-disable-next-line no-await-in-loop
-        const error = await response.json().catch(() => ({}));
+        const error = (await response.json().catch(() => ({})));
         const errorCode = error.error || error.code;
         if (errorCode === 'authorization_pending') {
             continue;

package/dist/util/token-storage.js

@@ -5,7 +5,7 @@ import { getDomain } from './domain-urls.js';
 const getQuonfigDir = (options) => options?.quonfigDir || path.join(os.homedir(), '.quonfig');
 const getTokenFile = (options) => {
     const domain = getDomain();
-    const filename = domain !== 'quonfig.com' ? `tokens-${domain.replaceAll('.', '-')}.json` : 'tokens.json';
+    const filename = domain === 'quonfig.com' ? 'tokens.json' : `tokens-${domain.replaceAll('.', '-')}.json`;
     return path.join(getQuonfigDir(options), filename);
 };
 const getConfigFile = (options) => path.join(getQuonfigDir(options), 'config');
@@ -86,7 +86,7 @@ export const loadAuthConfig = async (options) => {
             config.defaultProfile = defaultMatch[1].trim();
         }
         // Parse profiles — each block starts with [profile name] and contains key=value lines
-        const profileBlockRegex = /\[profile\s+(\w+)]\s*\n((?:[^\[]*\n?)*)/g;
+        const profileBlockRegex = /\[profile\s+(\w+)]\s*\n((?:[^[]*\n?)*)/g;
         let match;
         while ((match = profileBlockRegex.exec(data)) !== null) {
             const profileName = match[1];

package/dist/verify/standalone.d.ts

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 /**
  * Standalone workspace validator.
  *