@quonfig/cli 0.0.1

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

@@ -0,0 +1,11 @@
+import type { Environment } from '../api/get-environments.js';
+import { APICommand } from '../index.js';
+import { JsonObj } from '../result.js';
+declare const getEnvironment: ({ allowDefaultEnvironment, command, flags, message, providedEnvironment, }: {
+    allowDefaultEnvironment?: boolean;
+    command: APICommand;
+    flags: JsonObj;
+    message: string;
+    providedEnvironment: string | undefined;
+}) => Promise<Environment | undefined>;
+export default getEnvironment;

package/dist/ui/get-environment.js

@@ -0,0 +1,42 @@
+import { getEnvironments } from '../api/get-environments.js';
+import autocomplete from '../util/autocomplete.js';
+import isInteractive from '../util/is-interactive.js';
+const defaultEnvironmentName = '[Default]';
+const getEnvironment = async ({ allowDefaultEnvironment = false, command, flags, message, providedEnvironment, }) => {
+    if (!providedEnvironment && !isInteractive(flags)) {
+        command.err("'environment' is required when interactive mode isn't available.");
+    }
+    const environments = await getEnvironments(command);
+    command.verboseLog({ environments });
+    if (providedEnvironment?.toLowerCase() === defaultEnvironmentName.toLowerCase()) {
+        return {
+            id: '',
+            name: defaultEnvironmentName,
+        };
+    }
+    if (providedEnvironment) {
+        const matchingEnvironment = environments.find((environment) => environment.name.toLowerCase() === providedEnvironment.toLowerCase());
+        if (!matchingEnvironment) {
+            command.err(`Environment \`${providedEnvironment}\` not found. Valid environments: ${environments
+                .map((environment) => environment.name)
+                .join(', ')}`);
+        }
+        return matchingEnvironment;
+    }
+    const environmentNames = environments.map((environment) => environment.name);
+    if (allowDefaultEnvironment) {
+        environmentNames.unshift(defaultEnvironmentName);
+    }
+    const selectedEnvironment = await autocomplete({
+        message,
+        source: environmentNames,
+    });
+    if (selectedEnvironment === defaultEnvironmentName) {
+        return {
+            id: '',
+            name: defaultEnvironmentName,
+        };
+    }
+    return environments.find((environment) => environment.name === selectedEnvironment);
+};
+export default getEnvironment;

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

@@ -0,0 +1,27 @@
+import { Quonfig } from '@quonfig/node';
+type Flags = {
+    ['sdk-key']?: string;
+    interactive?: boolean;
+};
+export type CommandLike = {
+    err: (input: Error | string, options?: {
+        code?: string | undefined;
+        exit: false;
+    }) => void;
+    error: (input: Error | string, options: {
+        code?: string | undefined;
+        exit: false;
+    }) => void;
+};
+declare const getKey: ({ args, command, flags, message, }: {
+    args: {
+        name?: string;
+    };
+    command: CommandLike;
+    flags: Flags;
+    message: string;
+}) => Promise<{
+    key: null | string | undefined;
+    quonfig: Quonfig | undefined;
+}>;
+export default getKey;

package/dist/ui/get-key.js

@@ -0,0 +1,15 @@
+import { initQuonfig } from '../quonfig.js';
+import autocomplete from '../util/autocomplete.js';
+import isInteractive from '../util/is-interactive.js';
+const getKey = async ({ args, command, flags, message, }) => {
+    if (!args.name && !isInteractive(flags)) {
+        command.err("'name' argument is required when interactive mode isn't available.");
+    }
+    const quonfig = await initQuonfig(command, flags);
+    let key = args.name;
+    if (!key) {
+        key = await autocomplete({ message, source: () => quonfig.keys() });
+    }
+    return { key, quonfig };
+};
+export default getKey;

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

@@ -0,0 +1,5 @@
+declare const getString: ({ allowBlank, message }: {
+    allowBlank: boolean;
+    message: string;
+}) => Promise<string>;
+export default getString;

package/dist/ui/get-string.js

@@ -0,0 +1,8 @@
+import { ux } from '@oclif/core';
+const getString = async ({ allowBlank, message }) => {
+    const options = {
+        required: !allowBlank,
+    };
+    return ux.prompt(message, options);
+};
+export default getString;

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

