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

package/dist/lib/function-local-run.js

@@ -1,148 +1,14 @@
-import { spawn } from 'node:child_process';
-import { access } from 'node:fs/promises';
-import path from 'node:path';
-import { FUNCTION_RUNTIMES, parseParameterAssignments } from './function-types.js';
-/** Default Copado Function image; partners can override when the Copado registry is unavailable. */
-export const DEFAULT_FUNCTION_LOCAL_IMAGE = 'copado-function-core:v1';
-/** Container working directory (matches Copado Function runtime). */
-export const FUNCTION_LOCAL_CONTAINER_APP_DIR = '/app';
-/** Fixed container path for the function script (matches Copado Function runtime). */
-export const FUNCTION_LOCAL_CONTAINER_SCRIPT_PATH = '/tmp/cf_function.sh';
-export function runtimeFromFunctionScriptPath(scriptPath) {
-    const normalized = scriptPath.replaceAll('\\', '/').toLowerCase();
-    if (normalized.endsWith('.js')) {
-        return 'node';
-    }
-    if (normalized.endsWith('.py')) {
-        return 'python';
-    }
-    return 'bash';
-}
-export function runtimeInterpreter(runtime) {
-    if (runtime === 'node') {
-        return 'node';
-    }
-    if (runtime === 'python') {
-        return 'python3';
-    }
-    return 'bash';
-}
-export function resolveLocalFunctionRuntime(scriptPath, runtimeFlag) {
-    if (runtimeFlag === undefined) {
-        return runtimeFromFunctionScriptPath(scriptPath);
-    }
-    if (!FUNCTION_RUNTIMES.includes(runtimeFlag)) {
-        throw new Error(`Unsupported runtime "${runtimeFlag}". Expected one of: ${FUNCTION_RUNTIMES.join(', ')}.`);
-    }
-    return runtimeFlag;
-}
-export async function assertLocalFunctionScriptReadable(scriptPath) {
-    const resolved = path.resolve(scriptPath);
-    try {
-        await access(resolved);
-    }
-    catch {
-        throw new Error(`Function script not found or unreadable: ${resolved}`);
-    }
-    return resolved;
-}
-/**
- * Host directory bind-mounted at `/app`.
- * Defaults to the current process working directory (workspace root when invoked from a project).
- */
-export function resolveLocalFunctionHostAppDir(cwdFlag) {
-    if (cwdFlag === undefined || cwdFlag.trim().length === 0) {
-        return process.cwd();
-    }
-    return path.resolve(cwdFlag);
-}
-export function buildDockerLocalFunctionRunInvocation(options) {
-    const image = options.image.trim();
-    if (image.length === 0) {
-        throw new Error('Docker image must not be empty. Pass --image to override the default Copado Function image.');
-    }
-    const args = ['run', '--rm'];
-    if (options.platform !== undefined && options.platform.trim().length > 0) {
-        args.push('--platform', options.platform.trim());
-    }
-    for (const [key, value] of Object.entries(options.env ?? {})) {
-        args.push('-e', `${key}=${value}`);
-    }
-    args.push('-v', `${options.hostAppDir}:${FUNCTION_LOCAL_CONTAINER_APP_DIR}`, '-v', `${options.scriptPath}:${FUNCTION_LOCAL_CONTAINER_SCRIPT_PATH}`, '-w', FUNCTION_LOCAL_CONTAINER_APP_DIR, image, runtimeInterpreter(options.runtime), FUNCTION_LOCAL_CONTAINER_SCRIPT_PATH);
-    return {
-        args,
-        command: 'docker',
-        display: `docker ${args.join(' ')}`,
-    };
-}
-export function runLocalFunctionProcess(invocation, options) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(invocation.command, invocation.args, {
-            cwd: options.cwd,
-            env: process.env,
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (chunk) => {
-            stdout += String(chunk);
-        });
-        child.stderr.on('data', (chunk) => {
-            stderr += String(chunk);
-        });
-        child.on('error', (error) => {
-            reject(error);
-        });
-        child.on('close', (code) => {
-            resolve({ exitCode: code, stderr, stdout });
-        });
-    });
-}
-export async function executeLocalFunctionRun(options) {
-    const script = await assertLocalFunctionScriptReadable(options.script);
-    const runtime = resolveLocalFunctionRuntime(script, options.runtime);
-    const hostAppDir = resolveLocalFunctionHostAppDir(options.cwd);
-    const image = options.image === undefined || options.image.trim().length === 0
-        ? DEFAULT_FUNCTION_LOCAL_IMAGE
-        : options.image.trim();
-    const env = parseParameterAssignments(options.parameter);
-    const invocation = buildDockerLocalFunctionRunInvocation({
-        hostAppDir,
-        image,
-        runtime,
-        scriptPath: script,
-        ...(env === undefined ? {} : { env }),
-        ...(options.platform === undefined ? {} : { platform: options.platform }),
-    });
-    const runProcess = options.runProcess ?? runLocalFunctionProcess;
-    const processResult = await runProcess(invocation, { cwd: hostAppDir });
-    return {
-        args: invocation.args,
-        command: invocation.command,
-        cwd: hostAppDir,
-        exitCode: processResult.exitCode,
-        image,
-        runtime,
-        script,
-        stderr: processResult.stderr,
-        stdout: processResult.stdout,
-    };
-}
-export function formatLocalFunctionRunResult(result) {
-    const lines = [
-        `Script: ${result.script}`,
-        `Runtime: ${result.runtime}`,
-        `Image: ${result.image}`,
-        `Command: ${result.command} ${result.args.join(' ')}`,
-        `App mount (/app): ${result.cwd}`,
-        `Container script: ${FUNCTION_LOCAL_CONTAINER_SCRIPT_PATH}`,
-        `Exit code: ${result.exitCode ?? 'null'}`,
-    ];
-    if (result.stdout.trim().length > 0) {
-        lines.push('', 'stdout:', result.stdout.endsWith('\n') ? result.stdout.slice(0, -1) : result.stdout);
-    }
-    if (result.stderr.trim().length > 0) {
-        lines.push('', 'stderr:', result.stderr.endsWith('\n') ? result.stderr.slice(0, -1) : result.stderr);
-    }
-    return lines.join('\n');
-}
-//# sourceMappingURL=function-local-run.js.map
+import {modules} from './runtime.js';
+const DEFAULT_FUNCTION_LOCAL_IMAGE = modules["function-local-run.js"]["DEFAULT_FUNCTION_LOCAL_IMAGE"]
+const FUNCTION_LOCAL_CONTAINER_APP_DIR = modules["function-local-run.js"]["FUNCTION_LOCAL_CONTAINER_APP_DIR"]
+const FUNCTION_LOCAL_CONTAINER_SCRIPT_PATH = modules["function-local-run.js"]["FUNCTION_LOCAL_CONTAINER_SCRIPT_PATH"]
+const assertLocalFunctionScriptReadable = modules["function-local-run.js"]["assertLocalFunctionScriptReadable"]
+const buildDockerLocalFunctionRunInvocation = modules["function-local-run.js"]["buildDockerLocalFunctionRunInvocation"]
+const executeLocalFunctionRun = modules["function-local-run.js"]["executeLocalFunctionRun"]
+const formatLocalFunctionRunResult = modules["function-local-run.js"]["formatLocalFunctionRunResult"]
+const resolveLocalFunctionHostAppDir = modules["function-local-run.js"]["resolveLocalFunctionHostAppDir"]
+const resolveLocalFunctionRuntime = modules["function-local-run.js"]["resolveLocalFunctionRuntime"]
+const runLocalFunctionProcess = modules["function-local-run.js"]["runLocalFunctionProcess"]
+const runtimeFromFunctionScriptPath = modules["function-local-run.js"]["runtimeFromFunctionScriptPath"]
+const runtimeInterpreter = modules["function-local-run.js"]["runtimeInterpreter"]
+export {DEFAULT_FUNCTION_LOCAL_IMAGE, FUNCTION_LOCAL_CONTAINER_APP_DIR, FUNCTION_LOCAL_CONTAINER_SCRIPT_PATH, assertLocalFunctionScriptReadable, buildDockerLocalFunctionRunInvocation, executeLocalFunctionRun, formatLocalFunctionRunResult, resolveLocalFunctionHostAppDir, resolveLocalFunctionRuntime, runLocalFunctionProcess, runtimeFromFunctionScriptPath, runtimeInterpreter};

