@copado/agentia-cli 0.122.0-alpha.1 → 1.0.0-beta.1

package/dist/lib/environment-flags.js

@@ -1,165 +1,18 @@
-import { Flags } from '@oclif/core';
-import { DEFAULT_ENVIRONMENT_PLATFORM, DEFAULT_ENVIRONMENT_TYPE, ENVIRONMENT_TYPES, } from './environment-types.js';
-import { buildListPaginationQuery, listPaginationFlags } from './list-pagination.js';
-export const environmentPlatformFlag = Flags.string({
-    default: DEFAULT_ENVIRONMENT_PLATFORM,
-    description: 'Environment platform',
-});
-export const environmentTypeFlag = Flags.string({
-    description: 'Environment type',
-    options: [...ENVIRONMENT_TYPES],
-});
-export const environmentCreateTypeFlag = Flags.string({
-    default: DEFAULT_ENVIRONMENT_TYPE,
-    description: 'Environment type',
-    options: [...ENVIRONMENT_TYPES],
-});
-export const environmentListFilterFlags = {
-    ...listPaginationFlags,
-    name: Flags.string({
-        description: 'Filter by name',
-    }),
-    'org-id': Flags.string({
-        description: 'Filter by Salesforce org ID',
-    }),
-    platform: Flags.string({
-        description: 'Filter by platform',
-    }),
-    type: environmentTypeFlag,
-};
-const ENVIRONMENT_LIST_FILTER_FLAG_TO_KEY = {
-    name: 'name',
-    'org-id': 'orgId',
-    platform: 'platform',
-    type: 'type',
-};
-export function buildEnvironmentListFilters(flags) {
-    const filters = {};
-    for (const flagKey of Object.keys(ENVIRONMENT_LIST_FILTER_FLAG_TO_KEY)) {
-        const value = flags[flagKey];
-        if (typeof value === 'string') {
-            const filterKey = ENVIRONMENT_LIST_FILTER_FLAG_TO_KEY[flagKey];
-            Object.assign(filters, { [filterKey]: value });
-        }
-    }
-    return { ...filters, ...buildListPaginationQuery(flags) };
-}
-export const environmentMutationStringFlags = {
-    'apex-test-level': Flags.string({
-        description: 'Apex test level',
-    }),
-    name: Flags.string({
-        description: 'Environment name',
-    }),
-    namespace: Flags.string({
-        description: 'Environment namespace',
-    }),
-    platform: Flags.string({
-        description: 'Environment platform',
-    }),
-    'promotion-default-credential': Flags.string({
-        description: 'Default credential for promotions',
-    }),
-    'run-specified-tests': Flags.string({
-        description: 'Specified tests to run',
-    }),
-    type: environmentTypeFlag,
-    'validation-promotion-default-credential': Flags.string({
-        description: 'Default credential for validation promotions',
-    }),
-};
-export const environmentMutationBooleanFlags = {
-    'enable-rollback': Flags.boolean({
-        allowNo: true,
-        description: 'Enable rollback',
-    }),
-    'index-back-promotion-metadata': Flags.boolean({
-        allowNo: true,
-        description: 'Index back promotion metadata',
-    }),
-    'run-local-tests': Flags.boolean({
-        allowNo: true,
-        description: 'Run local tests',
-    }),
-};
-const ENVIRONMENT_MUTATION_FLAG_TO_PAYLOAD_KEY = {
-    'apex-test-level': 'apexTestLevel',
-    'enable-rollback': 'enableRollback',
-    'index-back-promotion-metadata': 'indexBackPromotionMetadata',
-    name: 'name',
-    namespace: 'namespace',
-    platform: 'platform',
-    'promotion-default-credential': 'promotionDefaultCredential',
-    'run-local-tests': 'runLocalTests',
-    'run-specified-tests': 'runSpecifiedTests',
-    type: 'type',
-    'validation-promotion-default-credential': 'validationPromotionDefaultCredential',
-};
-const MUTATION_FLAG_KEYS = Object.keys(ENVIRONMENT_MUTATION_FLAG_TO_PAYLOAD_KEY);
-export const ENVIRONMENT_STRING_VALIDATION_KEYS = [
-    'name',
-    'namespace',
-    'runSpecifiedTests',
-    'promotionDefaultCredential',
-    'validationPromotionDefaultCredential',
-    'apexTestLevel',
-    'platform',
-];
-export function collectMutationFlagKeys(flags) {
-    const selected = [];
-    for (const key of MUTATION_FLAG_KEYS) {
-        if (flags[key] !== undefined) {
-            selected.push(key);
-        }
-    }
-    return selected;
-}
-export function buildMutationPayload(flags) {
-    const payload = {};
-    for (const flagKey of MUTATION_FLAG_KEYS) {
-        const value = flags[flagKey];
-        if (value !== undefined) {
-            const payloadKey = ENVIRONMENT_MUTATION_FLAG_TO_PAYLOAD_KEY[flagKey];
-            Object.assign(payload, { [payloadKey]: value });
-        }
-    }
-    return payload;
-}
-export const environmentCreateStringFlags = {
-    'apex-test-level': environmentMutationStringFlags['apex-test-level'],
-    namespace: environmentMutationStringFlags.namespace,
-    'promotion-default-credential': environmentMutationStringFlags['promotion-default-credential'],
-    'run-specified-tests': environmentMutationStringFlags['run-specified-tests'],
-    'validation-promotion-default-credential': environmentMutationStringFlags['validation-promotion-default-credential'],
-};
-export const environmentUpdateFlags = {
-    ...environmentMutationBooleanFlags,
-    ...environmentMutationStringFlags,
-};
-export const environmentCreateFlags = {
-    ...environmentMutationBooleanFlags,
-    ...environmentCreateStringFlags,
-    platform: environmentPlatformFlag,
-    type: environmentCreateTypeFlag,
-};
-export function buildCreatePayload(name, flags) {
-    return {
-        ...buildMutationPayload(flags),
-        name,
-        platform: flags.platform ?? DEFAULT_ENVIRONMENT_PLATFORM,
-        type: flags.type ?? DEFAULT_ENVIRONMENT_TYPE,
-    };
-}
-export function formatMutationFlagName(key) {
-    return `--${key}`;
-}
-export function validateNonEmptyStringFields(payload, keys) {
-    for (const key of keys) {
-        const value = payload[key];
-        if (typeof value === 'string' && value.trim().length === 0) {
-            return `${key} value cannot be empty`;
-        }
-    }
-    return undefined;
-}
-//# sourceMappingURL=environment-flags.js.map
+import {modules} from './runtime.js';
+const ENVIRONMENT_STRING_VALIDATION_KEYS = modules["environment-flags.js"]["ENVIRONMENT_STRING_VALIDATION_KEYS"]
+const buildCreatePayload = modules["environment-flags.js"]["buildCreatePayload"]
+const buildEnvironmentListFilters = modules["environment-flags.js"]["buildEnvironmentListFilters"]
+const buildMutationPayload = modules["environment-flags.js"]["buildMutationPayload"]
+const collectMutationFlagKeys = modules["environment-flags.js"]["collectMutationFlagKeys"]
+const environmentCreateFlags = modules["environment-flags.js"]["environmentCreateFlags"]
+const environmentCreateStringFlags = modules["environment-flags.js"]["environmentCreateStringFlags"]
+const environmentCreateTypeFlag = modules["environment-flags.js"]["environmentCreateTypeFlag"]
+const environmentListFilterFlags = modules["environment-flags.js"]["environmentListFilterFlags"]
+const environmentMutationBooleanFlags = modules["environment-flags.js"]["environmentMutationBooleanFlags"]
+const environmentMutationStringFlags = modules["environment-flags.js"]["environmentMutationStringFlags"]
+const environmentPlatformFlag = modules["environment-flags.js"]["environmentPlatformFlag"]
+const environmentTypeFlag = modules["environment-flags.js"]["environmentTypeFlag"]
+const environmentUpdateFlags = modules["environment-flags.js"]["environmentUpdateFlags"]
+const formatMutationFlagName = modules["environment-flags.js"]["formatMutationFlagName"]
+const validateNonEmptyStringFields = modules["environment-flags.js"]["validateNonEmptyStringFields"]
+export {ENVIRONMENT_STRING_VALIDATION_KEYS, buildCreatePayload, buildEnvironmentListFilters, buildMutationPayload, collectMutationFlagKeys, environmentCreateFlags, environmentCreateStringFlags, environmentCreateTypeFlag, environmentListFilterFlags, environmentMutationBooleanFlags, environmentMutationStringFlags, environmentPlatformFlag, environmentTypeFlag, environmentUpdateFlags, formatMutationFlagName, validateNonEmptyStringFields};