@@ -0,0 +1,18 @@
+import { Quonfig } from '@quonfig/node';
+import { Result } from '../result.js';
+interface Environment {
+    id: string;
+    name: string;
+}
+declare const getValue: ({ allowBlank, desiredValue, environment, flags, key, message, quonfig, }: {
+    allowBlank?: boolean;
+    desiredValue: string | undefined;
+    environment?: Environment;
+    flags: {
+        interactive: boolean;
+    };
+    key?: string;
+    message: string;
+    quonfig: Quonfig;
+}) => Promise<Result<string>>;
+export default getValue;

package/dist/ui/get-value.js

@@ -0,0 +1,46 @@
+import { defaultValueFor } from '../quonfig.js';
+import { failure, noop, success } from '../result.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 (!key) {
+        const value = desiredValue ?? (await promptForValue({ allowBlank, message }));
+        if (value === undefined || value === null) {
+            return noop();
+        }
+        return success(value);
+    }
+    const currentDefault = environment ? defaultValueFor(environment.id, key) : undefined;
+    const config = quonfig.rawConfig(key);
+    if (!config) {
+        return failure(`Could not find config named ${key}`);
+    }
+    const selectedValue = desiredValue ?? (await promptForValue({ allowBlank, config, currentDefault, message }));
+    if (selectedValue === undefined || selectedValue === null) {
+        return noop();
+    }
+    if (selectedValue === currentDefault?.value?.toString()) {
+        return noop(`The default is already \`${selectedValue}\``);
+    }
+    return validateValue(quonfig, key, selectedValue);
+};
+const valueToString = (v) => {
+    if (!v)
+        return '';
+    if (v.value === undefined || v.value === null)
+        return '';
+    return String(v.value);
+};
+const promptForValue = async ({ allowBlank, 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) {
+        return getString({ allowBlank, message });
+    }
+    const autoCompleteMessage = `The current default is \`${valueToString(currentDefault)}\`. Enter your new default.`;
+    return getString({ allowBlank, message: autoCompleteMessage });
+};
+export default getValue;

package/dist/util/autocomplete.d.ts

@@ -0,0 +1,6 @@
+type Args = {
+    message: string;
+    source: (() => string[]) | string[];
+};
+declare const autocomplete: ({ message, source }: Args) => Promise<string | null>;
+export default autocomplete;

package/dist/util/autocomplete.js

@@ -0,0 +1,25 @@
+// eslint-disable-next-line import/default
+import fuzzy from 'fuzzy';
+import internalAutocomplete from 'inquirer-autocomplete-standalone';
+import { green } from '../util/color.js';
+const options = {
+    post: '\u001B[0m',
+    pre: '\u001B[31m',
+};
+const unformat = (str) => str.replaceAll(options.pre, '').replaceAll(options.post, '');
+const autocomplete = async ({ message, source }) => {
+    try {
+        const result = await internalAutocomplete({
+            message: green(message),
+            async source(input) {
+                const list = typeof source === 'function' ? source() : source;
+                // eslint-disable-next-line import/no-named-as-default-member
+                return fuzzy.filter(input ?? '', list, options).map((el) => ({ value: el.string }));
+            },
+        });
+        return unformat(result);
+    }
+    catch { }
+    return null;
+};
+export default autocomplete;

package/dist/util/coerce.d.ts

@@ -0,0 +1,7 @@
+import type { ConfigValue } from '@quonfig/node';
+import { ConfigValueType } from '@quonfig/node';
+type ConfigValueWithConfigValueType = [ConfigValue, ConfigValueType];
+export declare const TYPE_MAPPING: Record<string, ConfigValueType>;
+export declare const coerceIntoType: (type: string, value: string) => ConfigValueWithConfigValueType | undefined;
+export declare const coerceBool: (value: string) => boolean;
+export {};

package/dist/util/coerce.js

