@factorialco/fcode-cli 1.1.0

package/dist/repositories/script-library.d.ts

@@ -0,0 +1,28 @@
+import { ResourceMetadata, ScriptLibrary, VersionedScriptLibrary } from '../core/types';
+import ResourceRepositoryBase from './resource';
+declare class ScriptLibraryRepository extends ResourceRepositoryBase<ScriptLibrary> {
+    constructor();
+    find(slug: string): Promise<ScriptLibrary>;
+    private allFilesExist;
+    findSlugsNotAdded(): Promise<Array<string>>;
+    protected getSourceCodeFileName(scriptLibrary: ScriptLibrary): string;
+    protected getResourceDirectory(scriptLibrary: ScriptLibrary): string;
+    protected getResourcePath(scriptLibrary: ScriptLibrary): string;
+    protected resourceDirectoryName(scriptLibrary: ScriptLibrary): string;
+    protected removeFiles(scriptLibrary: ScriptLibrary): Promise<void>;
+    protected resourceToMetadata(scriptLibrary: ScriptLibrary): ResourceMetadata;
+    protected saveFiles(scriptLibrary: ScriptLibrary): Promise<void>;
+    private versionsDirectory;
+    private versionDirectory;
+    private versionPath;
+    versionHasChanges(scriptLibrary: ScriptLibrary, version: VersionedScriptLibrary): Promise<boolean>;
+    getLocalVersionTags(scriptLibrary: ScriptLibrary): string[];
+    versionExistsLocally(scriptLibrary: ScriptLibrary, tag: string): boolean;
+    removeVersion(scriptLibrary: ScriptLibrary, tag: string): void;
+    saveVersion(scriptLibrary: ScriptLibrary, version: VersionedScriptLibrary): Promise<void>;
+    metadataFromFiles(slug: string): Promise<ResourceMetadata>;
+    getVersions(scriptLibrary: ScriptLibrary): Promise<Array<VersionedScriptLibrary>>;
+    validSlug(slug: string): boolean;
+    slugFormatMessage(): string;
+}
+export default ScriptLibraryRepository;