package/dist/lib/environment-types.js

@@ -1,79 +1,14 @@
-import { cellValue } from './format.js';
-import { appendListPaginationQueryParams } from './list-pagination.js';
-import { normalizeSalesforceId } from './salesforce-id.js';
-export const ENVIRONMENT_TYPES = ['Production/Developer', 'Sandbox', 'Scratch Org', 'Custom Domain'];
-export const DEFAULT_ENVIRONMENT_PLATFORM = 'SFDX';
-export const DEFAULT_ENVIRONMENT_TYPE = 'Production/Developer';
-export const ENVIRONMENT_LIST_FILTER_KEYS = ['name', 'orgId', 'platform', 'type'];
-const ENVIRONMENT_LIST_FILTER_QUERY_PARAM = {
-    name: 'name',
-    orgId: 'orgId',
-    platform: 'platform',
-    type: 'type',
-};
-export function environmentsListEndpoint(filters = {}) {
-    const params = new URLSearchParams();
-    for (const key of ENVIRONMENT_LIST_FILTER_KEYS) {
-        const value = filters[key];
-        if (value !== undefined) {
-            params.set(ENVIRONMENT_LIST_FILTER_QUERY_PARAM[key], value);
-        }
-    }
-    appendListPaginationQueryParams(params, filters);
-    const query = params.toString();
-    return query.length > 0 ? `/corpus/environments?${query}` : '/corpus/environments';
-}
-export function environmentEndpoint(id) {
-    return `/corpus/environments/${encodeURIComponent(normalizeSalesforceId(id))}`;
-}
-export function environmentCredentialsEndpoint(environmentId) {
-    return `/corpus/environments/${encodeURIComponent(normalizeSalesforceId(environmentId))}/credentials/`;
-}
-export function environmentCredentialEndpoint(environmentId, credentialId) {
-    return `/corpus/environments/${encodeURIComponent(normalizeSalesforceId(environmentId))}/credentials/${encodeURIComponent(normalizeSalesforceId(credentialId))}`;
-}
-export function environmentCredentialAuthUrlEndpoint(environmentId, credentialId, redirectUrl) {
-    const endpoint = `/corpus/environments/${normalizeSalesforceId(environmentId)}/credentials/${normalizeSalesforceId(credentialId)}/auth-url`;
-    return `${endpoint}?redirectUrl=${encodeURIComponent(redirectUrl)}`;
-}
-export function environmentCredentialValidateEndpoint(environmentId, credentialId) {
-    return `/corpus/environments/${normalizeSalesforceId(environmentId)}/credentials/${normalizeSalesforceId(credentialId)}/validate`;
-}
-export function formatEnvironmentAuthStatus(result, options = {}) {
-    const colorize = options.colorize ?? ((_, text) => text);
-    const status = result.validated ? 'valid' : 'invalid';
-    const statusColor = result.validated ? 'green' : 'red';
-    const lines = [
-        `Credential ID: ${result.credentialId}`,
-        `Credential Name: ${result.credentialName}`,
-        `Status: ${colorize(statusColor, status)}`,
-    ];
-    if (typeof result.message === 'string' && result.message.trim().length > 0) {
-        lines.push(`Message: ${result.message}`);
-    }
-    return lines.join('\n');
-}
-export function formatEnvironmentDetail(environment) {
-    const lines = [
-        `ID: ${cellValue(environment.id)}`,
-        `Name: ${cellValue(environment.name)}`,
-        `Type: ${cellValue(environment.type)}`,
-        `Platform: ${cellValue(environment.platform)}`,
-        `Org ID: ${cellValue(environment.orgId)}`,
-        `Namespace: ${cellValue(environment.namespace)}`,
-        `Apex Test Level: ${cellValue(environment.apexTestLevel)}`,
-        `Run Local Tests: ${cellValue(environment.runLocalTests)}`,
-        `Run Specified Tests: ${cellValue(environment.runSpecifiedTests)}`,
-        `Promotion Default Credential: ${cellValue(environment.promotionDefaultCredential)}`,
-        `Validation Promotion Default Credential: ${cellValue(environment.validationPromotionDefaultCredential)}`,
-        `Index Back Promotion Metadata: ${cellValue(environment.indexBackPromotionMetadata)}`,
-        `Enable Rollback: ${cellValue(environment.enableRollback)}`,
-        `Created By: ${cellValue(environment.createdBy)}`,
-        `Created Date: ${cellValue(environment.createdDate)}`,
-        `Last Modified By: ${cellValue(environment.lastModifiedBy)}`,
-        `Last Modified Date: ${cellValue(environment.lastModifiedDate)}`,
-        `Last Refresh Date: ${cellValue(environment.lastRefreshDate)}`,
-    ];
-    return lines.join('\n');
-}
-//# sourceMappingURL=environment-types.js.map
+import {modules} from './runtime.js';
+const DEFAULT_ENVIRONMENT_PLATFORM = modules["environment-types.js"]["DEFAULT_ENVIRONMENT_PLATFORM"]
+const DEFAULT_ENVIRONMENT_TYPE = modules["environment-types.js"]["DEFAULT_ENVIRONMENT_TYPE"]
+const ENVIRONMENT_LIST_FILTER_KEYS = modules["environment-types.js"]["ENVIRONMENT_LIST_FILTER_KEYS"]
+const ENVIRONMENT_TYPES = modules["environment-types.js"]["ENVIRONMENT_TYPES"]
+const environmentCredentialAuthUrlEndpoint = modules["environment-types.js"]["environmentCredentialAuthUrlEndpoint"]
+const environmentCredentialEndpoint = modules["environment-types.js"]["environmentCredentialEndpoint"]
+const environmentCredentialValidateEndpoint = modules["environment-types.js"]["environmentCredentialValidateEndpoint"]
+const environmentCredentialsEndpoint = modules["environment-types.js"]["environmentCredentialsEndpoint"]
+const environmentEndpoint = modules["environment-types.js"]["environmentEndpoint"]
+const environmentsListEndpoint = modules["environment-types.js"]["environmentsListEndpoint"]
+const formatEnvironmentAuthStatus = modules["environment-types.js"]["formatEnvironmentAuthStatus"]
+const formatEnvironmentDetail = modules["environment-types.js"]["formatEnvironmentDetail"]
+export {DEFAULT_ENVIRONMENT_PLATFORM, DEFAULT_ENVIRONMENT_TYPE, ENVIRONMENT_LIST_FILTER_KEYS, ENVIRONMENT_TYPES, environmentCredentialAuthUrlEndpoint, environmentCredentialEndpoint, environmentCredentialValidateEndpoint, environmentCredentialsEndpoint, environmentEndpoint, environmentsListEndpoint, formatEnvironmentAuthStatus, formatEnvironmentDetail};