@@ -0,0 +1,62 @@
+import { ConfigValueType } from '@quonfig/node';
+const TRUE_VALUES = new Set(['true', '1', 't']);
+const BOOLEAN_VALUES = new Set([...TRUE_VALUES, 'false', '0', 'f']);
+export const TYPE_MAPPING = {
+    bool: ConfigValueType.Bool,
+    boolean: ConfigValueType.Bool,
+    double: ConfigValueType.Double,
+    int: ConfigValueType.Int,
+    string: ConfigValueType.String,
+    'string-list': ConfigValueType.StringList,
+    stringList: ConfigValueType.StringList,
+};
+export const coerceIntoType = (type, value) => {
+    switch (type) {
+        case 'string': {
+            return [{ string: value }, TYPE_MAPPING[type]];
+        }
+        case 'int': {
+            try {
+                const int = BigInt(value);
+                return [{ int }, TYPE_MAPPING[type]];
+            }
+            catch {
+                throw new TypeError(`Invalid default value for int: ${value}`);
+            }
+        }
+        case 'double': {
+            const double = Number.parseFloat(value);
+            if (Number.isNaN(double)) {
+                throw new TypeError(`Invalid default value for double: ${value}`);
+            }
+            return [{ double }, TYPE_MAPPING[type]];
+        }
+        case 'bool':
+        case 'boolean': {
+            return [{ bool: coerceBool(value) }, TYPE_MAPPING[type]];
+        }
+        case 'stringList':
+        case 'string-list': {
+            return [{ stringList: { values: value.split(/\s*,\s*/) } }, TYPE_MAPPING[type]];
+        }
+        case 'json': {
+            try {
+                // ensure the value is valid JSON
+                JSON.parse(value);
+                return [{ json: { json: value } }, ConfigValueType.Json];
+            }
+            catch {
+                throw new TypeError(`Invalid default value for JSON: ${value}`);
+            }
+        }
+        default: {
+            return undefined;
+        }
+    }
+};
+export const coerceBool = (value) => {
+    if (!BOOLEAN_VALUES.has(value.toLowerCase())) {
+        throw new TypeError(`Invalid default value for boolean: ${value}`);
+    }
+    return TRUE_VALUES.has(value.toLowerCase());
+};

package/dist/util/color.d.ts

@@ -0,0 +1,3 @@
+export declare const red: (message: string) => string;
+export declare const green: (message: string) => string;
+export declare const checkmark: string;

package/dist/util/color.js

@@ -0,0 +1,4 @@
+import chalk from 'chalk';
+export const red = (message) => chalk.red(message);
+export const green = (message) => chalk.green(message);
+export const checkmark = chalk.green('✔');

package/dist/util/config-value-dto.d.ts

@@ -0,0 +1,16 @@
+import type { ConfigValue } from '@quonfig/node';
+import { ConfigValueType } from '@quonfig/node';
+/**
+ * Maps a ConfigValue to the DTO format expected by the API.
+ * Used by both create and set-default commands.
+ * @param configValue - The config value to convert
+ * @param valueType - The type of the config value
+ * @returns The DTO representation of the config value
+ */
+export declare function mapConfigValueToDto(configValue: ConfigValue, valueType: ConfigValueType): Record<string, unknown>;
+/**
+ * Converts a ConfigValueType enum to its string representation for the API.
+ * @param valueType - The config value type enum
+ * @returns The string representation of the value type
+ */
+export declare function mapValueTypeToString(valueType: ConfigValueType): string;

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