package/dist/repositories/script-library.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs-extra");
+const path = require("node:path");
+const color_1 = require("@oclif/color");
+const cli_1 = require("../utils/cli");
+const errors_1 = require("../core/errors");
+const types_1 = require("../core/types");
+const filenamify_1 = require("../utils/filenamify");
+const file_utils_1 = require("../utils/file-utils");
+const resource_1 = require("./resource");
+const resource_checker_1 = require("../services/resource-checker");
+class ScriptLibraryRepository extends resource_1.default {
+    constructor() {
+        super({
+            name: 'modules',
+        });
+    }
+    async find(slug) {
+        const { [this._repositoryName]: scriptLibraries } = await this.workspaceConfig.getActiveTeam();
+        const scriptLibraryMetadata = scriptLibraries[slug];
+        if (!scriptLibraryMetadata) {
+            throw new errors_1.LocalScriptLibraryNotFound(new Error('Script library not found on team metadata'), slug);
+        }
+        const sourceCodeFile = fs.readFileSync(this.getResourcePath(scriptLibraryMetadata));
+        try {
+            const sourceCode = sourceCodeFile.toString();
+            return new types_1.ScriptLibrary(scriptLibraryMetadata.id, scriptLibraryMetadata.name, sourceCode, scriptLibraryMetadata.programmingLanguage, scriptLibraryMetadata.resolvingTeamSlug);
+        }
+        catch (error) {
+            throw new errors_1.LocalScriptLibraryNotFound(error, slug);
+        }
+    }
+    allFilesExist(directory) {
+        const processDirectory = path.join(this._repositoryName, directory);
+        return fs.pathExistsSync(path.join(processDirectory, `${directory}.js`)) || fs.pathExistsSync(path.join(processDirectory, `${directory}.py`));
+    }
+    async findSlugsNotAdded() {
+        const slugsNotAdded = [];
+        for (const directory of fs.readdirSync(this._repositoryName)) {
+            if (!(await this.workspaceConfig.exists('modules', directory))) {
+                if (!this.validSlug(directory)) {
+                    cli_1.default.log(color_1.default.yellow(`\n⚠️  local module directory '${directory}' doesn't have a valid format and will be ignored. ${this.slugFormatMessage()}`));
+                }
+                else if (!this.allFilesExist(directory)) {
+                    cli_1.default.log(color_1.default.yellow(`\n⚠️  local module directory '${directory}' doesn't have all the required files and will be ignored.`));
+                }
+                else {
+                    slugsNotAdded.push(directory);
+                }
+            }
+        }
+        return slugsNotAdded;
+    }
+    getSourceCodeFileName(scriptLibrary) {
+        return (0, filenamify_1.default)(scriptLibrary.name) + '.' + (scriptLibrary.programmingLanguage === 'PYTHON' ? `py` : `js`);
+    }
+    getResourceDirectory(scriptLibrary) {
+        return path.join(this._repositoryName, this.resourceDirectoryName(scriptLibrary));
+    }
+    getResourcePath(scriptLibrary) {
+        return path.join(this.getResourceDirectory(scriptLibrary), this.getSourceCodeFileName(scriptLibrary));
+    }
+    resourceDirectoryName(scriptLibrary) {
+        return (0, filenamify_1.default)(scriptLibrary.name);
+    }
+    async removeFiles(scriptLibrary) {
+        await new Promise((resolve, reject) => {
+            try {
+                fs.removeSync(this.getResourcePath(scriptLibrary));
+                this.removeDirectoryIfEmpty(this.getResourceDirectory(scriptLibrary));
+                resolve(true);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    resourceToMetadata(scriptLibrary) {
+        return {
+            id: scriptLibrary.id,
+            name: scriptLibrary.name,
+            slug: scriptLibrary.slug,
+            programmingLanguage: scriptLibrary.programmingLanguage,
+            ...(scriptLibrary.resolvingTeamSlug && { resolvingTeamSlug: scriptLibrary.resolvingTeamSlug }),
+        };
+    }
+    async saveFiles(scriptLibrary) {
+        (0, file_utils_1.outputFileSyncIfChanged)(this.getResourcePath(scriptLibrary), scriptLibrary.sourceCode || '', { readOnly: Boolean(scriptLibrary.resolvingTeamSlug) });
+    }
+    versionsDirectory(scriptLibrary) {
+        return path.join(this._repositoryName, this.resourceDirectoryName(scriptLibrary), 'versions');
+    }
+    versionDirectory(scriptLibrary, tag) {
+        return path.join(this.versionsDirectory(scriptLibrary), tag);
+    }
+    versionPath(scriptLibrary, tag) {
+        return path.join(this.versionDirectory(scriptLibrary, tag), this.getSourceCodeFileName(scriptLibrary));
+    }
+    async versionHasChanges(scriptLibrary, version) {
+        const versionPath = this.versionPath(scriptLibrary, version.tag);
+        if (!fs.pathExistsSync(versionPath)) {
+            return true;
+        }
+        const storedSourceCode = fs.readFileSync(versionPath).toString();
+        const storedVersion = new types_1.VersionedScriptLibrary(scriptLibrary.id, version.tag, storedSourceCode, scriptLibrary.programmingLanguage);
+        return !resource_checker_1.default.sameContent(storedVersion, version);
+    }
+    getLocalVersionTags(scriptLibrary) {
+        const versionsDir = this.versionsDirectory(scriptLibrary);
+        if (!fs.pathExistsSync(versionsDir))
+            return [];
+        return fs.readdirSync(versionsDir).filter((name) => this.validVersion(name));
+    }
+    versionExistsLocally(scriptLibrary, tag) {
+        return fs.pathExistsSync(this.versionDirectory(scriptLibrary, tag));
+    }
+    removeVersion(scriptLibrary, tag) {
+        fs.removeSync(this.versionDirectory(scriptLibrary, tag));
+    }
+    async saveVersion(scriptLibrary, version) {
+        const versionFilePath = path.join(this._repositoryName, this.resourceDirectoryName(scriptLibrary), 'versions', version.tag, this.getSourceCodeFileName(scriptLibrary));
+        fs.outputFileSync(versionFilePath, version.sourceCode || '');
+        fs.chmodSync(versionFilePath, 0o444);
+    }
+    async metadataFromFiles(slug) {
+        const resourceDirectory = path.join(this._repositoryName, slug);
+        const programmingLanguage = fs.existsSync(path.join(resourceDirectory, `${slug}.js`)) ? 'JAVASCRIPT' : 'PYTHON';
+        return {
+            name: slug,
+            slug: slug,
+            programmingLanguage,
+            contentHash: '',
+        };
+    }
+    async getVersions(scriptLibrary) {
+        const versionsDirectory = this.versionsDirectory(scriptLibrary);
+        if (!fs.pathExistsSync(versionsDirectory)) {
+            return [];
+        }
+        const versions = [];
+        for (const version of fs.readdirSync(versionsDirectory)) {
+            if (!this.validVersion(version)) {
+                cli_1.default.log(color_1.default.yellow(`\n⚠️  module version '${version}' doesn't have a valid format and will be ignored. ${this.versionFormatMessage()}`));
+                continue;
+            }
+            try {
+                const sourceCode = await fs.readFileSync(path.join(versionsDirectory, version, this.getSourceCodeFileName(scriptLibrary))).toString();
+                versions.push(new types_1.VersionedScriptLibrary(scriptLibrary.id, version, sourceCode, scriptLibrary.programmingLanguage));
+            }
+            catch {
+                cli_1.default.log(color_1.default.yellow(`\n⚠️  local version directory '${version}' doesn't have valid files and will be ignored.`));
+            }
+        }
+        return versions;
+    }
+    validSlug(slug) {
+        return /^[\w-.]*$/.test(slug);
+    }
+    slugFormatMessage() {
+        return 'Only letters, dashes and dots are allowed.';
+    }
+}
+exports.default = ScriptLibraryRepository;

package/dist/repositories/team.d.ts

@@ -0,0 +1,23 @@
+import { RawTeamSettings, Team } from '../core/types';
+import WorkspaceConfig from '../config/workspace';
+/**
+ * Reads/writes the singleton team.json (timezone, error handler, inheritance) at the
+ * workspace root. Unlike collection resources this is not a ResourceRepositoryBase:
+ * there is exactly one team, so there is no slug-keyed collection to manage.
+ *
+ * team.json references the error-handler process by slug for portability; the cloud
+ * references it by id, so this repository resolves slug<->id against the tracked
+ * process metadata in .fcode/.
+ */
+export default class TeamRepository {
+    protected workspaceConfig: WorkspaceConfig;
+    exists(): boolean;
+    find(): Promise<Team>;
+    save(team: Team): void;
+    /** Builds a Team from the cloud's raw settings, resolving the error-handler id to a slug. */
+    fromRaw(raw: RawTeamSettings): Promise<Team>;
+    resolveSlugToId(processSlug: string): Promise<string>;
+    resolveIdToSlug(processId: string): Promise<string>;
+    private parseErrorHandler;
+    private toFile;
+}

package/dist/repositories/team.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs-extra");
+const types_1 = require("../core/types");
+const workspace_1 = require("../config/workspace");
+const file_utils_1 = require("../utils/file-utils");
+const TEAM_FILENAME = 'team.json';
+/**
+ * Reads/writes the singleton team.json (timezone, error handler, inheritance) at the
+ * workspace root. Unlike collection resources this is not a ResourceRepositoryBase:
+ * there is exactly one team, so there is no slug-keyed collection to manage.
+ *
+ * team.json references the error-handler process by slug for portability; the cloud
+ * references it by id, so this repository resolves slug<->id against the tracked
+ * process metadata in .fcode/.
+ */
+class TeamRepository {
+    constructor() {
+        this.workspaceConfig = new workspace_1.default();
+    }
+    exists() {
+        return fs.pathExistsSync(TEAM_FILENAME);
+    }
+    async find() {
+        const slug = await this.workspaceConfig.getActiveTeamSlug();
+        let raw = {};
+        try {
+            raw = fs.readJsonSync(TEAM_FILENAME) || {};
+        }
+        catch { }
+        const parentTeamSlugs = Array.isArray(raw.parentTeamSlugs) ? raw.parentTeamSlugs : [];
+        return new types_1.Team(slug, parentTeamSlugs, raw.zoneId, this.parseErrorHandler(raw.errorHandlerConfig));
+    }
+    save(team) {
+        (0, file_utils_1.outputFileSyncIfChanged)(TEAM_FILENAME, JSON.stringify(this.toFile(team), null, 2));
+    }
+    /** Builds a Team from the cloud's raw settings, resolving the error-handler id to a slug. */
+    async fromRaw(raw) {
+        let errorHandlerConfig;
+        if (raw.errorHandlerConfig?.processId) {
+            errorHandlerConfig = {
+                processSlug: await this.resolveIdToSlug(raw.errorHandlerConfig.processId),
+                tag: raw.errorHandlerConfig.tag ?? null,
+            };
+        }
+        return new types_1.Team(raw.slug, raw.parentTeamSlugs ?? [], raw.zoneId, errorHandlerConfig);
+    }
+    async resolveSlugToId(processSlug) {
+        const { processes } = await this.workspaceConfig.getActiveTeam();
+        return processes[processSlug]?.id ?? processSlug;
+    }
+    async resolveIdToSlug(processId) {
+        const { processes } = await this.workspaceConfig.getActiveTeam();
+        const match = Object.values(processes).find((process) => process.id === processId);
+        return match?.slug ?? processId;
+    }
+    parseErrorHandler(raw) {
+        if (!raw || !raw.processSlug) {
+            return undefined;
+        }
+        return { processSlug: raw.processSlug, tag: raw.tag ?? null };
+    }
+    toFile(team) {
+        const file = { parentTeamSlugs: team.parentTeamSlugs ?? [] };
+        if (team.zoneId !== undefined) {
+            file.zoneId = team.zoneId;
+        }
+        if (team.errorHandlerConfig !== undefined) {
+            file.errorHandlerConfig = team.errorHandlerConfig;
+        }
+        return file;
+    }
+}
+exports.default = TeamRepository;

package/dist/repositories/variable.d.ts

@@ -0,0 +1,26 @@
+import { AddResourceOptions, ResourceMetadata, Variable } from '../core/types';
+import ResourceRepositoryBase from './resource';
+export declare const DEFAULT_SENSITIVE_VALUE = "********";
+declare class VariableRepository extends ResourceRepositoryBase<Variable> {
+    private filename;
+    private localFilename;
+    private filenameInitPromise;
+    constructor();
+    private ensureFilenamesInitialized;
+    findAll(): Promise<Variable[]>;
+    findAllForExecution(): Promise<Variable[]>;
+    find(slug: string): Promise<Variable>;
+    findSlugsNotAdded(): Promise<Array<string>>;
+    protected getResourcePath(_resource: Variable): string;
+    protected removeFiles(variable: Variable): Promise<void>;
+    protected resourceToMetadata(variable: Variable): ResourceMetadata;
+    protected saveFiles(variable: Variable): Promise<void>;
+    metadataFromFiles(slug: string, opts: AddResourceOptions): Promise<ResourceMetadata>;
+    private readVariablesMeta;
+    private writeVariablesMeta;
+    private filePath;
+    private readVariablesFromFile;
+    private valueToSave;
+    private writeRawVariables;
+}
+export default VariableRepository;

package/dist/repositories/variable.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SENSITIVE_VALUE = void 0;
+const dotenv_1 = require("dotenv");
+const fs = require("fs-extra");
+const path = require("node:path");
+const types_1 = require("../core/types");
+const resource_1 = require("./resource");
+const errors_1 = require("../core/errors");
+const global_1 = require("../config/global");
+const settings_1 = require("../config/settings");
+const file_utils_1 = require("../utils/file-utils");
+const env_utils_1 = require("../utils/env-utils");
+exports.DEFAULT_SENSITIVE_VALUE = '********';
+const VARIABLES_META_FILENAME = 'variables.meta.json';
+class VariableRepository extends resource_1.default {
+    constructor() {
+        super({
+            name: 'variables',
+        });
+        this.filename = null;
+        this.localFilename = null;
+        this.filenameInitPromise = null;
+    }
+    async ensureFilenamesInitialized() {
+        if (this.filenameInitPromise) {
+            return this.filenameInitPromise;
+        }
+        this.filenameInitPromise = (async () => {
+            const globalConfig = new global_1.default();
+            this.filename = await globalConfig.getSetting(settings_1.SettingKeys.VARIABLES_FILE_NAME);
+            this.localFilename = await globalConfig.getSetting(settings_1.SettingKeys.LOCAL_VARIABLES_FILE_NAME);
+        })();
+        return this.filenameInitPromise;
+    }
+    async findAll() {
+        await this.ensureFilenamesInitialized();
+        const rawVariables = this.readVariablesFromFile();
+        const localOverrideKeys = new Set(Object.keys(this.readVariablesFromFile(true)));
+        const meta = this.readVariablesMeta();
+        const variables = [];
+        const { variables: localVariables } = await this.workspaceConfig.getActiveTeam();
+        for (const localVariableKey of Object.keys(localVariables)) {
+            const localVariable = localVariables[localVariableKey];
+            const isSensitive = meta[localVariable.key]?.isSensitive ?? false;
+            const variable = types_1.Variable.validate(new types_1.Variable(localVariable.id, localVariable.key, rawVariables[localVariable.key], isSensitive));
+            variable.overriddenLocally = localOverrideKeys.has(localVariable.key);
+            variables.push(variable);
+        }
+        return variables;
+    }
+    async findAllForExecution() {
+        await this.ensureFilenamesInitialized();
+        const rawVariables = this.readVariablesFromFile();
+        const localRawVariables = this.readVariablesFromFile(true);
+        const meta = this.readVariablesMeta();
+        const variables = [];
+        const { variables: localVariables } = await this.workspaceConfig.getActiveTeam();
+        for (const localVariableKey of Object.keys(localVariables)) {
+            const localVariable = localVariables[localVariableKey];
+            const value = localRawVariables[localVariable.key] || rawVariables[localVariable.key];
+            const isSensitive = meta[localVariable.key]?.isSensitive ?? false;
+            variables.push(types_1.Variable.validate(new types_1.Variable(localVariable.id, localVariable.key, value, isSensitive)));
+        }
+        return variables;
+    }
+    async find(slug) {
+        let variables = await this.findAll();
+        variables = variables.filter((v) => v.key === slug);
+        if (variables.length > 0) {
+            return variables[0];
+        }
+        throw new errors_1.LocalVariableNotFound(new Error('Variable not found on team metadata'), slug);
+    }
+    async findSlugsNotAdded() {
+        await this.ensureFilenamesInitialized();
+        const { variables: localVariables } = await this.workspaceConfig.getActiveTeam();
+        const slugsNotAdded = [];
+        for (const [key, _value] of Object.entries(this.readVariablesFromFile())) {
+            if (!localVariables[key]) {
+                slugsNotAdded.push(key);
+            }
+        }
+        return slugsNotAdded;
+    }
+    getResourcePath(_resource) {
+        throw new Error('Method not implemented.');
+    }
+    async removeFiles(variable) {
+        await this.ensureFilenamesInitialized();
+        let rawVariables = this.readVariablesFromFile();
+        delete rawVariables[variable.key];
+        this.writeRawVariables(rawVariables);
+        const meta = this.readVariablesMeta();
+        delete meta[variable.key];
+        this.writeVariablesMeta(meta);
+    }
+    resourceToMetadata(variable) {
+        return {
+            id: variable.id,
+            slug: variable.slug,
+            key: variable.key,
+        };
+    }
+    async saveFiles(variable) {
+        await this.ensureFilenamesInitialized();
+        let rawVariables = this.readVariablesFromFile();
+        rawVariables = Object.assign(rawVariables, { [variable.key]: this.valueToSave(variable) });
+        this.writeRawVariables(rawVariables);
+        const meta = this.readVariablesMeta();
+        meta[variable.key] = { isSensitive: variable.isSensitive };
+        this.writeVariablesMeta(meta);
+    }
+    async metadataFromFiles(slug, opts) {
+        const meta = this.readVariablesMeta();
+        const isSensitive = opts.variableSensitive || meta[slug]?.isSensitive || false;
+        meta[slug] = { isSensitive };
+        this.writeVariablesMeta(meta);
+        return {
+            slug,
+            key: slug,
+            contentHash: '',
+        };
+    }
+    readVariablesMeta() {
+        try {
+            return fs.readJsonSync(VARIABLES_META_FILENAME) || {};
+        }
+        catch {
+            return {};
+        }
+    }
+    writeVariablesMeta(meta) {
+        const sorted = Object.keys(meta)
+            .sort()
+            .reduce((acc, key) => {
+            acc[key] = meta[key];
+            return acc;
+        }, {});
+        (0, file_utils_1.outputFileSyncIfChanged)(VARIABLES_META_FILENAME, JSON.stringify(sorted, null, 2));
+    }
+    filePath(useLocalVersion = false) {
+        if (!this.filename || !this.localFilename) {
+            throw new Error('Filenames not initialized. Call ensureFilenamesInitialized() first.');
+        }
+        return path.join(useLocalVersion ? this.localFilename : this.filename);
+    }
+    readVariablesFromFile(useLocalVersion = false) {
+        try {
+            const result = (0, dotenv_1.parse)(fs.readFileSync(this.filePath(useLocalVersion), 'utf8')) || {};
+            for (const [key, value] of Object.entries(result)) {
+                result[key] = (0, env_utils_1.unescapeEnvValue)(value);
+            }
+            return result;
+        }
+        catch {
+            return {};
+        }
+    }
+    valueToSave(variable) {
+        if (!variable.value && variable.isSensitive) {
+            return exports.DEFAULT_SENSITIVE_VALUE;
+        }
+        return variable.value;
+    }
+    writeRawVariables(rawVariables) {
+        const envContent = Object.entries(rawVariables)
+            .sort((a, b) => a[0].localeCompare(b[0]))
+            .map(([key, value]) => `${key}=${(0, env_utils_1.escapeEnvValue)(value)}`)
+            .join('\n');
+        (0, file_utils_1.outputFileSyncIfChanged)(this.filePath(), envContent);
+    }
+}
+exports.default = VariableRepository;

package/dist/runtime/executor.js

@@ -0,0 +1,87 @@
+const fs = require('node:fs')
+const path = require('node:path')
+const { execSync } = require('node:child_process')
+const os = require('node:os')
+
+const YC_COMMAND = process.env.YC_COMMAND ?? "fcode"
+
+const file = process.argv[2]
+if (!fs.existsSync(file)) {
+  console.error('File not found: ' + file)
+  process.exit(1)
+}
+
+function getVersion(relativePath) {
+  const parts = relativePath.split(path.sep)
+  if (parts.length == 5 && parts[2] == 'versions') {
+    return parts[3]
+  }
+  return null
+}
+
+const absolutePath = path.resolve(file)
+if (!absolutePath.startsWith(process.cwd() + path.sep)) {
+  console.error('File outside of current directory: ' + file)
+  process.exit(1)
+}
+const relativePath = path.relative(process.cwd(), absolutePath)
+
+if (!relativePath.endsWith('.js') || !relativePath.startsWith('processes' + path.sep)) {
+  console.error('You can only debug JavaScript processes, file not valid: ' + absolutePath)
+  process.exit(1)
+}
+
+let mainFilePath = ''
+let dependenciesPath = ''
+try {
+  version = getVersion(relativePath)
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'fcode-'))
+  const command = [YC_COMMAND, 'pre-debug', absolutePath, '-t', tempDir]
+  if (version) {
+    command.push('-v')
+    command.push(version)
+  }
+  console.log('Running command: ' + command.join(' '))
+
+  try {
+    execSync(command.join(' '), { encoding: 'utf-8', stdio: 'inherit' })
+  } catch (error) {
+    console.error('Command finished with exit code: ' + error.status)
+    process.exit(1)
+  }
+
+  const variablesFile = path.join(tempDir, 'METADATA')
+  if (!fs.existsSync(variablesFile)) {
+    console.error('Temporal directory not found')
+    process.exit(1)
+  }
+
+  const fileContent = fs.readFileSync(variablesFile, 'utf-8')
+  const lines = fileContent.split('\n')
+
+  for (const line of lines) {
+    if (line.includes('FCODE_EXECUTION_FILE')) {
+      mainFilePath = line.split('=')[1].trim()
+    }
+    if (line.includes('FCODE_DEPENDENCIES_PATH')) {
+      dependenciesPath = line.split('=')[1].trim()
+    }
+  }
+
+  if (!mainFilePath || !dependenciesPath) {
+    console.error('Failed creating process temporal files')
+    process.exit(1)
+  }
+} catch (error) {
+  console.error('Error running command')
+  console.error(error)
+  process.exit(1)
+}
+
+const fileName = path.basename(mainFilePath).replace('.js', '')
+const executionDir = path.dirname(path.resolve(mainFilePath))
+
+const newPaths = [path.join(path.dirname(path.resolve(__filename)), 'libs', 'node'), path.join(dependenciesPath, 'node_modules'), process.cwd()]
+
+process.env.NODE_PATH = [process.env.NODE_PATH, ...newPaths].join(':')
+require(path.join(executionDir, fileName))

package/dist/runtime/executor.py

@@ -0,0 +1,81 @@
+import os
+import sys
+import subprocess
+import tempfile
+
+
+YC_COMMAND = os.environ.get("YC_COMMAND", "fcode")
+file = sys.argv[1]
+if not os.path.exists(file):
+    print("File not found: " + file)
+    exit(1)
+
+
+def get_version(file):
+    parts = file.split(os.sep)
+    if len(parts) == 5 and parts[2] == "versions":
+        return parts[3]
+    return None
+
+
+file = os.path.abspath(file)
+if not file.startswith(os.getcwd() + os.sep):
+    print("File outside of current directory: " + file)
+    exit(1)
+relative_file = file.replace(os.getcwd() + os.sep, "")
+if not file.endswith(".py") or not relative_file.startswith("processes" + os.sep):
+    print("You can only debug python processes, file not valid: " + file)
+    exit(1)
+
+main_file_path = ""
+try:
+    version = get_version(file)
+    tempDir = tempfile.TemporaryDirectory()
+    command = [YC_COMMAND, "pre-debug", file, "-t", tempDir.name]
+    if version != None:
+        command.append("-v")
+        command.append(version)
+    print("Running command: " + " ".join(command))
+    result = subprocess.run(" ".join(command), shell=True, encoding="utf-8")
+    if result.returncode != 0:
+        print("Command finished with exit code: " + str(result.returncode))
+        exit(1)
+    variables_file = os.path.join(tempDir.name, "METADATA")
+    if not os.path.exists(variables_file):
+        print("Temporal directory not found")
+        exit(1)
+    with open(variables_file, "r") as f:
+        for line in f:
+            if "FCODE_EXECUTION_FILE" in line:
+                main_file_path = line.split("=")[1].strip()
+            if "FCODE_DEPENDENCIES_PATH" in line:
+                dependencies_path = line.split("=")[1].strip()
+            if "FCODE_TMP_PATH" in line:
+                os.environ["FCODE_RUNTIME_METADATA_PATH"] = os.path.join(
+                    line.split("=")[1].strip(), "initialize_params.py"
+                )
+    if len(main_file_path) == 0 or len(dependencies_path) == 0:
+        print("Failed creating process temporal files")
+        exit(1)
+except Exception as e:
+    print("Error running command")
+    print(e)
+    exit(1)
+
+file_name = os.path.basename(main_file_path).replace(".py", "")
+execution_dir = os.path.dirname(os.path.realpath(main_file_path))
+tmp_dir_name = os.path.basename(execution_dir)
+tmp_dir_parent = os.path.dirname(execution_dir)
+library_path = os.path.join(
+    os.path.dirname(os.path.realpath(__file__)), "libs", "python"
+)
+sys.path.append(library_path)
+sys.path.append(tmp_dir_parent)
+sys.path.append(dependencies_path)
+sys.path.append(os.getcwd())
+print("## library_path: " + library_path)
+print("## dependencies_path: " + dependencies_path)
+print("## tmp_dir_parent: " + tmp_dir_parent)
+print("## os.getcwd(): " + os.getcwd())
+print("## importing: " + tmp_dir_name + "." + file_name)
+__import__(tmp_dir_name + "." + file_name, fromlist=[tmp_dir_name])

package/dist/runtime/libs/node/fcode/index.js

@@ -0,0 +1 @@
+module.exports = { fcode }