package/dist/lib/format.js

@@ -1,108 +1,4 @@
-import createTtyTable from 'tty-table';
-const TABLE_PADDING = 2;
-const TABLE_MARGIN_LEFT = 2;
-export function cellValue(value) {
-    return value === null || value === undefined ? '' : String(value);
-}
-function columnContentWidth(column, rows) {
-    let max = column.alias.length;
-    for (const row of rows) {
-        const value = row[column.value];
-        const length = value === null || value === undefined ? 0 : String(value).length;
-        if (length > max) {
-            max = length;
-        }
-    }
-    return max;
-}
-function terminalColumns() {
-    if (typeof process.stdout.columns === 'number' && process.stdout.columns > 0) {
-        return process.stdout.columns;
-    }
-    const envColumns = Number(process.env.COLUMNS);
-    return Number.isFinite(envColumns) && envColumns > 0 ? envColumns : 80;
-}
-function minColumnWidth(column) {
-    return column.alias.length + TABLE_PADDING;
-}
-function maxWidthSum(columnCount) {
-    // tty-table adds a left margin and n+1 vertical borders around n cells.
-    return Math.max(0, terminalColumns() - TABLE_MARGIN_LEFT - (columnCount + 1));
-}
-function truncateToWidth(value, contentWidth) {
-    if (contentWidth <= 0) {
-        return '';
-    }
-    if (value.length <= contentWidth) {
-        return value;
-    }
-    if (contentWidth === 1) {
-        return value.slice(0, 1);
-    }
-    return `${value.slice(0, contentWidth - 1)}…`;
-}
-function shrinkWidths(natural, mins, budget) {
-    const widths = natural.map((width, index) => Math.max(width, mins[index]));
-    let overflow = widths.reduce((sum, width) => sum + width, 0) - budget;
-    while (overflow > 0) {
-        let candidate = -1;
-        let spare = 0;
-        for (const [index, width] of widths.entries()) {
-            const available = width - mins[index];
-            if (available > spare) {
-                spare = available;
-                candidate = index;
-            }
-        }
-        if (candidate === -1 || spare <= 0) {
-            break;
-        }
-        widths[candidate]--;
-        overflow--;
-    }
-    return widths;
-}
-function sizeWrapTable(columns, rows) {
-    const wrapIndex = columns.findIndex((column) => column.wrap);
-    const naturals = columns.map((column) => columnContentWidth(column, rows) + TABLE_PADDING);
-    const mins = columns.map((column) => minColumnWidth(column));
-    const nonWrapIndexes = columns.map((_, index) => index).filter((index) => index !== wrapIndex);
-    const maxSum = maxWidthSum(columns.length);
-    const wrapMin = mins[wrapIndex];
-    const naturalNonWrap = nonWrapIndexes.map((index) => naturals[index]);
-    const nonWrapMins = nonWrapIndexes.map((index) => mins[index]);
-    const nonWrapBudget = Math.min(naturalNonWrap.reduce((sum, width) => sum + width, 0), Math.max(0, maxSum - wrapMin));
-    const nonWrapWidths = shrinkWidths(naturalNonWrap, nonWrapMins, nonWrapBudget);
-    const usedNonWrap = nonWrapWidths.reduce((sum, width) => sum + width, 0);
-    const widths = columns.map(() => 0);
-    for (const [offset, index] of nonWrapIndexes.entries()) {
-        widths[index] = nonWrapWidths[offset];
-    }
-    widths[wrapIndex] = Math.max(wrapMin, Math.min(naturals[wrapIndex], maxSum - usedNonWrap));
-    const sizedRows = rows.map((row) => {
-        const next = { ...row };
-        for (const [offset, index] of nonWrapIndexes.entries()) {
-            const column = columns[index];
-            next[column.value] = truncateToWidth(cellValue(row[column.value]), Math.max(0, nonWrapWidths[offset] - TABLE_PADDING));
-        }
-        return next;
-    });
-    return {
-        columns: columns.map((column, index) => ({
-            ...column,
-            align: column.align ?? (column.wrap ? 'left' : undefined),
-            headerAlign: column.headerAlign ?? (column.wrap ? 'left' : undefined),
-            width: widths[index],
-        })),
-        rows: sizedRows,
-    };
-}
-export function table(headers, rows) {
-    const hasWrapColumn = headers.some((header) => header.wrap);
-    if (!hasWrapColumn) {
-        return createTtyTable(headers, rows).render();
-    }
-    const sized = sizeWrapTable(headers, rows);
-    return createTtyTable(sized.columns, sized.rows).render();
-}
-//# sourceMappingURL=format.js.map
+import {modules} from './runtime.js';
+const cellValue = modules["format.js"]["cellValue"]
+const table = modules["format.js"]["table"]
+export {cellValue, table};