@@ -0,0 +1,82 @@
+import { ConfigValueType } from '@quonfig/node';
+/**
+ * Maps a ConfigValue to the DTO format expected by the API.
+ * Used by both create and set-default commands.
+ * @param configValue - The config value to convert
+ * @param valueType - The type of the config value
+ * @returns The DTO representation of the config value
+ */
+export function mapConfigValueToDto(configValue, valueType) {
+    const dto = {
+        type: mapValueTypeToString(valueType),
+    };
+    // Handle provided (env-var) values
+    if (configValue.provided) {
+        return {
+            ...dto,
+            provided: {
+                source: configValue.provided.source,
+                lookup: configValue.provided.lookup,
+            },
+        };
+    }
+    // Extract the actual value based on type
+    let value;
+    if (configValue.bool !== undefined) {
+        value = configValue.bool;
+    }
+    else if (configValue.string !== undefined) {
+        value = configValue.string;
+    }
+    else if (configValue.int !== undefined) {
+        value = configValue.int;
+    }
+    else if (configValue.double !== undefined) {
+        value = configValue.double;
+    }
+    else if (configValue.stringList !== undefined) {
+        value = configValue.stringList.values;
+    }
+    else if (configValue.json !== undefined) {
+        value = configValue.json;
+    }
+    else if (configValue.duration !== undefined) {
+        value = configValue.duration;
+    }
+    else if (configValue.intRange !== undefined) {
+        value = configValue.intRange;
+    }
+    else if (configValue.value !== undefined) {
+        // Handle encrypted/confidential values where value is directly set
+        value = configValue.value;
+    }
+    dto.value = value;
+    if (configValue.confidential) {
+        dto.confidential = true;
+    }
+    if (configValue.decryptWith) {
+        dto.decryptWith = configValue.decryptWith;
+    }
+    return dto;
+}
+/**
+ * Converts a ConfigValueType enum to its string representation for the API.
+ * @param valueType - The config value type enum
+ * @returns The string representation of the value type
+ */
+export function mapValueTypeToString(valueType) {
+    const mapping = {
+        [ConfigValueType.Bool]: 'bool',
+        [ConfigValueType.String]: 'string',
+        [ConfigValueType.Int]: 'int',
+        [ConfigValueType.Double]: 'double',
+        [ConfigValueType.StringList]: 'string_list',
+        [ConfigValueType.Json]: 'json',
+        [ConfigValueType.LimitDefinition]: 'limit_definition',
+        [ConfigValueType.Duration]: 'duration',
+        [ConfigValueType.IntRange]: 'int_range',
+        [ConfigValueType.Bytes]: 'bytes',
+        [ConfigValueType.LogLevel]: 'log_level',
+    };
+    return mapping[valueType] || 'string';
+}

package/dist/util/context.d.ts

@@ -0,0 +1,18 @@
+interface JavascriptClientContext {
+    type: string;
+    values: {
+        [key: string]: {
+            string: string;
+        };
+    };
+}
+interface JavascriptClientContextInput {
+    contexts: JavascriptClientContext[];
+}
+interface ContextObj {
+    [key: string]: {
+        [key: string]: string;
+    };
+}
+export declare const javaScriptClientFormattedContextToContext: (input: JavascriptClientContextInput) => ContextObj;
+export {};

package/dist/util/context.js

@@ -0,0 +1,10 @@
+export const javaScriptClientFormattedContextToContext = (input) => {
+    const result = {};
+    for (const context of input.contexts) {
+        result[context.type] = {};
+        for (const [key, value] of Object.entries(context.values)) {
+            result[context.type][key] = value.string;
+        }
+    }
+    return result;
+};

package/dist/util/domain-urls.d.ts

@@ -0,0 +1,3 @@
+export declare const getDomain: () => string;
+export declare const getApiUrl: (domain?: string) => string;
+export declare const getAppUrl: (domain?: string) => string;

package/dist/util/domain-urls.js

@@ -0,0 +1,18 @@
+const DEFAULT_DOMAIN = 'quonfig.com';
+export const getDomain = () => process.env.QUONFIG_DOMAIN || DEFAULT_DOMAIN;
+export const getApiUrl = (domain) => {
+    // Allow full override for local development
+    if (process.env.QUONFIG_API_BASE_URL_OVERRIDE) {
+        return process.env.QUONFIG_API_BASE_URL_OVERRIDE;
+    }
+    const actualDomain = domain || getDomain();
+    return `https://app.${actualDomain}`;
+};
+export const getAppUrl = (domain) => {
+    // Allow explicit override for app URL
+    if (process.env.QUONFIG_APP_BASE_URL_OVERRIDE) {
+        return process.env.QUONFIG_APP_BASE_URL_OVERRIDE;
+    }
+    const actualDomain = domain || getDomain();
+    return `https://app.${actualDomain}`;
+};

package/dist/util/encryption.d.ts

