@factorialco/fcode-cli 1.1.0

package/dist/core/executors/javascript-execution-task.js

@@ -0,0 +1,618 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const errors_1 = require("../errors");
+const fs = require("node:fs");
+const path = require("node:path");
+const execution_task_1 = require("./execution-task");
+const source_code_sanitizer_1 = require("./source-code-sanitizer");
+/**
+ * Task which handles native executions using child_process.
+ */
+class JavaScriptExecutionTask extends execution_task_1.default {
+    async run() {
+        if (!this._execFilePath) {
+            this.prepare();
+        }
+        const nodePath = process.env.NODE_PATH;
+        const fcodeLibPath = path.join(__dirname, '..', '..', 'runtime', 'libs', 'node');
+        const nodeModulesPath = path.join(this._dependenciesPath, 'node_modules');
+        const forked = (0, node_child_process_1.fork)(path.resolve(this._execFilePath), {
+            env: {
+                FORCE_COLOR: 'true',
+                NODE_PATH: [nodeModulesPath, nodePath, fcodeLibPath].filter((p) => p).join(':'),
+                PATH: process.env.PATH,
+            },
+            silent: false,
+        });
+        return new Promise((resolve, reject) => {
+            forked.on('exit', (code) => {
+                if (code) {
+                    reject(new errors_1.ErrorExecutingProcess(`Process exited with code ${code}`));
+                }
+                else {
+                    resolve(undefined);
+                }
+            });
+        });
+    }
+    _getLegacyBlock() {
+        const sourceCode = this.getExecutionSourceCode();
+        return `const main = async () => { ${sourceCode}
+      };`;
+    }
+    _getNewBlock() {
+        if (this._options.hookFilePath) {
+            const fn = this._options.hookFunction ?? 'main';
+            return `
+const _hooksModule = require('${this._options.hookFilePath}')
+const main = typeof _hooksModule['${fn}'] === 'function'
+  ? _hooksModule['${fn}']
+  : async () => undefined`;
+        }
+        const processPath = [process.cwd(), 'processes', this._process.slug];
+        if (this._options.version) {
+            processPath.push('versions', this._options.version);
+        }
+        processPath.push('index.js');
+        const fullPath = path.join(...processPath);
+        return `const { main }= require('${fullPath}')`;
+    }
+    async _createExecutionFiles(tempDir) {
+        if (!this._options.silent) {
+            this._options.jsonLogs
+                ? process.stdout.write(JSON.stringify({ timestamp: new Date().toISOString(), level: 'DEBUG', message: `Creating execution files for '${this._process.slug}' in ${tempDir}` }) + '\n')
+                : console.debug(`Creating execution files for '${this._process.slug}' in ${tempDir}`);
+        }
+        const execFilePath = `${tempDir}/${this._process.slug}.js`;
+        const metadata = this.getMetadata();
+        const execution = metadata.execution;
+        execution.id = '00000000-0000-0000-0000-000000000000';
+        execution.process = {
+            id: execution.process?.id || '00000000-0000-0000-0000-000000000000',
+            name: execution.process?.name || 'Process not yet pushed to cloud',
+        };
+        execution.timeout = 86400000;
+        const isLegacy = !this._options.hookFilePath && (0, source_code_sanitizer_1.isLegacySourceCode)(this.getExecutionSourceCode(), 'JAVASCRIPT');
+        fs.writeFileSync(execFilePath, `${isLegacy ? this._getLegacyBlock() : ''}
+
+      global.logLevel = "` +
+            this._options.logLevel +
+            `";
+      const logLevels = ["DEBUG", "INFO", "WARNING", "ERROR"];
+      const shouldLog = (level) => {
+        return logLevels.indexOf(level) >= logLevels.indexOf(global.logLevel);
+      };
+      const _console = console
+      ${this._options.jsonLogs ? `
+      const _ts = () => new Date().toISOString();
+      const _fmt = (level, msg, rest) => JSON.stringify({timestamp:_ts(),level,message:[msg,...rest].map(p=>typeof p==='string'?p:JSON.stringify(p)).join(' ')});
+      global.console = {
+        ...global.console,
+        log:   (msg, ...rest) => { shouldLog("INFO")    && _console.log(_fmt("INFO",   msg, rest)); },
+        warn:  (msg, ...rest) => { shouldLog("WARNING") && _console.warn(_fmt("WARNING",msg, rest)); },
+        error: (msg, ...rest) => { shouldLog("ERROR")   && _console.error(_fmt("ERROR",  msg, rest)); },
+        debug: (msg, ...rest) => { shouldLog("DEBUG")   && _console.debug(_fmt("DEBUG",  msg, rest)); },
+      };` : `
+      global.console = {
+        ...global.console,
+        log: (message, ...optionalParams) => {
+          shouldLog("INFO") && _console.log(message, ...optionalParams);
+        },
+        warn: (message, ...optionalParams) => {
+          shouldLog("WARNING") && _console.warn(message, ...optionalParams);
+        },
+        error: (message, ...optionalParams) => {
+          shouldLog("ERROR") && _console.error(message, ...optionalParams);
+        },
+        debug: (message, ...optionalParams) => {
+          shouldLog("DEBUG") && _console.debug(message, ...optionalParams);
+        },
+      };`}
+
+      global.fcode = {
+        import: (moduleName, version) => {
+          let modulePath = require('path').join('${process.cwd()}', 'modules', moduleName);
+          if(version) {
+            modulePath = require('path').join(modulePath, 'versions', version)
+          }
+          modulePath = require('path').join(modulePath, moduleName + '.js')
+          return require(modulePath)
+        },
+        env: ${JSON.stringify(metadata.variables, null, 2)},
+        context: {
+          parameters: ${JSON.stringify(metadata.parameters, null, 2)},
+          request: ${JSON.stringify(metadata.request)}
+        },
+        execution: ${JSON.stringify(metadata.execution, null, 2)},
+        team: {
+          "timezone": "UTC"
+        },
+        processes: {
+          run: (processIdentifier, options) => {
+            const { exec } = require('child_process');
+            const tag = options.tag ? " -v " + options.tag : ''
+            const parameters = options.parameters ? " -p '" + JSON.stringify(options.parameters) + "'" : ''
+            const command = "fcode run " + processIdentifier + tag + parameters
+            exec(command, {},  (error, stdout, stderr) => {
+              if (error) {
+                console.error(error)
+              }
+              console.log(stdout)
+              console.error(stderr)
+            })
+          }
+        },
+        datastore: {
+          async save(datastore) {
+            return new Promise((resolve, reject) => {
+              require('fs').writeFile(require('path').join('${process.cwd()}', 'datastore.json'), JSON.stringify(datastore, null, 2), (err) => {
+                if (err) {
+                  reject(err)
+                }
+                resolve(undefined)
+              })
+            })
+          },
+          getAll() {
+            try {
+              return require(require('path').join('${process.cwd()}', 'datastore.json'));
+            } catch (e) {
+              return {}
+            }
+          },
+          async get(key) {
+            if ((typeof key === 'string' || typeof key === 'number')) {
+              return this.getAll()[key] || null
+            }
+            throw new Error('Invalid argument type')
+          },
+          async set(key, value) {
+            if ((typeof key === 'string' || typeof key === 'number') && (typeof value === 'string' || typeof value === 'number')) {
+              const datastore = this.getAll()
+              datastore[key] = value
+              return this.save(datastore)
+            }
+            throw new Error('Invalid argument type')
+          },
+          async del(key) {
+            const datastore = this.getAll()
+            delete datastore[key]
+            return this.save(datastore)
+          }
+        },
+        storage: {
+          async upload(filename, file) {
+            return new Promise((resolve, reject) => {
+              const fs = require('fs')
+              const path = require('path')
+              const crypto = require('crypto')
+
+              const createResponse = (filePath, hash) => {
+                try {
+                  const stats = fs.statSync(filePath)
+                  const currentTime = new Date().toISOString()
+
+                  return {
+                    name: filename,
+                    size: stats.size,
+                    link: filePath,
+                    md5_hash: hash.digest('hex'),
+                    content_type: 'application/octet-stream',
+                    created_at: currentTime,
+                    updated_at: currentTime
+                  }
+                } catch (error) {
+                  throw new Error(\`Storage upload failed: unable to process file - \${error.message}\`)
+                }
+              }
+
+              if (typeof filename !== 'string') {
+                return reject(new Error('Storage upload failed: filename must be a string'))
+              }
+
+              if (!filename.trim()) {
+                return reject(new Error('Storage upload failed: filename cannot be empty'))
+              }
+
+              if (!file) {
+                return reject(new Error('Storage upload failed: file parameter is required'))
+              }
+
+              const isReadable = typeof file?.pipe === 'function'
+              const isFile = typeof File !== 'undefined' && file instanceof File
+              const isBlob = typeof Blob !== 'undefined' && file instanceof Blob
+              const isBuffer = Buffer.isBuffer(file)
+              const isString = typeof file === 'string'
+
+              if (!isReadable && !isFile && !isBlob && !isBuffer && !isString) {
+                return reject(new Error('Storage upload failed: file must be File, Blob, Readable stream, Buffer, or string'))
+              }
+
+              try {
+                const storageDir = path.join('${process.cwd()}', 'storage')
+                if (!fs.existsSync(storageDir)) {
+                  fs.mkdirSync(storageDir)
+                }
+
+                const filePath = path.join(storageDir, filename)
+                const fileDir = path.dirname(filePath)
+
+                if (!fs.existsSync(fileDir)) {
+                  fs.mkdirSync(fileDir, { recursive: true })
+                }
+
+                const hash = crypto.createHash('md5')
+
+                if (isFile || isBlob) {
+                  file.arrayBuffer().then(arrayBuffer => {
+                    const buffer = Buffer.from(arrayBuffer)
+                    hash.update(buffer)
+
+                    fs.writeFile(filePath, buffer, (err) => {
+                      if (err) {
+                        return reject(new Error(\`Storage upload failed: write error - \${err.message}\`))
+                      }
+
+                      try {
+                        resolve(createResponse(filePath, hash))
+                      } catch (error) {
+                        reject(error)
+                      }
+                    })
+                  }).catch(error => {
+                    reject(new Error(\`Storage upload failed: unable to read file content - \${error.message}\`))
+                  })
+                } else if (isReadable) {
+                  const writeStream = fs.createWriteStream(filePath)
+
+                  file.on('data', (chunk) => {
+                    hash.update(chunk)
+                  })
+
+                  file.pipe(writeStream)
+
+                  writeStream.on('finish', () => {
+                    try {
+                      resolve(createResponse(filePath, hash))
+                    } catch (error) {
+                      reject(error)
+                    }
+                  })
+
+                  writeStream.on('error', (error) => {
+                    reject(new Error(\`Storage upload failed: write error - \${error.message}\`))
+                  })
+
+                  file.on('error', (error) => {
+                    reject(new Error(\`Storage upload failed: stream error - \${error.message}\`))
+                  })
+                } else if (isBuffer) {
+                  hash.update(file)
+
+                  fs.writeFile(filePath, file, (err) => {
+                    if (err) {
+                      return reject(new Error(\`Storage upload failed: write error - \${err.message}\`))
+                    }
+
+                    try {
+                      resolve(createResponse(filePath, hash))
+                    } catch (error) {
+                      reject(error)
+                    }
+                  })
+                } else if (isString) {
+                  const buffer = Buffer.from(file, 'utf8')
+                  hash.update(buffer)
+
+                  fs.writeFile(filePath, buffer, (err) => {
+                    if (err) {
+                      return reject(new Error(\`Storage upload failed: write error - \${err.message}\`))
+                    }
+
+                    try {
+                      resolve(createResponse(filePath, hash))
+                    } catch (error) {
+                      reject(error)
+                    }
+                  })
+                }
+
+              } catch (error) {
+                reject(new Error(\`Storage upload failed: \${error.message}\`))
+              }
+            })
+          },
+
+          list(prefix = '') {
+            const fs = require('fs')
+            const path = require('path')
+            const crypto = require('crypto')
+
+            if (typeof prefix !== 'string') {
+              throw new Error('Storage list failed: prefix must be a string')
+            }
+
+            const storageDir = path.join('${process.cwd()}', 'storage')
+
+            if (!fs.existsSync(storageDir)) {
+              return []
+            }
+
+            const files = []
+
+            const walkDir = (dir, relativePath = '') => {
+              try {
+                const items = fs.readdirSync(dir)
+
+                for (const item of items) {
+                  const fullPath = path.join(dir, item)
+                  const itemRelativePath = path.join(relativePath, item)
+
+                  try {
+                    const stats = fs.statSync(fullPath)
+
+                    if (stats.isDirectory()) {
+                      walkDir(fullPath, itemRelativePath)
+                    } else if (stats.isFile()) {
+                      const normalizedPath = itemRelativePath.replace(/\\\\/g, '/')
+                      if (!prefix || normalizedPath.startsWith(prefix)) {
+                        try {
+                          const content = fs.readFileSync(fullPath)
+                          const hash = crypto.createHash('md5').update(content).digest('hex')
+
+                          files.push({
+                            name: normalizedPath,
+                            size: stats.size,
+                            link: fullPath,
+                            md5_hash: hash,
+                            content_type: 'application/octet-stream',
+                            created_at: stats.birthtime.toISOString(),
+                            updated_at: stats.mtime.toISOString()
+                          })
+                        } catch (error) {
+                          console.warn(\`Storage list warning: unable to process file \${normalizedPath}: \${error.message}\`)
+                        }
+                      }
+                    }
+                  } catch (error) {
+                    console.warn(\`Storage list warning: unable to access \${itemRelativePath}: \${error.message}\`)
+                  }
+                }
+              } catch (error) {
+                throw new Error(\`Storage list failed: unable to read directory \${dir}: \${error.message}\`)
+              }
+            }
+
+            try {
+              walkDir(storageDir)
+              return files
+            } catch (error) {
+              throw new Error(\`Storage list failed: \${error.message}\`)
+            }
+          },
+
+          async download(filename) {
+            return new Promise((resolve, reject) => {
+              const fs = require('fs')
+              const path = require('path')
+
+              if (typeof filename !== 'string') {
+                return reject(new Error('Storage download failed: filename must be a string'))
+              }
+
+              if (!filename.trim()) {
+                return reject(new Error('Storage download failed: filename cannot be empty'))
+              }
+
+              const filePath = path.join('${process.cwd()}', 'storage', filename)
+
+              if (!fs.existsSync(filePath)) {
+                return reject(new Error(\`Storage download failed: file not found - \${filename}\`))
+              }
+
+              try {
+                const stats = fs.statSync(filePath)
+                if (!stats.isFile()) {
+                  return reject(new Error(\`Storage download failed: \${filename} is not a file\`))
+                }
+
+                const readStream = fs.createReadStream(filePath)
+
+                readStream.on('error', (error) => {
+                  reject(new Error(\`Storage download failed: unable to read file - \${error.message}\`))
+                })
+
+                resolve(readStream)
+              } catch (error) {
+                reject(new Error(\`Storage download failed: \${error.message}\`))
+              }
+            })
+          },
+
+          async delete(filename) {
+            return new Promise((resolve, reject) => {
+              const fs = require('fs')
+              const path = require('path')
+
+              if (typeof filename !== 'string') {
+                return reject(new Error('Storage delete failed: filename must be a string'))
+              }
+
+              if (!filename.trim()) {
+                return reject(new Error('Storage delete failed: filename cannot be empty'))
+              }
+
+              const filePath = path.join('${process.cwd()}', 'storage', filename)
+
+              if (!fs.existsSync(filePath)) {
+                return reject(new Error(\`Storage delete failed: file not found - \${filename}\`))
+              }
+
+              try {
+                const stats = fs.statSync(filePath)
+                if (!stats.isFile()) {
+                  return reject(new Error(\`Storage delete failed: \${filename} is not a file\`))
+                }
+
+                fs.unlinkSync(filePath)
+
+                let dir = path.dirname(filePath)
+                const storageDir = path.join('${process.cwd()}', 'storage')
+
+                while (dir !== storageDir && dir !== path.dirname(dir)) {
+                  try {
+                    const items = fs.readdirSync(dir)
+                    if (items.length === 0) {
+                      fs.rmdirSync(dir)
+                      dir = path.dirname(dir)
+                    } else {
+                      break
+                    }
+                  } catch (error) {
+                    console.warn(\`Storage delete warning: unable to clean up directory \${dir}: \${error.message}\`)
+                    break
+                  }
+                }
+
+                resolve(undefined)
+              } catch (error) {
+                reject(new Error(\`Storage delete failed: \${error.message}\`))
+              }
+            })
+          },
+
+          async createSignedUrl(filename, options = {}) {
+            const fs = require('fs')
+            const path = require('path')
+            const url = require('url')
+
+            if (typeof filename !== 'string' || !filename.trim()) {
+              throw new Error('Storage createSignedUrl failed: filename must be a non-empty string')
+            }
+
+            const expiresInSeconds = options.expiresInSeconds ?? 3600
+            if (!Number.isInteger(expiresInSeconds) || expiresInSeconds < 1 || expiresInSeconds > 604800) {
+              throw new Error('Storage createSignedUrl failed: expiresInSeconds must be an integer between 1 and 604800')
+            }
+
+            const filePath = path.join('${process.cwd()}', 'storage', filename)
+
+            if (!fs.existsSync(filePath)) {
+              throw new Error(\`Storage createSignedUrl failed: file not found - \${filename}\`)
+            }
+
+            // Local runtime has no object store to sign against, so return a
+            // file:// URL to the file on disk. Mirrors the cloud { url, path,
+            // expiresAt } contract so process code needs no local-vs-cloud guard.
+            console.warn('Storage createSignedUrl: no object store in local runtime; returning a file:// URL to the local file (mock).')
+
+            return {
+              url: url.pathToFileURL(filePath).href,
+              path: filename,
+              expiresAt: new Date(Date.now() + expiresInSeconds * 1000).toISOString()
+            }
+          }
+        },
+        schedule: {
+          // Scheduling is cloud-only; every method is a logged no-op during local \`fcode run\`.
+          create: async () => { console.warn('[fcode] schedule.create only runs in the cloud; no-op during local run.'); return null },
+          list: async () => { console.warn('[fcode] schedule.list only runs in the cloud; no-op during local run.'); return [] },
+          get: async () => { console.warn('[fcode] schedule.get only runs in the cloud; no-op during local run.'); return null },
+          update: async () => { console.warn('[fcode] schedule.update only runs in the cloud; no-op during local run.'); return null },
+          delete: async () => { console.warn('[fcode] schedule.delete only runs in the cloud; no-op during local run.') },
+          deleteForProcess: async () => { console.warn('[fcode] schedule.deleteForProcess only runs in the cloud; no-op during local run.'); return 0 },
+          pause: async () => { console.warn('[fcode] schedule.pause only runs in the cloud; no-op during local run.') },
+          resume: async () => { console.warn('[fcode] schedule.resume only runs in the cloud; no-op during local run.') }
+        },
+        variables: (() => {
+          const fs = require('fs');
+          const localEnvPath = require('path').join('${process.cwd()}', 'variables.local.env');
+          const baseVars = ${JSON.stringify(metadata.variables, null, 2)};
+          const readLocal = () => { try { return fs.readFileSync(localEnvPath, 'utf8') } catch { return '' } };
+          const parseEnv = (text) => {
+            const map = {};
+            for (const raw of text.split('\\n')) {
+              const line = raw.trim();
+              if (!line || line.startsWith('#')) continue;
+              const eq = line.indexOf('=');
+              if (eq === -1) continue;
+              map[line.slice(0, eq).trim()] = line.slice(eq + 1);
+            }
+            return map;
+          };
+          // Merged view: team + local file loaded at start, overlaid with the current
+          // variables.local.env so same-run writes are reflected.
+          const merged = () => {
+            const base = {};
+            if (Array.isArray(baseVars)) { for (const v of baseVars) base[v.key] = v.value; }
+            else { Object.assign(base, baseVars); }
+            return { ...base, ...parseEnv(readLocal()) };
+          };
+          return {
+            list: async () => Object.entries(merged()).map(([key, value]) => ({ key, value })),
+            get: async (key) => merged()[key],
+            // Writes affect only variables.local.env (never the shared variables.env).
+            set: async (key, value) => {
+              const lines = readLocal().split('\\n');
+              const out = [];
+              let replaced = false;
+              for (const line of lines) {
+                const t = line.trim();
+                const eq = t.indexOf('=');
+                if (t && !t.startsWith('#') && eq !== -1 && t.slice(0, eq).trim() === key) {
+                  out.push(key + '=' + String(value));
+                  replaced = true;
+                } else {
+                  out.push(line);
+                }
+              }
+              while (out.length && out[out.length - 1].trim() === '') out.pop();
+              if (!replaced) out.push(key + '=' + String(value));
+              fs.writeFileSync(localEnvPath, out.join('\\n') + '\\n');
+              console.log('[fcode] variables.set wrote ' + key + ' to variables.local.env (local run).');
+            },
+            delete: async (key) => {
+              const text = readLocal();
+              if (!text) return;
+              const out = [];
+              for (const line of text.split('\\n')) {
+                const t = line.trim();
+                const eq = t.indexOf('=');
+                if (t && !t.startsWith('#') && eq !== -1 && t.slice(0, eq).trim() === key) continue;
+                out.push(line);
+              }
+              while (out.length && out[out.length - 1].trim() === '') out.pop();
+              fs.writeFileSync(localEnvPath, out.length ? out.join('\\n') + '\\n' : '');
+              console.log('[fcode] variables.delete removed ' + key + ' from variables.local.env (local run).');
+            }
+          };
+        })()
+      };
+      ${Object.entries(this.getVariablesObject())
+                .map(([key, value]) => `process.env['${key}'] = process.env['${key}'] ?? ${JSON.stringify(value)}`)
+                .join('\n')}
+
+      require("module").Module._initPaths();
+      ${!isLegacy && this._getNewBlock()}
+
+      main().then((r) => {
+        if (r !== null && r !== undefined) {
+          ${this._options.jsonLogs
+                ? `_console.log(JSON.stringify({timestamp:new Date().toISOString(),level:"INFO",message:"Return",data:r}));`
+                : `console.log('Return: ', r);`}
+          try { require('fs').writeFileSync(${JSON.stringify(this.returnValueFilePath)}, JSON.stringify(r)); } catch(e) {}
+        }
+      }).catch((e) => {
+        console.error(e);
+        try { require('fs').writeFileSync(${JSON.stringify(this.errorValueFilePath)}, JSON.stringify({ message: e?.message ?? String(e) })); } catch(_) {}
+        process.exit(1);
+      })
+`);
+        return {
+            FCODE_EXECUTION_FILE: execFilePath,
+            FCODE_TMP_PATH: tempDir,
+        };
+    }
+}
+exports.default = JavaScriptExecutionTask;

package/dist/core/executors/python/context.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "";
+export default _default;

package/dist/core/executors/python/context.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ``;

package/dist/core/executors/python/datastore.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n";
+export default _default;

package/dist/core/executors/python/datastore.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = `
+`;

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

@@ -0,0 +1,11 @@
+import ExecutionTask from './execution-task';
+declare class PythonExecutionTask extends ExecutionTask {
+    run(): Promise<unknown>;
+    _getJsonLogsSetup(): string;
+    _getReturnBlock(result: string): string;
+    _getMainBlock(): string;
+    _createExecutionFiles(tempDir: string): Promise<{
+        [name: string]: string;
+    }>;
+}
+export default PythonExecutionTask;