package/dist/lib/function-flags.js

@@ -1,199 +1,8 @@
-import { Flags } from '@oclif/core';
-import { readFile } from 'node:fs/promises';
-import { FUNCTION_RUNTIME_EXTENSION, FUNCTION_RUNTIMES, normalizeFunctionUpsertPayload, parseParameterAssignments, } from './function-types.js';
-export const functionUpsertFlags = {
-    'apex-class': Flags.string({
-        description: 'Apex callback class',
-    }),
-    callback: Flags.string({
-        description: 'Function callback type',
-    }),
-    description: Flags.string({
-        description: 'Function description',
-    }),
-    file: Flags.string({
-        description: 'Path to a JSON file with the full upsert payload (overrides individual script flags)',
-    }),
-    'flow-handler': Flags.string({
-        description: 'Flow handler name',
-    }),
-    'image-name': Flags.string({
-        description: 'Function container image',
-    }),
-    name: Flags.string({
-        description: 'Function display name (defaults to the API name argument)',
-    }),
-    'parameters-file': Flags.string({
-        description: 'Path to a JSON file containing the parameters array',
-    }),
-    runtime: Flags.string({
-        description: 'Script runtime',
-        options: [...FUNCTION_RUNTIMES],
-    }),
-    script: Flags.string({
-        description: 'Inline script content',
-    }),
-    'script-file': Flags.string({
-        description: 'Path to a file whose contents become the script',
-    }),
-    size: Flags.string({
-        description: 'Function size',
-    }),
-    timeout: Flags.integer({
-        description: 'Function timeout in seconds',
-    }),
-    type: Flags.string({
-        description: 'Function type',
-    }),
-    version: Flags.string({
-        description: 'Function version',
-    }),
-};
-export const functionDefaultsFlags = {
-    'image-name': Flags.string({
-        default: 'copado-function-core:v1',
-        description: 'Function container image',
-    }),
-    name: Flags.string({
-        description: 'Function display name used to scaffold defaults',
-        required: true,
-    }),
-    runtime: Flags.string({
-        default: 'bash',
-        description: 'Script runtime',
-        options: [...FUNCTION_RUNTIMES],
-    }),
-};
-export const functionRunFlags = {
-    'context-id': Flags.string({
-        description: 'Execution context Id',
-    }),
-    'deploy-first': Flags.boolean({
-        default: false,
-        description: 'Deploy related metadata before running the function',
-    }),
-    parameter: Flags.string({
-        description: 'Run parameter as key=value (repeatable)',
-        multiple: true,
-    }),
-    'show-validation-errors': Flags.boolean({
-        allowNo: true,
-        default: true,
-        description: 'Surface validation errors from the gateway',
-    }),
-};
-async function readJsonFile(path, label) {
-    let raw;
-    try {
-        raw = await readFile(path, 'utf8');
-    }
-    catch (error) {
-        throw new Error(`Unable to read ${label} file ${path}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        throw new Error(`${label} file ${path} is not valid JSON.`);
-    }
-}
-function buildScript(flags, content) {
-    const runtime = (flags.runtime ?? 'bash');
-    return {
-        content,
-        extension: FUNCTION_RUNTIME_EXTENSION[runtime],
-        runtime,
-    };
-}
-async function resolveScriptContent(flags) {
-    if (flags.script !== undefined && flags['script-file'] !== undefined) {
-        throw new Error('Cannot provide --script and --script-file together.');
-    }
-    if (flags.script !== undefined) {
-        return flags.script;
-    }
-    if (flags['script-file'] === undefined) {
-        throw new Error('Must provide --script, --script-file, or --file.');
-    }
-    try {
-        return await readFile(flags['script-file'], 'utf8');
-    }
-    catch (error) {
-        throw new Error(`Unable to read script file ${flags['script-file']}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function resolveParameters(flags) {
-    if (flags['parameters-file'] === undefined) {
-        return undefined;
-    }
-    const parameters = await readJsonFile(flags['parameters-file'], 'Parameters');
-    if (!Array.isArray(parameters)) {
-        throw new TypeError('Parameters file must contain a JSON array.');
-    }
-    return parameters;
-}
-function applyOptionalUpsertFields(payload, flags, parameters) {
-    return {
-        ...payload,
-        ...(flags.description === undefined ? {} : { description: flags.description }),
-        ...(flags['apex-class'] === undefined ? {} : { apexClass: flags['apex-class'] }),
-        ...(flags.callback === undefined ? {} : { callback: flags.callback }),
-        ...(flags['flow-handler'] === undefined ? {} : { flowHandler: flags['flow-handler'] }),
-        ...(flags.timeout === undefined ? {} : { timeout: flags.timeout }),
-        ...(parameters === undefined ? {} : { parameters }),
-    };
-}
-export async function buildFunctionUpsertPayload(apiName, flags) {
-    if (flags.file !== undefined) {
-        const conflictingFlags = Object.entries(flags)
-            .filter(([key, value]) => key !== 'file' && value !== undefined)
-            .map(([key]) => `--${key}`);
-        if (conflictingFlags.length > 0) {
-            throw new Error(`Cannot combine --file with payload flags: ${conflictingFlags.join(', ')}.`);
-        }
-        const fromFile = await readJsonFile(flags.file, 'Upsert');
-        return normalizeFunctionUpsertPayload(apiName, fromFile);
-    }
-    const scriptContent = await resolveScriptContent(flags);
-    const parameters = await resolveParameters(flags);
-    const payload = {
-        apiName,
-        imageName: flags['image-name'] ?? 'copado-function-core:v1',
-        name: flags.name?.trim() || apiName,
-        script: buildScript(flags, scriptContent),
-        size: flags.size ?? 'S',
-        type: flags.type ?? 'Custom',
-        version: flags.version ?? '1',
-    };
-    return normalizeFunctionUpsertPayload(apiName, applyOptionalUpsertFields(payload, flags, parameters));
-}
-export function buildFunctionDefaultsPayload(flags) {
-    return {
-        imageName: flags['image-name'] ?? 'copado-function-core:v1',
-        name: flags.name,
-        runtime: (flags.runtime ?? 'bash'),
-    };
-}
-export function buildFunctionRunPayload(flags) {
-    try {
-        const parameters = parseParameterAssignments(flags.parameter);
-        return {
-            payload: {
-                deployFirst: flags['deploy-first'] ?? false,
-                showValidationErrors: flags['show-validation-errors'] ?? true,
-                ...(flags['context-id'] === undefined ? {} : { contextId: flags['context-id'] }),
-                ...(parameters === undefined ? {} : { parameters }),
-            },
-        };
-    }
-    catch (error) {
-        return {
-            error: error instanceof Error ? error.message : String(error),
-            payload: {
-                deployFirst: false,
-                showValidationErrors: true,
-            },
-        };
-    }
-}
-//# sourceMappingURL=function-flags.js.map
+import {modules} from './runtime.js';
+const buildFunctionDefaultsPayload = modules["function-flags.js"]["buildFunctionDefaultsPayload"]
+const buildFunctionRunPayload = modules["function-flags.js"]["buildFunctionRunPayload"]
+const buildFunctionUpsertPayload = modules["function-flags.js"]["buildFunctionUpsertPayload"]
+const functionDefaultsFlags = modules["function-flags.js"]["functionDefaultsFlags"]
+const functionRunFlags = modules["function-flags.js"]["functionRunFlags"]
+const functionUpsertFlags = modules["function-flags.js"]["functionUpsertFlags"]
+export {buildFunctionDefaultsPayload, buildFunctionRunPayload, buildFunctionUpsertPayload, functionDefaultsFlags, functionRunFlags, functionUpsertFlags};