@@ -0,0 +1,20 @@
+import type { APICommand } from '../index.js';
+import type { Secret } from './secret-flags.js';
+import { Result } from '../result.js';
+/**
+ * Decrypts an encrypted config value
+ * Based on @quonfig/node/src/encryption.ts
+ * @param {string} encryptedString - The encrypted string in format: encryptedData--IV--authTag
+ * @param {string} keyStringHex - The encryption key as a 64-character hex string
+ * @returns {string} The decrypted plaintext value
+ */
+export declare function decrypt(encryptedString: string, keyStringHex: string): string;
+/**
+ * Creates an encrypted ConfigValue using the new v1 API endpoints
+ * @param command - The APICommand instance for API calls and logging
+ * @param value - The plaintext value to encrypt
+ * @param secret - Secret configuration containing key name
+ * @param environmentId - Environment ID to fetch encryption key for (empty string for default)
+ * @returns Result<ConfigValue> with encrypted value or error
+ */
+export declare function makeConfidentialValue(command: APICommand, value: string, secret: Secret, environmentId: string): Promise<Result<any>>;

package/dist/util/encryption.js

@@ -0,0 +1,153 @@
+import { encryption } from '@quonfig/node';
+import forge from 'node-forge';
+import { failure, success } from '../result.js';
+const SEPARATOR = '--';
+const KEY_LENGTH = 32; // 32 bytes for AES-256
+const TAG_LENGTH = 16; // 16 bytes for GCM tag
+/**
+ * Decrypts an encrypted config value
+ * Based on @quonfig/node/src/encryption.ts
+ * @param {string} encryptedString - The encrypted string in format: encryptedData--IV--authTag
+ * @param {string} keyStringHex - The encryption key as a 64-character hex string
+ * @returns {string} The decrypted plaintext value
+ */
+export function decrypt(encryptedString, keyStringHex) {
+    if (keyStringHex.length !== KEY_LENGTH * 2) {
+        throw new Error(`Invalid key length. Key must be a ${KEY_LENGTH * 2}-character hex string.`);
+    }
+    const parts = encryptedString.split(SEPARATOR);
+    if (parts.length !== 3) {
+        throw new Error('Invalid encrypted string. Must contain encrypted data, IV, and auth tag.');
+    }
+    const encryptedDataPart = parts[0];
+    const ivPart = parts[1];
+    const authTagPart = parts[2];
+    if (encryptedDataPart === undefined || ivPart === undefined || authTagPart === undefined) {
+        throw new Error('Invalid encrypted string. All parts must be defined.');
+    }
+    if (encryptedDataPart === '') {
+        return '';
+    }
+    // Convert hex strings to bytes
+    const keyBytes = forge.util.hexToBytes(keyStringHex);
+    const encryptedBytes = forge.util.hexToBytes(encryptedDataPart);
+    const ivBytes = forge.util.hexToBytes(ivPart);
+    const tagBytes = forge.util.hexToBytes(authTagPart);
+    // Create decipher
+    const decipher = forge.cipher.createDecipher('AES-GCM', keyBytes);
+    decipher.start({
+        iv: ivBytes,
+        tag: forge.util.createBuffer(tagBytes),
+        tagLength: TAG_LENGTH * 8, // tagLength is in bits
+    });
+    // Decrypt the data
+    decipher.update(forge.util.createBuffer(encryptedBytes));
+    const success = decipher.finish();
+    if (!success) {
+        throw new Error('Authentication tag verification failed');
+    }
+    return decipher.output.toString();
+}
+/**
+ * Creates an encrypted ConfigValue using the new v1 API endpoints
+ * @param command - The APICommand instance for API calls and logging
+ * @param value - The plaintext value to encrypt
+ * @param secret - Secret configuration containing key name
+ * @param environmentId - Environment ID to fetch encryption key for (empty string for default)
+ * @returns Result<ConfigValue> with encrypted value or error
+ */
+export async function makeConfidentialValue(command, value, secret, environmentId) {
+    // First check if the encryption key exists in metadata
+    const metadataRequest = await command.apiClient.post('/api/v1/metadata/list', { workspaceId: command.workspaceId });
+    if (!metadataRequest.ok) {
+        return failure(`Failed to check if encryption key exists: ${metadataRequest.status}`, {
+            phase: 'finding-secret',
+        });
+    }
+    const metadata = metadataRequest.json;
+    const keyExists = metadata.configs.some((config) => config.key === secret.keyName);
+    if (!keyExists) {
+        return failure(`Failed to create secret: encryption key '${secret.keyName}' does not exist. Please create it first or use --secret-key-name to specify a different key.`, {
+            phase: 'finding-secret',
+        });
+    }
+    // Fetch the encryption key config
+    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`
+            : `Failed to fetch encryption key config ${secret.keyName}: ${configRequest.status}`;
+        return failure(message, {
+            phase: 'finding-secret',
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const keyConfig = configRequest.json;
+    // Find the encryption key for this environment (or default)
+    let secretKey;
+    let envVar;
+    // Check environment-specific config first
+    if (keyConfig.environments && environmentId) {
+        /* eslint-disable @typescript-eslint/no-explicit-any */
+        const envConfig = keyConfig.environments.find((env) => String(env.id) === String(environmentId));
+        /* eslint-enable @typescript-eslint/no-explicit-any */
+        const ruleValue = envConfig?.rules?.[0]?.value;
+        // Check if it's a provided value (env var)
+        if (ruleValue?.type === 'provided' && ruleValue?.value?.lookup) {
+            envVar = ruleValue.value.lookup;
+        }
+        // Check for old format: provided.lookup
+        else if (ruleValue?.provided?.lookup) {
+            envVar = ruleValue.provided.lookup;
+        }
+        // Otherwise it's a literal value
+        else if (ruleValue?.value && typeof ruleValue.value === 'string') {
+            secretKey = ruleValue.value;
+        }
+    }
+    // Fall back to default config
+    if (!secretKey && !envVar) {
+        const defaultValue = keyConfig.default?.rules?.[0]?.value;
+        // Check if it's a provided value (env var)
+        if (defaultValue?.type === 'provided' && defaultValue?.value?.lookup) {
+            envVar = defaultValue.value.lookup;
+        }
+        // Check for old format: provided.lookup
+        else if (defaultValue?.provided?.lookup) {
+            envVar = defaultValue.provided.lookup;
+        }
+        // Otherwise it's a literal value
+        else if (defaultValue?.value && typeof defaultValue.value === 'string') {
+            secretKey = defaultValue.value;
+        }
+    }
+    // If we have an env var, resolve it
+    if (envVar && !secretKey) {
+        secretKey = process.env[envVar];
+        command.log(`Encrypting with key from env var: ${envVar}`);
+        if (typeof secretKey !== 'string') {
+            return failure(`Failed to create secret: env var ${envVar} is not present`, {
+                phase: 'finding-secret',
+            });
+        }
+    }
+    // If we have a literal value, use it
+    if (secretKey) {
+        command.verboseLog(`Using literal value from ${secret.keyName} to encrypt secret`);
+    }
+    if (!secretKey) {
+        return failure(`Failed to create secret: ${secret.keyName} does not have a value configured for environment ${environmentId || 'default'} or default env`, {
+            phase: 'finding-secret',
+        });
+    }
+    if (secretKey.length !== 64) {
+        return failure(`Secret key is too short. ${secret.keyName} must be 64 characters.`, {
+            phase: 'finding-secret',
+        });
+    }
+    return success({
+        confidential: true,
+        decryptWith: secret.keyName,
+        value: encryption.encrypt(value, secretKey),
+    });
+}

package/dist/util/file-manager.d.ts

@@ -0,0 +1,12 @@
+interface CreateFileManagerArgs {
+    outputDirectory: string;
+    verboseLog: (category: string | unknown, message?: unknown) => void;
+}
+interface FileManager {
+    writeFile: (args: {
+        data: string;
+        filename: string;
+    }) => Promise<void>;
+}
+export declare function createFileManager({ outputDirectory, verboseLog }: CreateFileManagerArgs): FileManager;
+export {};

package/dist/util/file-manager.js

@@ -0,0 +1,16 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function createFileManager({ outputDirectory, verboseLog }) {
+    return {
+        async writeFile({ data, filename }) {
+            // Ensure the directory exists
+            verboseLog(`Creating directory: ${outputDirectory}`);
+            await fs.promises.mkdir(outputDirectory, { recursive: true });
+            // Write the generated code to the file
+            const outputFile = path.join(outputDirectory, filename);
+            verboseLog(`Writing file: ${outputFile}`);
+            await fs.promises.writeFile(outputFile, data);
+            verboseLog(`Wrote file at ${outputFile}`);
+        },
+    };
+}