@factorialco/fcode-cli 1.1.0

package/dist/core/dependencies/env-dependencies-command.d.ts

@@ -0,0 +1,19 @@
+import { ProgrammingLanguageManifest, type ProgrammingLanguage, type Dependency } from '../types';
+import ApiClientCommand from '../commands/api-client-command';
+declare abstract class EnvDependenciesCommand extends ApiClientCommand {
+    abstract readonly programmingLanguage: ProgrammingLanguage;
+    static flags: {
+        check: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        reset: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    protected get envPath(): string;
+    abstract createEnv(): Promise<void>;
+    abstract installDependencies(installationPath: string, dependencies: Array<Dependency>): Promise<void>;
+    run(): Promise<void>;
+    check(): Promise<void>;
+    getManifest(): Promise<ProgrammingLanguageManifest>;
+    installationPath(dependencies: Array<Dependency>): string;
+}
+export declare function dependenciesHash(dependencies: Array<Dependency>): string;
+export default EnvDependenciesCommand;

package/dist/core/dependencies/env-dependencies-command.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependenciesHash = dependenciesHash;
+const types_1 = require("../types");
+const workspace_1 = require("../../config/workspace");
+const api_client_command_1 = require("../commands/api-client-command");
+const node_crypto_1 = require("node:crypto");
+const fs = require("node:fs");
+const path = require("node:path");
+const color_1 = require("@oclif/color");
+const programming_language_manifest_1 = require("../../repositories/programming-language-manifest");
+const cli_1 = require("../../utils/cli");
+class EnvDependenciesCommand extends api_client_command_1.default {
+    get envPath() {
+        return (0, workspace_1.baseDependenciesPath)(this.programmingLanguage);
+    }
+    async run() {
+        await super.init();
+        const { flags: { check, reset, force }, } = await this.parse(EnvDependenciesCommand);
+        if (check) {
+            return this.check();
+        }
+        if (reset) {
+            cli_1.default.log(color_1.default.yellow(`Resetting ${(0, types_1.programmingLanguageDisplayName)(this.programmingLanguage)} dependencies...`));
+            fs.rmSync(this.envPath, { recursive: true });
+        }
+        const manifest = await this.getManifest();
+        const installationPath = this.installationPath(manifest.dependencies);
+        if (fs.existsSync(installationPath)) {
+            if (force) {
+                fs.rmSync(installationPath, { recursive: true });
+            }
+            else {
+                cli_1.default.log(color_1.default.yellow(`Skipping ${(0, types_1.programmingLanguageDisplayName)(this.programmingLanguage)} dependencies installation as they already exist in ${installationPath}.`));
+                return;
+            }
+        }
+        await this.createEnv();
+        cli_1.default.log(`Installing Factorial Code ${(0, types_1.programmingLanguageDisplayName)(this.programmingLanguage)} dependencies... (This process might take some time ⌛️)`);
+        cli_1.default.log('====================================');
+        await this.installDependencies(installationPath, manifest.dependencies);
+        cli_1.default.log('====================================');
+        cli_1.default.log(color_1.default.green(`Factorial Code ${(0, types_1.programmingLanguageDisplayName)(this.programmingLanguage)} dependencies successfully installed in ${installationPath} 🤩\n\n`));
+    }
+    async check() {
+        const installationPath = this.installationPath((await this.getManifest()).dependencies);
+        if (!fs.existsSync(installationPath)) {
+            cli_1.default.log(color_1.default.yellow(`⚠️  ${(0, types_1.programmingLanguageDisplayName)(this.programmingLanguage)} dependencies need to be installed.`));
+        }
+        else {
+            cli_1.default.log(color_1.default.green(`✅  ${(0, types_1.programmingLanguageDisplayName)(this.programmingLanguage)} dependencies already installed at ${installationPath}`));
+        }
+    }
+    getManifest() {
+        const repo = new programming_language_manifest_1.default();
+        return repo.find(this.programmingLanguage);
+    }
+    installationPath(dependencies) {
+        return path.join(this.envPath, dependenciesHash(dependencies));
+    }
+}
+EnvDependenciesCommand.flags = types_1.DependenciesFlags;
+function dependenciesHash(dependencies) {
+    const dependenciesString = dependencies
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map(({ name, specifier }) => `${name}: ${specifier}`)
+        .join('\n');
+    return (0, node_crypto_1.createHash)('md5').update(dependenciesString).digest('hex');
+}
+exports.default = EnvDependenciesCommand;

package/dist/core/dependencies/env-process-dependencies-command.d.ts

@@ -0,0 +1,15 @@
+import ProcessRepository from '../../repositories/process';
+import BaseCommand from '../commands/base-command';
+export default class EnvProcessDependenciesCommand extends BaseCommand {
+    _resourceRepository: ProcessRepository;
+    static args: {
+        resourceSlug: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        check: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        reset: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private installDependencies;
+}

package/dist/core/dependencies/env-process-dependencies-command.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../types");
+const fs = require("node:fs");
+const path = require("node:path");
+const color_1 = require("@oclif/color");
+const cli_1 = require("../../utils/cli");
+const dependencies_1 = require("../utils/dependencies");
+const javascript_env_dependencies_1 = require("./javascript-env-dependencies");
+const python_env_dependencies_1 = require("./python-env-dependencies");
+const process_1 = require("../../repositories/process");
+const base_command_1 = require("../commands/base-command");
+const PROGRAMMING_LANGUAGE_ENV_DEPENDENCIES = {
+    JAVASCRIPT: javascript_env_dependencies_1.default,
+    PYTHON: python_env_dependencies_1.default,
+};
+class EnvProcessDependenciesCommand extends base_command_1.default {
+    constructor() {
+        super(...arguments);
+        this._resourceRepository = new process_1.default();
+    }
+    async run() {
+        await super.init();
+        const { args: { resourceSlug }, flags: { check, reset, force }, } = await this.parse(EnvProcessDependenciesCommand);
+        let processes = [];
+        if (resourceSlug) {
+            processes = [await this._resourceRepository.find(resourceSlug)];
+        }
+        else {
+            processes = await this._resourceRepository.findAll();
+        }
+        for (const process of processes) {
+            if (!process.settings.dependencies.scopedToProcess) {
+                cli_1.default.log(color_1.default.cyan(`Skipping process '${process.slug}' ${(0, types_1.programmingLanguageDisplayName)(process.script.programmingLanguage)} dependencies installation as they are not scoped to process.`));
+                continue;
+            }
+            const installationPath = await (0, dependencies_1.getProcessDependenciesPath)(process);
+            if (check) {
+                if (!fs.existsSync(installationPath)) {
+                    cli_1.default.log(color_1.default.yellow(`⚠️  Process '${process.slug}' ${(0, types_1.programmingLanguageDisplayName)(process.script.programmingLanguage)} dependencies need to be installed.`));
+                }
+                else {
+                    cli_1.default.log(color_1.default.green(`✅  Process '${process.slug}' ${(0, types_1.programmingLanguageDisplayName)(process.script.programmingLanguage)} dependencies already installed at ${installationPath}`));
+                }
+                continue;
+            }
+            if (reset) {
+                cli_1.default.log(color_1.default.yellow(`Resetting ${(0, types_1.programmingLanguageDisplayName)(process.script.programmingLanguage)} dependencies...`));
+                fs.rmSync(path.join(installationPath, '..'), { recursive: true });
+            }
+            if (fs.existsSync(installationPath)) {
+                if (force) {
+                    fs.rmSync(installationPath, { recursive: true });
+                }
+                else {
+                    cli_1.default.log(color_1.default.yellow(`Skipping process '${process.slug}' ${(0, types_1.programmingLanguageDisplayName)(process.script.programmingLanguage)} dependencies installation as they already exist in ${installationPath}.`));
+                    continue;
+                }
+            }
+            await this.installDependencies(installationPath, process);
+        }
+    }
+    async installDependencies(installationPath, process) {
+        const envDependencies = new PROGRAMMING_LANGUAGE_ENV_DEPENDENCIES[process.script.programmingLanguage]([], this.config);
+        await envDependencies.createEnv();
+        cli_1.default.log(`Installing process '${process.slug}' ${(0, types_1.programmingLanguageDisplayName)(process.script.programmingLanguage)} dependencies... (This process might take some time ⌛️)`);
+        cli_1.default.log('====================================');
+        await envDependencies.installDependencies(installationPath, process.manifest?.dependencies || []);
+        if (process.script.programmingLanguage === 'JAVASCRIPT') {
+            fs.writeFileSync(path.join(installationPath, 'index.js'), '');
+        }
+        cli_1.default.log('====================================');
+        cli_1.default.log(color_1.default.green(`Process '${process.slug}' ${(0, types_1.programmingLanguageDisplayName)(process.script.programmingLanguage)} dependencies successfully installed in ${installationPath} 🤩\n\n`));
+    }
+}
+EnvProcessDependenciesCommand.args = types_1.ResourceSlugArg;
+EnvProcessDependenciesCommand.flags = types_1.DependenciesFlags;
+exports.default = EnvProcessDependenciesCommand;

package/dist/core/dependencies/javascript-env-dependencies.d.ts

@@ -0,0 +1,8 @@
+import EnvDependenciesCommand from './env-dependencies-command';
+import { ProgrammingLanguage, Dependency } from '../types';
+export default class JavaScriptEnvDependencies extends EnvDependenciesCommand {
+    get programmingLanguage(): ProgrammingLanguage;
+    createEnv(): Promise<void>;
+    installDependencies(installationPath: string, dependencies: Array<Dependency>): Promise<void>;
+    private ensurePnpm;
+}

package/dist/core/dependencies/javascript-env-dependencies.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+const env_dependencies_command_1 = require("./env-dependencies-command");
+class JavaScriptEnvDependencies extends env_dependencies_command_1.default {
+    get programmingLanguage() {
+        return 'JAVASCRIPT';
+    }
+    async createEnv() {
+        try {
+            fs.mkdirSync(this.envPath, { recursive: true });
+            await this.ensurePnpm();
+        }
+        catch (error) {
+            fs.rmSync(this.envPath, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    async installDependencies(installationPath, dependencies) {
+        try {
+            const packageObject = {
+                name: 'fcode',
+                version: '1.0.0',
+                dependencies: dependencies.reduce((acc, { name, specifier }) => {
+                    acc[name] = specifier;
+                    return acc;
+                }, {}),
+            };
+            fs.mkdirSync(installationPath, { recursive: true });
+            fs.writeFileSync(`${installationPath}/package.json`, JSON.stringify(packageObject, null, 2));
+            // Backward compatibility
+            const pnpmPath = await this.ensurePnpm();
+            return new Promise((resolve, reject) => {
+                const proc = (0, node_child_process_1.spawn)(pnpmPath, ['install', '--no-dev'], {
+                    cwd: installationPath,
+                    stdio: 'inherit',
+                });
+                proc.on('close', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        fs.rmSync(installationPath, { recursive: true, force: true });
+                        reject(new Error(`Failed to install dependencies with code ${code}`));
+                    }
+                });
+            });
+        }
+        catch (error) {
+            fs.rmSync(installationPath, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    async ensurePnpm() {
+        const pnpmPath = path.join(this.envPath, 'node_modules', '.bin', 'pnpm');
+        if (!fs.existsSync(pnpmPath)) {
+            return new Promise((resolve, reject) => {
+                const proc = (0, node_child_process_1.spawn)('npm', ['install', '--prefix', this.envPath, 'pnpm'], {
+                    cwd: this.envPath,
+                    stdio: 'inherit',
+                });
+                proc.on('close', (code) => {
+                    if (code === 0) {
+                        resolve(pnpmPath);
+                    }
+                    else {
+                        reject(new Error(`Failed to install pnpm with code ${code}`));
+                    }
+                });
+            });
+        }
+        return pnpmPath;
+    }
+}
+exports.default = JavaScriptEnvDependencies;

package/dist/core/dependencies/python-env-dependencies.d.ts

@@ -0,0 +1,9 @@
+import { ProgrammingLanguage, Dependency } from '../types';
+import EnvDependenciesCommand from './env-dependencies-command';
+export default class PythonEnvDependencies extends EnvDependenciesCommand {
+    get programmingLanguage(): ProgrammingLanguage;
+    createEnv(): Promise<void>;
+    installDependencies(installationPath: string, dependencies: Array<Dependency>): Promise<void>;
+    generateInit(): string;
+    private ensureUv;
+}

package/dist/core/dependencies/python-env-dependencies.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+const env_dependencies_command_1 = require("./env-dependencies-command");
+const cli_1 = require("../../utils/cli");
+class PythonEnvDependencies extends env_dependencies_command_1.default {
+    get programmingLanguage() {
+        return 'PYTHON';
+    }
+    async createEnv() {
+        try {
+            await new Promise((resolve, reject) => {
+                (0, node_child_process_1.exec)(`python3 -m venv ${this.envPath}`, (error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    cli_1.default.log(`Python virtual environment successfully created at ${this.envPath}`);
+                    resolve();
+                });
+            });
+            await this.ensureUv();
+        }
+        catch (error) {
+            fs.rmSync(this.envPath, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    async installDependencies(installationPath, dependencies) {
+        try {
+            const requirements = dependencies
+                .map(({ name, specifier }) => {
+                if (specifier.startsWith('git')) {
+                    return `${name} @ ${specifier}`;
+                }
+                return `${name}==${specifier}`;
+            })
+                .join('\n');
+            fs.mkdirSync(installationPath, { recursive: true });
+            fs.writeFileSync(`${installationPath}/requirements.txt`, requirements);
+            // Backward compatibility
+            const uvPath = await this.ensureUv();
+            return new Promise((resolve, reject) => {
+                const proc = (0, node_child_process_1.spawn)(uvPath, ['pip', 'install', '-r', './requirements.txt', '--target', '.'], {
+                    cwd: installationPath,
+                    stdio: 'inherit',
+                });
+                proc.on('close', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        fs.rmSync(installationPath, { recursive: true, force: true });
+                        reject(new Error(`Failed to install dependencies with code ${code}`));
+                    }
+                });
+            });
+        }
+        catch (error) {
+            fs.rmSync(installationPath, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    generateInit() {
+        return `import os
+import json
+`;
+    }
+    async ensureUv() {
+        const uvPath = path.join(this.envPath, 'bin', 'uv');
+        const pipPath = path.join(this.envPath, 'bin', 'pip');
+        if (!fs.existsSync(uvPath)) {
+            return new Promise((resolve, reject) => {
+                const proc = (0, node_child_process_1.spawn)(pipPath, ['install', '--force-reinstall', 'uv'], {
+                    cwd: this.envPath,
+                });
+                proc.on('close', (code) => {
+                    if (code === 0) {
+                        resolve(uvPath);
+                    }
+                    else {
+                        reject(new Error(`Failed to install uv with code ${code}`));
+                    }
+                });
+            });
+        }
+        return uvPath;
+    }
+}
+exports.default = PythonEnvDependencies;

package/dist/core/errors.d.ts

@@ -0,0 +1,55 @@
+import { Process, ProgrammingLanguage } from './types';
+export declare abstract class CLIError extends Error {
+    suggestions: any;
+    constructor(message: string, options?: {
+        exit?: false | number;
+        code?: string;
+        suggestions?: string[];
+    } & any);
+}
+export declare abstract class ResourceNotFound extends CLIError {
+    constructor(error: Error | string, resourceType: string, resourceId: string, options: {
+        exit?: false | number;
+    } & any);
+}
+export declare class LocalProcessNotFound extends ResourceNotFound {
+    constructor(error: Error | string, processId: string);
+}
+export declare class CloudProcessNotFound extends ResourceNotFound {
+    constructor(error: Error | string, processId: string);
+}
+export declare class LocalScriptLibraryNotFound extends ResourceNotFound {
+    constructor(error: Error | string, scriptLibraryId: string);
+}
+export declare class CloudScriptLibraryNotFound extends ResourceNotFound {
+    constructor(error: Error | string, scriptLibraryId: string);
+}
+export declare class LocalVariableNotFound extends ResourceNotFound {
+    constructor(error: Error | string, variableId: string);
+}
+export declare class CloudVariableNotFound extends ResourceNotFound {
+    constructor(error: Error | string, variableId: string);
+}
+export declare class LocalProgrammingLanguageManifestNotFound extends ResourceNotFound {
+    constructor(error: Error | string, programmingLanguageManifestId: string);
+}
+export declare class CloudProgrammingLanguageManifestNotFound extends ResourceNotFound {
+    constructor(error: Error | string, programmingLanguageManifestId: string);
+}
+export declare class NotAuthenticated extends CLIError {
+    url: string;
+    constructor(url: string);
+    getUrl(): string;
+}
+export declare class NotFcodeWorkspace extends CLIError {
+    constructor();
+}
+export declare class DependenciesNotInstalled extends CLIError {
+    constructor(programmingLanguage: ProgrammingLanguage);
+}
+export declare class ProcessDependenciesNotInstalled extends CLIError {
+    constructor(process: Process);
+}
+export declare class ErrorExecutingProcess extends CLIError {
+    constructor(message: string);
+}

package/dist/core/errors.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorExecutingProcess = exports.ProcessDependenciesNotInstalled = exports.DependenciesNotInstalled = exports.NotFcodeWorkspace = exports.NotAuthenticated = exports.CloudProgrammingLanguageManifestNotFound = exports.LocalProgrammingLanguageManifestNotFound = exports.CloudVariableNotFound = exports.LocalVariableNotFound = exports.CloudScriptLibraryNotFound = exports.LocalScriptLibraryNotFound = exports.CloudProcessNotFound = exports.LocalProcessNotFound = exports.ResourceNotFound = exports.CLIError = void 0;
+const global_1 = require("../config/global");
+class CLIError extends Error {
+    constructor(message, options) {
+        super(message);
+        this.name = this.constructor.name;
+        this.suggestions = options?.suggestions;
+    }
+}
+exports.CLIError = CLIError;
+class ResourceNotFound extends CLIError {
+    constructor(error, resourceType, resourceId, options) {
+        super(`Local ${resourceType} ${resourceId} not found!`, {
+            code: 'ERR_RESOURCE_NOT_FOUND',
+            exit: 1,
+            ...options,
+        });
+    }
+}
+exports.ResourceNotFound = ResourceNotFound;
+class LocalProcessNotFound extends ResourceNotFound {
+    constructor(error, processId) {
+        super(error, 'process', processId, {
+            code: 'ERR_LOCAL_PROCESS_NOT_FOUND',
+            suggestions: ['fcode processes'],
+        });
+    }
+}
+exports.LocalProcessNotFound = LocalProcessNotFound;
+class CloudProcessNotFound extends ResourceNotFound {
+    constructor(error, processId) {
+        super(error, 'process', processId, {
+            code: 'ERR_CLOUD_PROCESS_NOT_FOUND',
+            suggestions: ['fcode processes'],
+        });
+    }
+}
+exports.CloudProcessNotFound = CloudProcessNotFound;
+class LocalScriptLibraryNotFound extends ResourceNotFound {
+    constructor(error, scriptLibraryId) {
+        super(error, 'ScriptLibrary', scriptLibraryId, {
+            code: 'ERR_LOCAL_SCRIPT_LIBRARY_NOT_FOUND',
+            suggestions: [],
+        });
+    }
+}
+exports.LocalScriptLibraryNotFound = LocalScriptLibraryNotFound;
+class CloudScriptLibraryNotFound extends ResourceNotFound {
+    constructor(error, scriptLibraryId) {
+        super(error, 'ScriptLibrary', scriptLibraryId, {
+            code: 'ERR_CLOUD_SCRIPT_LIBRARY_NOT_FOUND',
+            suggestions: [],
+        });
+    }
+}
+exports.CloudScriptLibraryNotFound = CloudScriptLibraryNotFound;
+class LocalVariableNotFound extends ResourceNotFound {
+    constructor(error, variableId) {
+        super(error, 'Variable', variableId, {
+            code: 'ERR_LOCAL_VARIABLE_NOT_FOUND',
+            suggestions: [],
+        });
+    }
+}
+exports.LocalVariableNotFound = LocalVariableNotFound;
+class CloudVariableNotFound extends ResourceNotFound {
+    constructor(error, variableId) {
+        super(error, 'Variable', variableId, {
+            code: 'ERR_CLOUD_VARIABLE_NOT_FOUND',
+            suggestions: [],
+        });
+    }
+}
+exports.CloudVariableNotFound = CloudVariableNotFound;
+class LocalProgrammingLanguageManifestNotFound extends ResourceNotFound {
+    constructor(error, programmingLanguageManifestId) {
+        super(error, 'ProgrammingLanguageManifest', programmingLanguageManifestId, {
+            code: 'ERR_LOCAL_PROGRAMMING_LANGUAGE_MANIFEST_NOT_FOUND',
+            suggestions: [],
+        });
+    }
+}
+exports.LocalProgrammingLanguageManifestNotFound = LocalProgrammingLanguageManifestNotFound;
+class CloudProgrammingLanguageManifestNotFound extends ResourceNotFound {
+    constructor(error, programmingLanguageManifestId) {
+        super(error, 'ProgrammingLanguageManifest', programmingLanguageManifestId, {
+            code: 'ERR_CLOUD_PROGRAMMING_LANGUAGE_MANIFEST_NOT_FOUND',
+            suggestions: [],
+        });
+    }
+}
+exports.CloudProgrammingLanguageManifestNotFound = CloudProgrammingLanguageManifestNotFound;
+class NotAuthenticated extends CLIError {
+    constructor(url) {
+        super(`⚠️  No session active. Try 'fcode login${url !== global_1.FCODE_CLOUD_URL ? ' --url ' + url : ''}'`);
+        this.url = url;
+    }
+    getUrl() {
+        return this.url;
+    }
+}
+exports.NotAuthenticated = NotAuthenticated;
+class NotFcodeWorkspace extends CLIError {
+    constructor() {
+        super('⚠️  Current directory is not a Factorial Code workspace.', {
+            code: 'ERR_NOT_FCODE_WORKSPACE',
+            exit: 1,
+            suggestions: ['fcode clone <team-slug>'],
+        });
+    }
+}
+exports.NotFcodeWorkspace = NotFcodeWorkspace;
+class DependenciesNotInstalled extends CLIError {
+    constructor(programmingLanguage) {
+        super(`Dependencies not installed.`, {
+            code: `DEPENDENCIES_NOT_INSTALLED_${programmingLanguage}`,
+            exit: 1,
+            suggestions: [`fcode dependencies:install ${programmingLanguage.toLowerCase()}`],
+        });
+    }
+}
+exports.DependenciesNotInstalled = DependenciesNotInstalled;
+class ProcessDependenciesNotInstalled extends CLIError {
+    constructor(process) {
+        super(`Process dependencies not installed.`, {
+            code: `PROCESS_DEPENDENCIES_NOT_INSTALLED`,
+            exit: 1,
+            suggestions: [`fcode processes:install-dependencies ${process.slug}`],
+        });
+    }
+}
+exports.ProcessDependenciesNotInstalled = ProcessDependenciesNotInstalled;
+class ErrorExecutingProcess extends CLIError {
+    constructor(message) {
+        super(message, {
+            code: 'ERR_PROCESS_EXECUTION',
+            exit: 1,
+            suggestions: [],
+        });
+    }
+}
+exports.ErrorExecutingProcess = ErrorExecutingProcess;

package/dist/core/executors/execution-task.d.ts

@@ -0,0 +1,29 @@
+import type { ExecutionOptions, Process, ProgrammingLanguage } from '../types';
+declare abstract class ExecutionTask {
+    protected getVariablesObject: () => {};
+    _programmingLanguage: ProgrammingLanguage;
+    _options: ExecutionOptions;
+    _process: Process;
+    _dependenciesPath: string;
+    _tempDir: string;
+    _execFilePath: string;
+    constructor(_programmingLanguage: ProgrammingLanguage, process: Process, options: ExecutionOptions, tempDir?: string);
+    protected getCliPath(): Promise<string>;
+    protected getExecutionSourceCode(): string;
+    protected getDependenciesPath(): Promise<string>;
+    protected abstract _createExecutionFiles(tempDir: string): Promise<{
+        [name: string]: string;
+    }>;
+    get returnValueFilePath(): string;
+    get errorValueFilePath(): string;
+    readReturnValue(): unknown;
+    readErrorValue(): {
+        message: string;
+    } | undefined;
+    getMetadata(): {
+        [name: string]: any;
+    };
+    prepare(): Promise<string>;
+    cleanup(): void;
+}
+export default ExecutionTask;