package/dist/lib/function-types.js

@@ -1,179 +1,22 @@
-import { cellValue, table } from './format.js';
-import { appendListPaginationQueryParams, paginatedResultFromNestedData, } from './list-pagination.js';
-export const FUNCTION_LIST_TYPES = ['custom', 'all'];
-export const FUNCTION_RUNTIMES = ['bash', 'node', 'python'];
-export const FUNCTION_EXTENSIONS = ['sh', 'js', 'py'];
-export const FUNCTION_RUNTIME_EXTENSION = {
-    bash: 'sh',
-    node: 'js',
-    python: 'py',
-};
-export function functionsEndpoint(filters = {}) {
-    const params = new URLSearchParams();
-    if (filters.type !== undefined) {
-        params.set('type', filters.type);
-    }
-    if (filters.name !== undefined) {
-        params.set('name', filters.name);
-    }
-    if (filters.imageName !== undefined) {
-        params.set('imageName', filters.imageName);
-    }
-    if (filters.size !== undefined) {
-        params.set('size', filters.size);
-    }
-    appendListPaginationQueryParams(params, filters);
-    const query = params.toString();
-    return query.length > 0 ? `/functions?${query}` : '/functions';
-}
-export function functionEndpoint(apiName) {
-    return `/functions/${encodeURIComponent(apiName)}`;
-}
-export function functionRunEndpoint(apiName) {
-    return `${functionEndpoint(apiName)}/run`;
-}
-export function functionResultEndpoint(resultId) {
-    return `/functions/results/${encodeURIComponent(resultId)}`;
-}
-export function functionResultLogEndpoint(resultId, fileType) {
-    const base = `${functionResultEndpoint(resultId)}/log-file`;
-    if (fileType === undefined || fileType.trim().length === 0) {
-        return base;
-    }
-    const params = new URLSearchParams({ type: fileType.trim() });
-    return `${base}?${params.toString()}`;
-}
-export function normalizeFunctionUpsertPayload(apiNameValue, input) {
-    const apiName = apiNameValue.trim();
-    if (apiName.length === 0) {
-        throw new Error('Function API name is required.');
-    }
-    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
-        throw new TypeError('Function upsert payload must be a JSON object.');
-    }
-    if (input.script === null || typeof input.script !== 'object' || Array.isArray(input.script)) {
-        throw new TypeError('Function upsert payload must include a script object.');
-    }
-    if (typeof input.script.content !== 'string') {
-        throw new TypeError('Function upsert payload script must include string content.');
-    }
-    const runtime = input.script.runtime ?? 'bash';
-    if (!FUNCTION_RUNTIMES.includes(runtime)) {
-        throw new Error(`Unsupported function runtime "${runtime}".`);
-    }
-    return {
-        ...input,
-        apiName,
-        imageName: input.imageName ?? 'copado-function-core:v1',
-        name: input.name?.trim() || apiName,
-        script: {
-            content: input.script.content,
-            extension: input.script.extension ?? FUNCTION_RUNTIME_EXTENSION[runtime],
-            runtime,
-        },
-        size: input.size ?? 'S',
-        type: input.type ?? 'Custom',
-        version: input.version ?? '1',
-    };
-}
-export function normalizeFunctionsListPage(response) {
-    return paginatedResultFromNestedData(response);
-}
-export function normalizeFunctionsList(response) {
-    return normalizeFunctionsListPage(response).data;
-}
-export function normalizeFunction(response) {
-    if ('data' in response && response.data !== undefined && typeof response.data === 'object' && !Array.isArray(response.data)) {
-        return response.data;
-    }
-    return response;
-}
-export function normalizeFunctionRunResult(response) {
-    if ('data' in response && response.data !== undefined && typeof response.data === 'object' && !Array.isArray(response.data)) {
-        return response.data;
-    }
-    return response;
-}
-export function normalizeFunctionResultStatus(response) {
-    if ('data' in response &&
-        response.data !== undefined &&
-        typeof response.data === 'object' &&
-        !Array.isArray(response.data)) {
-        return response.data;
-    }
-    return response;
-}
-export function formatFunctionTable(functions) {
-    return table([
-        { alias: 'API NAME', value: 'apiName' },
-        { alias: 'NAME', value: 'name' },
-        { alias: 'TYPE', value: 'type' },
-        { alias: 'RUNTIME', value: 'runtime' },
-        { alias: 'SIZE', value: 'size' },
-        { alias: 'OWNER', value: 'ownerName' },
-    ], functions.map((fn) => ({
-        apiName: cellValue(fn.apiName),
-        name: cellValue(fn.name),
-        ownerName: cellValue(fn.ownerName),
-        runtime: cellValue(fn.script?.runtime),
-        size: cellValue(fn.size),
-        type: cellValue(fn.type),
-    })));
-}
-export function formatFunctionDetail(fn) {
-    return [
-        `ID: ${cellValue(fn.id)}`,
-        `Name: ${cellValue(fn.name)}`,
-        `API Name: ${cellValue(fn.apiName)}`,
-        `Type: ${cellValue(fn.type)}`,
-        `Image: ${cellValue(fn.imageName)}`,
-        `Size: ${cellValue(fn.size)}`,
-        `Version: ${cellValue(fn.version)}`,
-        `Timeout: ${cellValue(fn.timeout)}`,
-        `Owner: ${cellValue(fn.ownerName)}`,
-        `Description: ${cellValue(fn.description)}`,
-        `Runtime: ${cellValue(fn.script?.runtime)}`,
-        `Extension: ${cellValue(fn.script?.extension)}`,
-        `Parameters: ${cellValue(fn.parameters?.length)}`,
-        `Callback: ${cellValue(fn.callback)}`,
-        `Apex Class: ${cellValue(fn.apexClass)}`,
-        `Flow Handler: ${cellValue(fn.flowHandler)}`,
-    ].join('\n');
-}
-export function formatFunctionRunResult(result) {
-    return [
-        `API Name: ${cellValue(result.apiName)}`,
-        `Result ID: ${cellValue(result.resultId)}`,
-        `Status: ${cellValue(result.status)}`,
-    ].join('\n');
-}
-export function formatFunctionResultStatus(result) {
-    const lines = [
-        `Result ID: ${cellValue(result.resultId)}`,
-        `Status: ${cellValue(result.status)}`,
-    ];
-    if (result.messages !== undefined && result.messages !== null && result.messages.length > 0) {
-        lines.push(`Messages: ${result.messages.join('; ')}`);
-    }
-    return lines.join('\n');
-}
-export function parseParameterAssignments(values) {
-    if (values === undefined || values.length === 0) {
-        return undefined;
-    }
-    const parameters = {};
-    for (const value of values) {
-        const separator = value.indexOf('=');
-        if (separator <= 0) {
-            throw new Error(`Invalid --parameter value "${value}". Expected key=value.`);
-        }
-        const key = value.slice(0, separator).trim();
-        const paramValue = value.slice(separator + 1);
-        if (key.length === 0) {
-            throw new Error(`Invalid --parameter value "${value}". Expected key=value.`);
-        }
-        parameters[key] = paramValue;
-    }
-    return parameters;
-}
-//# sourceMappingURL=function-types.js.map
+import {modules} from './runtime.js';
+const FUNCTION_EXTENSIONS = modules["function-types.js"]["FUNCTION_EXTENSIONS"]
+const FUNCTION_LIST_TYPES = modules["function-types.js"]["FUNCTION_LIST_TYPES"]
+const FUNCTION_RUNTIMES = modules["function-types.js"]["FUNCTION_RUNTIMES"]
+const FUNCTION_RUNTIME_EXTENSION = modules["function-types.js"]["FUNCTION_RUNTIME_EXTENSION"]
+const formatFunctionDetail = modules["function-types.js"]["formatFunctionDetail"]
+const formatFunctionResultStatus = modules["function-types.js"]["formatFunctionResultStatus"]
+const formatFunctionRunResult = modules["function-types.js"]["formatFunctionRunResult"]
+const formatFunctionTable = modules["function-types.js"]["formatFunctionTable"]
+const functionEndpoint = modules["function-types.js"]["functionEndpoint"]
+const functionResultEndpoint = modules["function-types.js"]["functionResultEndpoint"]
+const functionResultLogEndpoint = modules["function-types.js"]["functionResultLogEndpoint"]
+const functionRunEndpoint = modules["function-types.js"]["functionRunEndpoint"]
+const functionsEndpoint = modules["function-types.js"]["functionsEndpoint"]
+const normalizeFunction = modules["function-types.js"]["normalizeFunction"]
+const normalizeFunctionResultStatus = modules["function-types.js"]["normalizeFunctionResultStatus"]
+const normalizeFunctionRunResult = modules["function-types.js"]["normalizeFunctionRunResult"]
+const normalizeFunctionUpsertPayload = modules["function-types.js"]["normalizeFunctionUpsertPayload"]
+const normalizeFunctionsList = modules["function-types.js"]["normalizeFunctionsList"]
+const normalizeFunctionsListPage = modules["function-types.js"]["normalizeFunctionsListPage"]
+const parseParameterAssignments = modules["function-types.js"]["parseParameterAssignments"]
+export {FUNCTION_EXTENSIONS, FUNCTION_LIST_TYPES, FUNCTION_RUNTIMES, FUNCTION_RUNTIME_EXTENSION, formatFunctionDetail, formatFunctionResultStatus, formatFunctionRunResult, formatFunctionTable, functionEndpoint, functionResultEndpoint, functionResultLogEndpoint, functionRunEndpoint, functionsEndpoint, normalizeFunction, normalizeFunctionResultStatus, normalizeFunctionRunResult, normalizeFunctionUpsertPayload, normalizeFunctionsList, normalizeFunctionsListPage, parseParameterAssignments};