@fnet/cli 0.100.2 → 0.101.0

package/dist/fnode/index.js

@@ -0,0 +1,2784 @@
+#!/usr/bin/env node
+import path$1 from 'path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'child_process';
+import prompt from '@fnet/prompt';
+import { Command, Option } from 'commander';
+import fs$1 from 'fs';
+import yaml from 'yaml';
+import fnetShellJs from '@fnet/shelljs';
+import os$1 from 'os';
+import fnetYaml from '@fnet/yaml';
+import fnetConfig from '@fnet/config';
+import fnetObjectFromSchema from '@fnet/object-from-schema';
+import fnetShellFlow from '@fnet/shell-flow';
+import fnetRender from '@flownet/lib-render-templates-dir';
+import fs, { existsSync } from 'node:fs';
+import path, { delimiter, join } from 'node:path';
+import os from 'node:os';
+import nunjucks from 'nunjucks';
+import { randomUUID } from 'node:crypto';
+import { Api, Atom } from '@flownet/lib-atom-api-js';
+import fnetParseNodeUrl from '@flownet/lib-parse-node-url';
+import fnetParseImports from '@flownet/lib-parse-imports-js';
+import fnetListFiles from '@fnet/list-files';
+import chalk from 'chalk';
+import redis from 'redis';
+import fnetIsRedisOnline from '@flownet/lib-is-redis-online';
+import merge from 'lodash.merge';
+import fnetListNpmVersions from '@fnet/npm-list-versions';
+import fnetPickNpmVersions from '@fnet/npm-pick-versions';
+import hash from 'object-hash';
+import Ajv from 'ajv/dist/2020.js';
+import standaloneCode from 'ajv/dist/standalone/index.js';
+import addFormats from 'ajv-formats';
+import fnetAutoCondaEnv from '@fnet/auto-conda-env';
+
+async function createRedisClient() {
+    const isOnline = await fnetIsRedisOnline({ host: process.env.REDIS_HOST, port: process.env.REDIS_PORT });
+    if (!isOnline) return;
+
+    const redisClient = redis.createClient({
+        socket: { host: process.env.REDIS_HOST, port: process.env.REDIS_PORT }
+    });
+    await redisClient.connect();
+
+    return redisClient;
+}
+
+class Auth {
+    init({ config, accessToken }) {
+        return new Promise((resolve, reject) => {
+
+            Api.set_api_url(config.data.url);
+
+            if (accessToken) {
+                Api.set_req_token(accessToken);
+                resolve(accessToken);
+                return;
+            }
+
+            fetch(`${config.data.issuer}/protocol/openid-connect/token`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded"
+                },
+                body: new URLSearchParams(config.data.grant.params)
+            })
+                .then(async (response) => {
+                    if (!response.ok) throw new Error(await response.text());
+                    return response.json();
+                })
+                .then(response => {
+                    Api.set_req_token(response.access_token);
+                    resolve(response.access_token);
+                })
+                .catch(error => {
+                    Api.set_req_token();
+                    reject(error);
+                });
+        });
+    }
+}
+
+function featureTemplate({ feature, features, packageDevDependencies }) {
+
+  const { name, packages, options, extraCheck, explicit } = feature;
+
+  const keyEnabled = `${name}_enabled`;
+
+  const rollup_output = features.rollup_output || {};
+
+  const allKeys = Object.keys(rollup_output);
+
+  let initialOptions = options || {};
+
+  const featureOptions = features[name]?.options;
+
+  if (featureOptions) initialOptions = merge(initialOptions, featureOptions);
+
+  const globallyDisabled = !features[name] || features[name]?.enabled === false;
+
+  allKeys.forEach(key => {
+    const output = features.rollup_output[key];
+
+    if (!output) return;
+
+    // Output has the feature
+    if (Reflect.has(output, name)) {
+      if (globallyDisabled || !output[name] || output[name]?.enabled === false) {
+        delete output[name];
+        return;
+      }
+      if (output[name] === true) {
+        output[name] = {
+          enabled: true,
+          options: initialOptions
+        };
+      }
+    } else {
+      // Output hasn't the feature
+      if (!globallyDisabled && !explicit && features[keyEnabled] !== false) {
+        output[name] = {
+          enabled: true,
+        };
+      }
+      else return;
+    }
+    output[name] = output[name] || {};
+    output[name].options = {
+      ...initialOptions,
+      ...output[name].options
+    };
+  });
+
+  let exists = allKeys.some(w => features.rollup_output[w][name]?.enabled === true);
+
+  if (extraCheck) exists = extraCheck() && exists;
+
+  features[keyEnabled] = exists;
+
+  if (exists) {
+    packages.forEach(p => packageDevDependencies.push({ package: p[0], version: p[1] }));
+  }
+}
+
+function initWorkboxFeature(apiContext) {
+
+  const { atom, packageDevDependencies } = apiContext;
+  const features = atom.doc.features;
+
+  featureTemplate({
+    feature: {
+      name: "workbox",
+      packages: [["rollup-plugin-workbox", "^8"]],
+      options: {
+        generate: {
+          swDest: 'dist/app/esm/sw.js',
+          globDirectory: 'dist/app/esm',
+          globPatterns: ['**/*.{html,js,css,png,jpg}'],
+          skipWaiting: true,
+          clientsClaim: true
+        }
+      },
+      explicit: true
+    }, features, packageDevDependencies
+  });
+}
+
+function initGzipFeature(apiContext) {
+
+  const { atom, packageDevDependencies } = apiContext;
+  const features = atom.doc.features;
+
+  featureTemplate({
+    feature: {
+      name: "gzip",
+      packages: [["rollup-plugin-gzip", "^4"]],
+      explicit: true
+    }, features, packageDevDependencies
+  });
+}
+
+function initNunjucksFeature(apiContext) {
+
+  const { atom, packageDevDependencies } = apiContext;
+  const features = atom.doc.features;
+
+  featureTemplate({
+    feature: {
+      name: "nunjucks",
+      packages: [["@fnet/rollup-plugin-nunjucks", "0.1.8"]],
+    }, features, packageDevDependencies
+  });
+}
+
+function initPolyfillFeature(apiContext) {
+
+  const { atom, packageDevDependencies } = apiContext;
+  const features = atom.doc.features;
+
+  featureTemplate({
+    feature: {
+      name: "polyfill",
+      packages: [["rollup-plugin-node-polyfills", "^0.2"]],
+    }, features, packageDevDependencies
+  });
+}
+
+function initVisualizerFeature(apiContext) {
+
+  const { atom, packageDevDependencies } = apiContext;
+  const features = atom.doc.features;
+
+  featureTemplate({
+    feature: {
+      name: "visualizer",
+      packages: [["rollup-plugin-visualizer", "^5"]]}, features, packageDevDependencies
+  });
+}
+
+function initAnalyzerFeature(apiContext) {
+  const { atom, packageDevDependencies } = apiContext;
+  const features = atom.doc.features;
+
+  featureTemplate({
+    feature: {
+      name: "analyzer",
+      packages: [["rollup-plugin-analyzer", "^3"]],
+      options: {
+        summaryOnly: true,
+        limit: 12
+      },
+      explicit: true
+    }, features, packageDevDependencies
+  });
+}
+
+function initStringFeature(apiContext) {
+
+  const { atom, packageDevDependencies } = apiContext;
+  const features = atom.doc.features;
+
+  featureTemplate({
+    feature: {
+      name: "string",
+      packages: [["rollup-plugin-string", "^3"]],
+    }, features, packageDevDependencies
+  });
+}
+
+function initImageFeature(apiContext) {
+
+  const { atom, packageDevDependencies } = apiContext;
+  const features = atom.doc.features;
+
+  featureTemplate({
+    feature: {
+      name: "image",
+      packages: [["@rollup/plugin-image", "^3"]],
+    }, features, packageDevDependencies
+  });
+}
+
+function initJsonFeature(apiContext) {
+
+  const { atom, packageDevDependencies } = apiContext;
+  const features = atom.doc.features;
+
+  featureTemplate({
+    feature: {
+      name: "json",
+      packages: [["@rollup/plugin-json", "^6"]],
+    }, features, packageDevDependencies
+  });
+}
+
+function initTerserFeature(apiContext) {
+
+  const { atom, packageDevDependencies } = apiContext;
+  const features = atom.doc.features;
+
+  featureTemplate({
+    feature: {
+      name: "terser",
+      packages: [["@rollup/plugin-terser", "^0.4"]],
+    }, features, packageDevDependencies
+  });
+}
+
+function initWasmFeature(apiContext) {
+
+  const { atom, packageDevDependencies } = apiContext;
+  const features = atom.doc.features;
+
+  featureTemplate({
+    feature: {
+      name: "wasm",
+      packages: [["@rollup/plugin-wasm", "^6"]],
+    }, features, packageDevDependencies
+  });
+}
+
+function initCopyFeature(apiContext) {
+
+  const { atom, packageDevDependencies } = apiContext;
+  const features = atom.doc.features;
+
+  const options = {};
+
+  // TODO: remove it later
+  // app specific
+  if (features.app?.enabled === true) {
+    options.targets = options.targets || [];
+    options.targets.push({ src: "./src/app/index.html", dest: features.app.dir });
+    if (!Reflect.has(features.app, "copy")) {
+      if (!Reflect.has(features, "copy")) {
+        features.copy = true;
+      }
+    }
+  }
+
+  // const extraCheck = () => {
+  //   return features.app_enabled;
+  // }
+
+  featureTemplate({
+    feature: {
+      name: "copy",
+      packages: [["rollup-plugin-copy", "^3"], ["chokidar", "^3"]],
+      options
+      // extraCheck
+    }, features, packageDevDependencies
+  });
+}
+
+function initCssFeature(apiContext) {
+
+  const { atom, packageDevDependencies } = apiContext;
+  const features = atom.doc.features;
+
+  const cssEnabled = features.css && features.css.enabled !== false;
+
+  let packages = [];
+
+  if (cssEnabled) {
+    packages.push(["rollup-plugin-postcss", "^4"]);
+    packages.push(["sass", "^1.66"]);
+    const plugins = features.css?.options?.plugins || [];
+    plugins.forEach(plugin => {
+      switch (plugin.name) {
+        case 'postcss-import':
+          packages.push(["postcss-import", "^15"]);
+          break;
+        case 'postcss-url':
+          packages.push(["postcss-url", "^10"]);
+          break;
+        case 'postcss-preset-env':
+          packages.push(["postcss-preset-env", "^9"]);
+          break;
+        case 'autoprefixer':
+          packages.push(["autoprefixer", "^10"]);
+          break;
+        case 'cssnano':
+          packages.push(["cssnano", "^6"]);
+          break;
+      }
+    });
+  }
+  
+  featureTemplate({
+    feature: {
+      name: "css",
+      packages: packages,
+    }, features, packageDevDependencies
+  });
+}
+
+function findEntryFile({ dir, name = 'index' }) {
+  let entryFile = path.resolve(dir, `./${name}.tsx`);
+
+  if (!fs.existsSync(entryFile)) entryFile = path.resolve(dir, `./${name}.ts`);
+  if (!fs.existsSync(entryFile)) entryFile = path.resolve(dir, `./${name}.jsx`);
+  if (!fs.existsSync(entryFile)) entryFile = path.resolve(dir, `./${name}.js`);
+  if (!fs.existsSync(entryFile)) return {};
+
+  const file = entryFile;
+  const ext = path.extname(entryFile);
+  const ts = ext === '.ts' || ext === '.tsx';
+
+  return { file, ext, ts, name };
+}
+async function initFeatures(apiContext) {
+
+  const { atom, context, setProgress } = apiContext;
+
+  setProgress('Initializing features...');
+
+  atom.doc.features = atom.doc.features || {};
+  const features = atom.doc.features;
+
+  // project format
+  features.project = features.project || {};
+  features.project.format = features.project.format || features.project_format || "esm";
+  features.project_format = features.project.format;
+
+  features.dts_enabled = features.dts === true || (typeof features.dts !== 'undefined' && features.dts !== false);
+
+  const projectDir = path.resolve(context.project.projectDir);
+
+  const appEntry = findEntryFile({ dir: path.resolve(projectDir, './app') });
+  if (appEntry.file) {
+    setProgress('Parsing app entry imports...');
+
+    let parsed = await fnetParseImports({ file: appEntry.file, recursive: true });
+    let usesJSX = parsed.all.some(w => w.usesJSX === true && w.type === 'local');
+    features.app_uses_jsx = usesJSX;
+    features.app_has_entry = true;
+    parsed = await fnetParseImports({ file: appEntry.file });
+    usesJSX = parsed.all.some(w => w.usesJSX === true && w.type === 'local');
+    features.app_entry_uses_jsx = usesJSX;
+    features.app_entry_is_ts = appEntry.ts;
+    features.app_entry_ext = appEntry.ext;
+  }
+
+  const cliEntry = findEntryFile({ dir: path.resolve(projectDir, './cli') });
+  if (cliEntry.file) {
+    setProgress('Parsing cli entry imports...');
+
+    let parsed = await fnetParseImports({ file: cliEntry.file, recursive: true });
+    let usesJSX = parsed.all.some(w => w.usesJSX === true && w.type === 'local');
+    features.cli_uses_jsx = usesJSX;
+    features.cli_has_entry = true;
+    parsed = await fnetParseImports({ file: cliEntry.file });
+    usesJSX = parsed.all.some(w => w.usesJSX === true && w.type === 'local');
+    features.cli_entry_uses_jsx = usesJSX;
+    features.cli_entry_is_ts = cliEntry.ts;
+    features.cli_entry_ext = cliEntry.ext;
+  }
+
+  if (atom.type === 'workflow.lib') {
+    const srcEntry = findEntryFile({ dir: path.resolve(projectDir, './src') });
+
+    if (srcEntry.file) {
+      setProgress('Parsing src entry imports...');
+
+      let parsed = await fnetParseImports({ file: srcEntry.file, recursive: true });
+      let usesJSX = parsed.all.some(w => w.usesJSX === true && w.type === 'local');
+      features.src_uses_jsx = usesJSX;
+      features.src_has_entry = true;
+      parsed = await fnetParseImports({ file: srcEntry.file });
+      usesJSX = parsed.all.some(w => w.usesJSX === true && w.type === 'local');
+      features.src_entry_uses_jsx = usesJSX;
+      features.src_entry_is_ts = srcEntry.ts;
+      features.src_entry_ext = srcEntry.ext;
+    }
+  }
+
+  const isAppReact = Reflect.has(features, 'app_entry_uses_jsx') ? features.app_entry_uses_jsx === true : features.src_entry_uses_jsx === true;
+  const isCliReact = Reflect.has(features, 'cli_entry_uses_jsx') ? features.cli_entry_uses_jsx === true : features.src_entry_uses_jsx === true;
+
+  features.form_enabled = (isAppReact || isCliReact) || features.form === true || features.form?.enabled === true;
+  features.multiple_enabled = features.multiple_enabled || features.multiple === true || features.multiple?.enabled === true;
+
+  // APP PROPS
+  if (features.app === false) {
+    features.app = {
+      enabled: false,
+    };
+  } else if (features.app === true) {
+    features.app = {
+      enabled: true,
+      extend: features.app_has_entry === true,
+      export: true,
+      react: isAppReact
+    };
+  } else features.app = { enabled: true, extend: features.app_has_entry === true, export: true, react: isAppReact, ...(features.app || {}) };
+
+
+  features.app.enabled = features.app.enabled === true && (atom.doc.features.form_enabled === true || features.app.extend === true || features.app.enabled === true);
+  features.app.format = features.app.format || "esm";
+  features.app.folder = features.app.folder || features.app.format || "default";
+
+  // CLI PROPS
+  if (features.cli === false) {
+    features.cli = {
+      enabled: false
+    };
+  } else if (features.cli === true) {
+    features.cli = {
+      enabled: true,
+      extend: features.cli_has_entry === true,
+      export: true,
+      react: isCliReact
+    };
+  } else features.cli = {
+    enabled: true,
+    extend: features.cli_has_entry === true,
+    export: true,
+    react: isCliReact, ...(features.cli || {})
+  };
+
+  features.cli.enabled = features.cli.enabled === true && (atom.doc.features.form_enabled === false || features.cli.extend === true || features.cli.enabled === true);
+  features.cli.format = features.cli.format || "esm";
+  features.cli.folder = features.cli.folder || features.cli.folder || "esm";
+  features.cli.node_options = features.cli.node?.options || features.cli.node_options || '';
+  features.json = features.cli.enabled || features.json;
+
+  // rollup output default
+  const rollup_output_default = {
+    cjs: {
+      format: "cjs",
+      context: features.form_enabled ? "window" : "global",
+      babel: (features.src_uses_jsx === true) || false,
+      browser: false,
+      replace: true,
+      terser: true,
+      enabled: features.cjs !== false,
+      copy: false,
+    },
+    esm: {
+      format: "esm",
+      context: features.form_enabled ? "window" : "global",
+      babel: (features.src_uses_jsx === true) || false,
+      browser: false,
+      replace: true,
+      terser: false,
+      enabled: features.esm !== false,
+      copy: true,
+    },
+    iife: {
+      format: "iife",
+      context: features.form_enabled ? "window" : "global",
+      babel: true,
+      browser: true,
+      replace: true,
+      enabled: features.iife === true,
+      terser: true,
+      copy: false,
+    }
+  };
+
+  // babel targets default
+  const babel_default = {
+    targets: {
+      browsers: "last 9 versions, not dead",
+      node: "18"
+    }
+  };
+
+  // replace default
+  const replace_default = {};
+
+  // webos default
+  if (features.webos === true) {
+    rollup_output_default.webos = {
+      format: "iife",
+      browser: true,
+      babel: true,
+      context: "window",
+      replace: true,
+      terser: true,
+      input: "./src/app/index.js",
+      output_dir: `./dist/app/webos`,
+      copy: false,
+      babel_options: {
+        targets: {
+          chrome: "79"
+        }
+      }
+    };
+  }
+
+  // electron default
+  if (features.electron === true) {
+    rollup_output_default.electron = {
+      format: "iife",
+      browser: true,
+      babel: true,
+      context: "window",
+      replace: true,
+      terser: true,
+      copy: false,
+      input: "./src/app/index.js",
+      output_dir: `./dist/app/electron`,
+    };
+  }
+
+  // nextsj default
+  if (features.nextjs === true) {
+    rollup_output_default.nextjs = {
+      format: "esm",
+      browser: true,
+      babel: true,
+      context: "window",
+      replace: true,
+      terser: true,
+      copy: false,
+      input: "./src/app/index.js",
+      output_dir: `./dist/app/nextjs`,
+    };
+  }
+
+  // ios default
+  if (features.ios === true) {
+    rollup_output_default.ios = {
+      format: "iife",
+      browser: true,
+      babel: true,
+      context: "window",
+      replace: true,
+      terser: true,
+      copy: false,
+      input: "./src/app/index.js",
+      output_dir: `./dist/app/ios`,
+    };
+  }
+
+  // macos default
+  if (features.macos === true) {
+    rollup_output_default.macos = {
+      format: "iife",
+      browser: true,
+      babel: true,
+      context: "window",
+      replace: true,
+      terser: true,
+      copy: false,
+      input: "./src/app/index.js",
+      output_dir: `./dist/app/macos`,
+    };
+  }
+
+  // app default
+  if (features.app.enabled === true) {
+    features.app.dir = `./dist/app/${features.app.folder}`;
+
+    rollup_output_default.app = {
+      format: features.app.format,
+      browser: true,
+      babel: true,
+      context: "window",
+      replace: true,
+      input: "./src/app/index.js",
+      output_dir: features.app.dir,
+      terser: true,
+      output_exports: features.app.export === false ? "none" : "auto",
+      browsersync: true,
+    };
+  }
+
+  // cli default
+  if (features.cli.enabled === true) {
+    features.cli.dir = `./dist/cli/${features.cli.folder}`;
+
+    rollup_output_default.cli = {
+      format: features.cli.format,
+      context: "global",
+      babel: (features.src_uses_jsx === true || features.cli_uses_jsx === true) || false,
+      browser: false,
+      replace: true,
+      enabled: true,
+      input: "./src/cli/index.js",
+      output_dir: features.cli.dir,
+      banner: "#!/usr/bin/env node",
+      terser: true,
+      output_exports: features.cli.export === false ? "none" : "auto",
+    };
+  }
+
+  // browsersync default
+  const browsersync_default = {
+    server: '.',
+    startPath: `${path.normalize(features.app.dir || '.')}`,
+    files: [path.normalize("./dist/**/*")],
+    cors: true,
+    open: false,
+  };
+
+  features.babel_options = merge(babel_default, features.babel_options || features.babel?.options);
+  features.browsersync_options = merge(browsersync_default, features.browsersync_options || features.browsersync?.options || {});
+  features.replace_options = merge(replace_default, features.replace_options || features.replace?.options || {});
+
+  if (Reflect.has(features.browsersync_options, 'proxy')) {
+    delete features.browsersync_options.server;
+  }
+
+  features.rollup = features.rollup || {};
+  features.rollup_output = merge(rollup_output_default, features.rollup_output || features.rollup?.output || {});
+
+  features.preact_enabled = features.preact === true || (features.preact && features.preact?.enabled !== false);
+
+  // rollup outputs
+  let rollup_output_keys = Object.keys(rollup_output_default);
+  for (const key of rollup_output_keys) {
+    const output = rollup_output_default[key];
+
+    if (!output) continue;
+
+    if (features.rollup[key] === false) {
+      delete features.rollup_output[key];
+      continue;
+    }
+    output.babel_options = output.babel_options || features.babel_options;
+    output.browsersync_options = merge(features.browsersync_options, output.browsersync_options);
+    output.replace_options = merge(features.replace_options, output.replace_options);
+
+    if (features.preact_enabled) {
+      output.alias_enabled = true;
+      output.alias = output.alias || {};
+      output.alias.entries = output.alias.entries || {};
+      output.alias.entries['react'] = 'preact/compat';
+      output.alias.entries['react-dom'] = 'preact/compat';
+    }
+
+    if (features.form_enabled || features.babel) output.babel = true;
+  }
+
+  rollup_output_keys = Object.keys(features.rollup_output);
+
+  features.babel_enabled = rollup_output_keys.some(w => features.rollup_output[w].babel === true);
+  features.browser_enabled = rollup_output_keys.some(w => features.rollup_output[w].babel === true);
+  features.browsersync_enabled = features.browsersync !== false && rollup_output_keys.some(w => features.rollup_output[w].browsersync === true);
+  features.browsersync_enabled = features.browsersync_enabled && features.app.enabled;
+  features.dependency_auto_enabled = features.dependency_auto !== false && features.dependency_auto?.enabled !== false;
+  features.npm_install_flags = features.npm_install_flags || '';
+  features.react_version = features.react_version || features.react?.version || 18;
+
+  initCssFeature(apiContext);
+  initCopyFeature(apiContext);
+  initWasmFeature(apiContext);
+  initTerserFeature(apiContext);
+  initJsonFeature(apiContext);
+  initStringFeature(apiContext);
+  initImageFeature(apiContext);
+  initAnalyzerFeature(apiContext);
+  initVisualizerFeature(apiContext);
+  initPolyfillFeature(apiContext);
+  initNunjucksFeature(apiContext);
+  initWorkboxFeature(apiContext);
+  initGzipFeature(apiContext);
+}
+
+async function initPythonFeature(apiContext) {
+  const { atom, context, setProgress } = apiContext;
+  setProgress('Initializing features...');
+
+  atom.doc.features = atom.doc.features || {};
+  const features = atom.doc.features;
+
+  // CLI PROPS
+  if (features.cli === false) {
+    features.cli = {
+      enabled: false
+    };
+  } else if (features.cli === true) {
+    features.cli = {
+      enabled: true,
+    };
+  } else features.cli = {
+    enabled: true
+  };
+
+  features.cli.enabled = features.cli.enabled === true && (atom.doc.features.form_enabled === false || features.cli.extend === true || features.cli.enabled === true);
+}
+
+async function initDependencies({ atom, packageDependencies, packageDevDependencies, setProgress }) {
+
+  setProgress('Initializing dependencies');
+
+  const userDependencies = atom.doc.dependencies || [];
+  userDependencies.filter(w => !w.dev).forEach(dep => packageDependencies.push(dep));
+  userDependencies.filter(w => w.dev).forEach(dep => packageDevDependencies.push(dep));
+
+  if (atom.type === 'workflow') {
+    packageDependencies.push({ package: "get-value", version: "^3" });
+    packageDependencies.push({ package: "set-value", version: "^4" });
+  }
+
+  if (atom.doc.features.form_enabled) {
+    if (atom.doc.features.dependency_auto_enabled) {
+      let reactVersion = '^18.2';
+      setProgress('Fetching React versions');
+      const versions = await fnetListNpmVersions({ name: "react", groupBy: { major: true } });
+      const found = versions.find(w => w[0] === atom.doc.features.react_version.toString());
+      reactVersion = `^${found[0]}`;
+      packageDependencies.push({ package: "react", version: reactVersion });
+      packageDependencies.push({ package: "react-dom", version: reactVersion });
+
+      if (atom.type === 'workflow') {
+        packageDependencies.push({ package: "@fnet/react-app", version: "^0.1" });
+        packageDependencies.push({ package: "@fnet/react-app-state", version: "^0.1" });
+      }
+    }
+  }
+
+  if (atom.doc.features.preact_enabled) {
+    packageDependencies.push({ package: "preact", version: "^10" });
+  }
+
+  if (atom.doc.features.cli.enabled === true) {
+    packageDependencies.push({ package: "@fnet/args", version: "^0.1" });
+    packageDevDependencies.push({ package: "ajv", version: "^8" });
+
+    if (atom.doc.features.cli.fargs && atom.doc.features.cli.fargs?.enabled !== false) {
+      packageDependencies.push({ package: "@fnet/config", version: "0.2.21" });
+    }
+  }
+
+  if (atom.doc.features.render && atom.doc.features.render.enabled !== false) {
+    packageDevDependencies.push({ package: "@flownet/lib-render-templates-dir", version: "0.1.19" });
+  }
+
+  // DEV DEPENDENCIES
+  packageDevDependencies.push({ package: "@babel/core", version: "^7" });
+  packageDevDependencies.push({ package: "@rollup/plugin-commonjs", version: "^28" });
+  packageDevDependencies.push({ package: "@rollup/plugin-node-resolve", version: "^16" });
+  packageDevDependencies.push({ package: "@rollup/plugin-replace", version: "^6" });
+  packageDevDependencies.push({ package: "rollup", version: "^4" });
+  if (atom.doc.features.dts_enabled) {
+    packageDevDependencies.push({ package: "rollup-plugin-dts", version: "^6" });
+  }
+  packageDevDependencies.push({ package: "rollup-plugin-peer-deps-external", version: "^2" });
+  packageDevDependencies.push({ package: "@rollup/plugin-alias", version: "^5" });
+  packageDevDependencies.push({ package: "fs-extra", version: "^11" });
+
+  if (atom.doc.features.babel_enabled) {
+    packageDevDependencies.push({ package: "@rollup/plugin-babel", version: "^6" });
+    packageDevDependencies.push({ package: "@babel/preset-env", version: "^7" });
+    packageDevDependencies.push({ package: "@babel/preset-react", version: "^7" });
+
+    atom.doc.features.babel?.options?.plugins?.forEach(plugin => {
+      const pluginName = plugin[0];
+      switch (pluginName) {
+        case '@babel/plugin-proposal-decorators':
+          packageDevDependencies.push({ package: "@babel/plugin-proposal-decorators", version: "^7" });
+          break;
+        case '@babel/plugin-proposal-class-properties':
+          packageDevDependencies.push({ package: "@babel/plugin-proposal-class-properties", version: "^7" });
+          break;
+        case '@babel/plugin-proposal-private-methods':
+          packageDevDependencies.push({ package: "@babel/plugin-proposal-private-methods", version: "^7" });
+          break;
+        case '@babel/plugin-proposal-private-property-in-object':
+          packageDevDependencies.push({ package: "@babel/plugin-proposal-private-property-in-object", version: "^7" });
+          break;
+        case '@babel/plugin-proposal-optional-chaining':
+          packageDevDependencies.push({ package: "@babel/plugin-proposal-optional-chaining", version: "^7" });
+          break;
+      }
+    });
+  }
+
+  packageDevDependencies.push({ package: "@fnet/rollup-plugin-delete", version: "0.1.10" });
+
+  if (atom.doc.features.browsersync_enabled) {
+    packageDevDependencies.push({ package: "@fnet/rollup-plugin-browsersync", version: "0.1.11" });
+  }
+}
+
+async function initPythonDependencies({ atom, packageDependencies, packageDevDependencies, setProgress }) {
+  setProgress('Initializing dependencies');
+}
+
+async function createApp({ atom, setProgress, context, packageDependencies }) {
+
+  if (atom.doc.features.app.enabled !== true) return;
+
+  await setProgress({ message: "Creating app folder" });
+
+  const templateContext = {
+    atom: atom,
+    packageDependencies: packageDependencies,
+    ts: Date.now()
+  };
+  const templateDir = context.templateDir;
+
+  const outDir = path.resolve(context.projectDir, `src/app`);
+  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+
+  let pattern = ["index.js.njk"];
+  if (atom.doc.features.app.html !== false) pattern.push("index.html.njk");
+  await fnetRender({
+    pattern: pattern,
+    dir: path.resolve(templateDir, `src/app`),
+    outDir,
+    context: templateContext,
+  });
+}
+
+async function pickNpmVersions({ projectDir, name, setProgress, count = 1 }) {
+
+  let npmVersions;
+
+  const key = ['npm-pick-versions', name, count];
+  const cacheKey = hash(key);
+  const cacheDir = path.join(projectDir, '.cache');
+  const cacheFile = path.join(cacheDir, cacheKey + '.json');
+
+  if (fs.existsSync(cacheFile)) {
+    if (setProgress) setProgress(`Picking npm version of ${name} from cache ...`);
+    npmVersions = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+  }
+  else {
+    if (setProgress) setProgress(`Picking npm version of ${name} ...`);
+    npmVersions = await fnetPickNpmVersions({ name: name, count });
+    fs.mkdirSync(cacheDir, { recursive: true });
+    fs.writeFileSync(cacheFile, JSON.stringify(npmVersions), 'utf8');
+  }
+
+  return npmVersions;
+}
+
+async function createPackageJson({ atom, context, packageDependencies, packageDevDependencies, setProgress }) {
+
+  await setProgress({ message: "Creating package.json." });
+
+  // move dev dependencies in packageDependencies to packageDevDependencies
+  const devPackages = packageDependencies.filter(w => w.dev === true);
+  devPackages.forEach(w => {
+    if (!packageDevDependencies.find(x => x.package === w.package)) {
+      packageDevDependencies.push(w);
+    }
+
+    const index = packageDependencies.findIndex(x => x.package === w.package);
+    packageDependencies.splice(index, 1);
+  });
+
+  // TODO: PEER DEPENDENCIES
+  // REACT CHECK
+  const reactDep = packageDependencies.find(w => w.package === "react");
+  const reactDomDep = packageDependencies.find(w => w.package === "react-dom");
+
+  if (reactDep && !reactDomDep)
+    packageDependencies.push({ package: "react-dom", version: reactDep.version });
+  else if (reactDep && reactDomDep)
+    reactDomDep.version = reactDep.version;
+
+  // EMOTION CHECK
+  if (reactDep && atom.doc.features.react_version >= 17) {
+    if (!packageDependencies.find(w => w.package === '@emotion/react'))
+      packageDependencies.push({ package: "@emotion/react", version: "^11" });
+    if (!packageDependencies.find(w => w.package === '@emotion/styled'))
+      packageDependencies.push({ package: "@emotion/styled", version: "^11" });
+  }
+
+  const checkFiles = [];
+
+  if (atom.doc.features.app.enabled === true) {
+    checkFiles.push({
+      file: path.resolve(context.projectDir, `src/app/index.js`),
+      dev: atom.doc.features.app.dev !== false
+    });
+  }
+
+  if (atom.doc.features.cli.enabled === true) {
+    checkFiles.push({
+      file: path.resolve(context.projectDir, `src/cli/index.js`),
+      dev: atom.doc.features.cli.dev !== false
+    });
+  }
+
+  for await (const checkFile of checkFiles) {
+    const srcFilePath = checkFile.file;
+    if (!fs.existsSync(srcFilePath)) throw new Error(`App file not found: ${srcFilePath}`);
+
+    const parsedImports = await fnetParseImports({ file: srcFilePath, recursive: true });
+    const targetImports = parsedImports.all;
+    
+    for await (const parsedImport of targetImports) {
+      if (parsedImport.type !== 'npm') continue;
+
+      if (packageDependencies.find(w => w.package === parsedImport.package)) continue;
+      if (packageDevDependencies.find(w => w.package === parsedImport.package)) continue;
+
+      const npmVersions = await pickNpmVersions({
+        name: parsedImport.package,
+        projectDir: context.projectDir,
+        setProgress
+      });
+
+      const targetDependencies = checkFile.dev === true ? packageDevDependencies : packageDependencies;
+      targetDependencies.push({
+        package: parsedImport.package,
+        subpath: parsedImport.subpath,
+        version: npmVersions.minorRange,
+        type: "npm"
+      });
+    }
+  }
+
+  const templateContext = {
+    atom: atom,
+    packageDependencies: packageDependencies,
+    packageDevDependencies: packageDevDependencies
+  };
+
+  const templateDir = context.templateCommonDir;
+  const template = nunjucks.compile(
+    fs.readFileSync(path.resolve(templateDir, `package.json.njk`), "utf8"),
+    nunjucks.configure(templateDir)
+  );
+
+  const templateRender = template.render(templateContext);
+
+  const projectDir = context.projectDir;
+  const filePath = path.resolve(projectDir, `package.json`);
+  fs.writeFileSync(filePath, templateRender, 'utf8');
+
+  // copy fnet files to projectDir
+  const fnetSrcDir = path.resolve(context.project.projectDir, 'fnet');
+  if (fs.existsSync(fnetSrcDir)) {
+    const fnetDestDir = path.resolve(context.projectDir, 'fnet');
+    if (!fs.existsSync(fnetDestDir)) {
+      fs.mkdirSync(fnetDestDir);
+    }
+
+    const fnetFiles = fs.readdirSync(fnetSrcDir);
+    for (const fnetFile of fnetFiles) {
+      const fnetFilePath = path.resolve(fnetSrcDir, fnetFile);
+      if (!fs.lstatSync(fnetFilePath).isFile()) continue;
+      const targetFilePath = path.resolve(fnetDestDir, fnetFile);
+      fs.copyFileSync(fnetFilePath, targetFilePath);
+    }
+  }
+}
+
+async function createCli({ atom, setProgress, context, packageDependencies }) {
+
+    if (atom.doc.features.cli.enabled !== true) return;
+
+    await setProgress({ message: "Creating cli." });
+
+    const templateContext = {
+        atom: atom,
+        packageDependencies: packageDependencies
+    };
+
+    const templateDir = context.templateDir;
+
+    const outDir = path.resolve(context.projectDir, `src/cli`);
+    if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+
+    await fnetRender({
+        pattern: ["index.js.njk"],
+        dir: path.resolve(templateDir, `src/cli`),
+        outDir,
+        context: templateContext,
+    });
+}
+
+async function createCliPython({ atom, setProgress, context, packageDependencies }) {
+
+  if (atom.doc.features.cli.enabled !== true) return;
+
+  await setProgress({ message: "Creating cli." });
+
+  const templateContext = {
+    atom: atom,
+    packageDependencies: packageDependencies
+  };
+
+  const templateDir = context.templateDir;
+
+  const outDir = path.join(context.projectDir, 'src', 'cli');
+  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+
+  await fnetRender({
+    pattern: ["index.py.njk", "__init__.py.njk"],
+    dir: path.join(templateDir, 'src', 'cli'),
+    outDir,
+    context: templateContext,
+  });
+}
+
+async function createRollup({ atom, setProgress, context, packageDependencies }) {
+
+  await setProgress({ message: "Creating rollup file." });
+
+  const templateContext = {
+    atom,
+    packageDependencies
+  };
+
+  // SCAN ENTRY FILE
+  const entryFile = path.resolve(context.projectDir, "src", "default/index.js");
+  if (!fs.existsSync(entryFile)) throw new Error(`Entry file not found: ${entryFile}`);
+
+  const packages = await fnetParseImports({ file: entryFile, recursive: true });
+
+  // ADD NODE BUILTINS
+  const nodeBuiltins = packages.all.filter(p => p.type === "node").map(p => p.path);
+  const rollup_output = atom.doc.features.rollup_output;
+  const keys = Object.keys(rollup_output);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const value = rollup_output[key];
+    if (value.browser === true) {
+      if (nodeBuiltins.length > 0) {
+
+        // GLOBALS
+        value.globals_enabled = true;
+        value.globals = value.globals || [];
+        value.globals = value.globals.concat(nodeBuiltins.map(nodeBuiltin => { return { key: nodeBuiltin, value: nodeBuiltin } }));
+
+        // ALIAS
+        value.alias_enabled = true;
+        value.alias = value.alias || {};
+        value.alias.entries = value.alias.entries || {};
+        for (let j = 0; j < nodeBuiltins.length; j++) {
+          const nodeBuiltin = nodeBuiltins[j];
+          value.alias.entries[nodeBuiltin] = `node:${nodeBuiltin}`;
+          value.alias.entries[`node:${nodeBuiltin}`] = nodeBuiltin;
+        }
+
+        // EXTERNAL
+        value.external_enabled = true;
+        value.external = value.external || [];
+        value.external = value.external.concat(nodeBuiltins);
+      }
+    }
+  }
+
+  // RENDER TEMPLATE rollup.config.js.njk
+  const templateDir = context.templateCommonDir;
+  let template = nunjucks.compile(
+    fs.readFileSync(path.resolve(templateDir, `rollup.config.mjs.njk`), "utf8"),
+    nunjucks.configure(templateDir)
+  );
+
+  let templateRender = template.render(templateContext);
+
+  const projectDir = context.projectDir;
+  let filePath = path.resolve(projectDir, `rollup.config.mjs`);
+  fs.writeFileSync(filePath, templateRender, 'utf8');
+
+
+  // // RENDER TEMPLATE rollup.config.mjs.njk
+  // // check file if exists
+  // if (fs.existsSync(path.resolve(templateDir, `rollup.config.mjs.njk`))) {
+  //   template = nunjucks.compile(
+  //     fs.readFileSync(path.resolve(templateDir, `rollup.config.mjs.njk`), "utf8"),
+  //     nunjucks.configure(templateDir)
+  //   );
+
+  //   templateRender = template.render(templateContext);
+
+  //   filePath = path.resolve(projectDir, `rollup.config.mjs`);
+  //   fs.writeFileSync(filePath, templateRender, 'utf8');
+  // };
+}
+
+async function createToYargs({ atom, setProgress, context, njEnv }) {
+
+  if (atom.doc.features.cli.enabled !== true) return;
+
+  await setProgress({ message: "Creating yargs." });
+
+  let schema = {};
+  const imports = [];
+
+  const input = atom.doc.input;
+  if (input) {
+    schema = atom.doc.input;
+  }
+  else {
+    schema = {
+      type: "object",
+      properties: {},
+      required: []
+    };
+  }
+  if (atom.doc.features.cli.fargs && atom.doc.features.cli.fargs?.enabled !== false) {
+
+    const fargsOptions = atom.doc.features.cli.fargs;
+
+    const fargs = { type: "string", description: "Config name to load args", hidden: false };
+    const ftag = { type: "array", description: "Tags to filter the config", hidden: false };
+
+    if (Reflect.has(fargsOptions, 'default')) fargs.default = fargsOptions.default;
+    // if (Reflect.has(fargsOptions, 'describe') || Reflect.has(fargsOptions, 'description')) fargs.describe = fargsOptions.describe || fargsOptions.description;
+    // if (Reflect.has(fargsOptions, 'choices')) fargs.choices = fargsOptions.choices;
+
+    if (schema.properties) {
+      schema.properties["fargs"] = fargs;
+      schema.properties["ftag"] = ftag;
+    }
+  }
+
+  const templateContext = { options: schema, imports, atom: atom };
+
+  const templateDir = context.templateDir;
+  const template = nunjucks.compile(
+    fs.readFileSync(path.resolve(templateDir, `src/default/to.args.js.njk`), "utf8"),
+    njEnv
+  );
+
+  const templateRender = template.render(templateContext);
+
+  const projectDir = context.projectDir;
+  const filePath = path.resolve(projectDir, `src/default/to.args.js`);
+  fs.writeFileSync(filePath, templateRender, 'utf8');
+
+  const ajv = new Ajv({
+    allErrors: true,
+    useDefaults: true,
+    formats: { },
+    strict: false,
+    code: {
+      esm: true,
+      lines: true,
+      optimize: false,
+      source: true
+    },
+  });
+  
+  addFormats(ajv);
+  const validate = ajv.compile(schema);
+  const validateCode = standaloneCode(ajv, validate);
+  
+  fs.writeFileSync(path.resolve(projectDir, `src/default/validate_input.js`), validateCode, 'utf8');
+}
+
+async function createGitIgnore({ atom, setProgress, context, packageDependencies }) {
+    await setProgress({ message: "Creating .gitignore" });
+
+    const templateContext = {
+        atom: atom,
+        packageDependencies:
+            packageDependencies
+    };
+
+    const templateDir = context.templateCommonDir;
+    const template = nunjucks.compile(
+        fs.readFileSync(path.resolve(templateDir, `.gitignore.njk`), "utf8"),
+        nunjucks.configure(templateDir)
+    );
+
+    const templateRender = template.render(templateContext);
+
+    const projectDir = context.projectDir;
+    const filePath = path.resolve(projectDir, `.gitignore`);
+    fs.writeFileSync(filePath, templateRender, 'utf8');    
+}
+
+async function createTsConfig({ atom, setProgress, context, packageDependencies }) {
+    await setProgress({ message: "Creating tsconfig.json." });
+
+    const templateContext = {
+        atom: atom,
+        packageDependencies:
+            packageDependencies
+    };
+
+    const templateDir = context.templateCommonDir;
+    const template = nunjucks.compile(
+        fs.readFileSync(path.resolve(templateDir, `tsconfig.json.njk`), "utf8"),
+        nunjucks.configure(templateDir)
+    );
+
+    const templateRender = template.render(templateContext);
+
+    const projectDir = context.projectDir;
+    const filePath = path.resolve(projectDir, `tsconfig.json`);
+    fs.writeFileSync(filePath, templateRender, 'utf8');
+}
+
+async function createProjectReadme({ atom, context, setProgress, Atom }) {
+
+  const fileBase = `readme.md`;
+  const message = `Creating ${fileBase}`;
+
+  await setProgress({ message: message });
+
+  if (context.project?.readme) {
+
+    const projectDir = context.projectDir;
+
+    const templateContext = {
+      content: context.project.readme.doc.content
+    };
+
+    const howtoPath = path.resolve(context.project.projectDir, `fnet/how-to.md`);
+    if (fs.existsSync(howtoPath)) {
+      const howtoContent = fs.readFileSync(howtoPath, 'utf8');
+      templateContext.howto = howtoContent;
+    }
+
+    const inputSchemaPath = path.resolve(context.project.projectDir, `fnet/input.yaml`);
+    if (fs.existsSync(inputSchemaPath)) {
+      const yaml = await fnetYaml({ file: inputSchemaPath, tags: context.tags });
+      templateContext.input = yaml.content;
+    }
+
+    const templateDir = context.templateCommonDir;
+    const template = nunjucks.compile(
+      fs.readFileSync(path.resolve(templateDir, `${fileBase}.njk`), "utf8"),
+      nunjucks.configure(templateDir)
+    );
+
+    const templateRender = template.render(templateContext);
+
+    const filePath = path.resolve(projectDir, `${fileBase}`);
+    fs.writeFileSync(filePath, templateRender, 'utf8');
+  }
+  else if (atom.id) {
+    const wiki = await Atom.first({ type: "wiki", parent_id: atom.id });
+
+    if (!wiki || wiki.doc?.["content-type"] !== 'markdown') return;
+
+    const { content: main, ...content } = wiki.doc;
+
+    const templateContext = { content: main };
+
+    const templateDir = context.templateCommonDir;
+    const template = nunjucks.compile(
+      fs.readFileSync(path.resolve(templateDir, `${fileBase}.njk`), "utf8"),
+      nunjucks.configure(templateDir)
+    );
+
+    const templateRender = template.render(templateContext);
+
+    const projectDir = context.projectDir;
+    const filePath = path.resolve(projectDir, `${fileBase}`);
+    fs.writeFileSync(filePath, templateRender, 'utf8');
+  }
+}
+
+async function formatFiles({ setProgress, context }) {
+
+  const projectDir = context.projectDir;
+
+  await setProgress({ message: "Prettifiying source files." });
+
+  let srcDir = path$1.join("src","**", "*");
+
+  await fnetShellFlow({
+    commands: {
+      steps: [`prettier --write ${srcDir} *.{js,cjs,mjs,json,yaml,html} --no-error-on-unmatched-pattern`],
+      wdir: projectDir,
+    }
+  });
+}
+
+async function createDts({ atom, setProgress, context }) {
+
+    if(!atom.doc.features.dts_enabled) return;
+    
+    const projectDir = context.projectDir;
+
+    await setProgress({ message: "Creating .d.ts" });
+    const result = await fnetShellJs(`tsc`, { cwd: projectDir });
+    if (result.code !== 0) throw new Error('Couldnt create .d.ts files.');
+}
+
+var which = (binName) => {
+  const pathEnv = process.env.PATH || '';
+  const pathExt = process.platform === 'win32'
+    ? (process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';')
+    : [''];
+
+  const paths = pathEnv.split(delimiter);
+
+  for (const dir of paths) {
+    for (const ext of pathExt) {
+      const fullPath = join(dir, process.platform === 'win32' ? binName + ext : binName);
+      if (existsSync(fullPath)) {
+        return fullPath;
+      }
+    }
+  }
+
+  return null;
+};
+
+async function installNpmPackages({ setProgress, atom, context }) {
+
+  const projectDir = context.projectDir;
+
+  await setProgress({ message: "Installing npm packages." });
+  const packageManager = which('bun') ? 'bun' : 'npm';
+  const result = await fnetShellJs(`${packageManager} install ${atom.doc.features.npm_install_flags}`, { cwd: projectDir });
+  if (result.code !== 0) throw new Error('Couldnt install npm packages.');
+}
+
+async function installPythonPackages(args) {
+
+  const { setProgress, atom, context } = args;
+
+  setProgress({ message: 'Installing Python packages' });
+
+  const projectDir = context.projectDir;
+
+  const parserEnv = await fnetAutoCondaEnv({
+    pythonVersion: "3.12",
+    packages: [{ package: "fnet-import-parser", version: "0.1.9" }]
+  });
+
+  const { errors, result } = await parserEnv.runBin('fnet_import_parser', [
+    "--entry_file", path.join(projectDir, 'src', 'default', 'index.py')
+  ], { captureName: 'result' });
+
+  if (errors) throw new Error(errors.format());
+
+  const parsedImports = JSON.parse(result.items[0].stdout);
+  const detectedDependencies = parsedImports.required['third-party']?.map(pkg => {
+    return {
+      package: pkg.metadata?.package || pkg.path,
+      version: pkg.metadata?.version || undefined,
+      channel: pkg.metadata?.channel || undefined
+    }
+  }) || [];
+
+  // console.log(detectedDependencies);
+
+  const userDependencies = atom.doc.dependencies || [];
+
+  // expand userDependencies with detectedDependencies if not already present
+  for (const dep of detectedDependencies) {
+    if (!userDependencies.some(userDep => userDep.package === dep.package)) {
+      userDependencies.push(dep);
+    }
+  }
+
+  // project workspace
+  const condaDir = path.join(projectDir, '.conda');
+
+  const pythonEnv = await fnetAutoCondaEnv({
+    // name: atom.doc.name,
+    envDir: condaDir,
+    pythonVersion: atom.doc.features.runtime.version || "3.12",
+    packages: userDependencies
+  });
+
+  context.pythonEnv = pythonEnv;
+
+  args.packageDependencies = userDependencies;
+
+  // TODO: move to a separate plugin
+  const dirs = atom.doc.features.render?.dirs || [];
+
+  for (const dir of dirs) {
+    dir.dir = path.resolve(projectDir, dir.dir);
+    dir.outDir = path.resolve(projectDir, dir.outDir);
+    await fnetRender(dir);
+  }
+
+  // TODO: move to a separate plugin
+  let tmplCtx = { params: {} };
+  tmplCtx.params.package_name = atom.doc.name;
+  tmplCtx.params.version = "0.1.0";
+  tmplCtx.params.bin_name = atom.doc.name;
+  tmplCtx.params.python_requires = atom.doc.features.runtime.version || ">=3.12";
+  tmplCtx.params.dependencies = userDependencies;
+  tmplCtx.params.scripts = JSON.stringify({
+    "cli": `PYTHONPATH='${path.join('src')}' '${path.relative(context.projectDir, pythonEnv.pythonBin)}' '${path.join('src', 'cli', 'index.py')}'`
+  });
+
+  await fnetRender({
+    pattern: ["setup.py.njk", "package.json.njk", "pyproject.toml.njk"],
+    dir: context.templateDir,
+    outDir: context.projectDir,
+    context: tmplCtx,
+  });
+
+  // await pythonEnv.runPip(["install", "-e", '.'], { wdir: context.projectDir });
+}
+
+async function runNpmBuild({ setProgress, context }) {
+
+    const projectDir = context.projectDir;
+
+    await setProgress({ message: "Building main project." });
+    const result = await fnetShellJs(`npm run build`, { cwd: projectDir });
+    if (result.code !== 0) throw new Error('Couldnt build project.');
+}
+
+var deployTo = async (apiContext) => {
+
+  // Destructure the apiContext to get needed variables
+  const {
+    atom,
+    packageDependencies,
+    context,
+    deploymentProjectTarget,
+    setProgress,
+    deploymentProject,
+    yamlTarget
+  } = apiContext;
+
+  // Early exit if the target is not enabled
+  if (deploymentProjectTarget.enabled !== true) return;
+
+  const type = deploymentProjectTarget.type;
+
+  try {
+    // Handle the first set of deployment types
+    if (type === "lib") {
+      await (await import('./index.f798DPwo.js')).default({ ...apiContext });
+    } else if (type === "red") {
+      await (await import('./index.CX8eMqfH.js')).default({ ...apiContext });
+    } else if (type === "npm") {
+      await (await import('./index.BNSTS5o6.js')).default({ ...apiContext });
+    } else if (type === "gcs") {
+      await (await import('./index.BMsD46br.js')).default({ ...apiContext });
+    } else if (type === "gitlab") {
+      await (await import('./index.Dd0lngp8.js')).default({ ...apiContext });
+    } else if (type === "fnet-package") {
+      await (await import('./index.C9zKEF61.js')).default({ ...apiContext });
+    } else if (type === "fnet-form") {
+      await (await import('./index.BUhoGq-h.js')).default({ ...apiContext });
+    } else if (type === "fnet-node") {
+      await (await import('./index.B6WHm9H0.js')).default({ ...apiContext });
+    } else if (type === "fnet-flow") {
+      await (await import('./index.D61MduW1.js')).default({ ...apiContext });
+    }
+    // Handle the second set of deployment types
+    else if (type === 'nextjs') {
+      await (await import('./index.DqwVukIB.js')).default({
+        atom,
+        target: deploymentProjectTarget,
+        onProgress: setProgress,
+        projectDir: context.projectDir,
+        dependencies: packageDependencies,
+        context,
+        yamlTarget
+      });
+      deploymentProject.isDirty = true;
+    } else if (type === 'webos') {
+      await (await import('./index.MWHLt6g3.js')).default({
+        atom,
+        target: deploymentProjectTarget,
+        onProgress: setProgress,
+        projectDir: context.projectDir,
+        dependencies: packageDependencies,
+        context,
+        yamlTarget
+      });
+      deploymentProject.isDirty = true;
+    } else if (type === 'electron') {
+      await (await import('./index.CQNYMi1Z.js')).default({
+        atom,
+        target: deploymentProjectTarget,
+        onProgress: setProgress,
+        projectDir: context.projectDir,
+        dependencies: packageDependencies,
+        context,
+        yamlTarget
+      });
+      deploymentProject.isDirty = true;
+    } else if (type === 'docker') {
+      await (await import('./index.B5vpZn1Z.js')).default({
+        atom,
+        target: deploymentProjectTarget,
+        onProgress: setProgress,
+        projectDir: context.projectDir,
+        dependencies: packageDependencies,
+        context,
+        yamlTarget
+      });
+      deploymentProject.isDirty = true;
+    } else if (type === 'ios') {
+      await (await import('./index.D2kFuxXo.js')).default({
+        atom,
+        target: deploymentProjectTarget,
+        onProgress: setProgress,
+        projectDir: context.projectDir,
+        dependencies: packageDependencies,
+        context,
+        yamlTarget
+      });
+      deploymentProject.isDirty = true;
+    } else if (type === 'macos') {
+      await (await import('./index.Ce8sTnt_.js')).default({
+        atom,
+        target: deploymentProjectTarget,
+        onProgress: setProgress,
+        projectDir: context.projectDir,
+        dependencies: packageDependencies,
+        context,
+        yamlTarget
+      });
+      deploymentProject.isDirty = true;
+    } else if (type === 'rust') {
+      await (await import('./index.BjzEMdm1.js')).default({
+        atom,
+        target: deploymentProjectTarget,
+        onProgress: setProgress,
+        projectDir: context.projectDir,
+        dependencies: packageDependencies,
+        context,
+        yamlTarget
+      });
+      deploymentProject.isDirty = true;
+    } else if (type === 'pypi') {
+      await (await import('./index.j5JP-zGw.js')).default({
+        atom,
+        target: deploymentProjectTarget,
+        onProgress: setProgress,
+        projectDir: context.projectDir,
+        dependencies: packageDependencies,
+        context,
+        yamlTarget
+      });
+      deploymentProject.isDirty = true;
+    } else {
+      console.warn(`No deployer found for type: ${type}`);
+      return;
+    }
+  } catch (error) {
+    // Add error handling for require failures or execution errors
+    console.error(`Error during deployment for type "${type}":`, error);
+    // Re-throw the error or handle it as appropriate for your application
+    throw error;
+  }
+};
+
+class Builder {
+
+  #auth;
+  #context;
+  #atom;
+  #njEnv;
+  #libs;
+  #packageDependencies;
+  #packageDevDependencies;
+  #atomAccessToken;
+  #buildId;
+  #buildKey;
+  #protocol;
+  #atomConfig;
+
+  #mode;
+  #fileMode;
+  #buildMode;
+  #deployMode;
+  #apiContext;
+
+  constructor(context) {
+    this.#auth = new Auth();
+    this.#context = context;
+    this.#packageDependencies = [];
+    this.#packageDevDependencies = [];
+
+    this._expire_ttl = 3600; // 1-hour
+    this._expire_ttl_short = 300; // 5-minutes
+
+    this.#apiContext = {
+      packageDependencies: this.#packageDependencies,
+      packageDevDependencies: this.#packageDevDependencies,
+      setProgress: this.setProgress.bind(this),
+      context: this.#context,
+      Atom,
+      registerToPackageManager: this.registerToPackageManager.bind(this)
+    };
+  }
+
+  async _cache_set(key, value, expire_ttl) {
+    if (!this._redis_client) return;
+
+    await this._redis_client.SETEX(
+      key,
+      expire_ttl || this._expire_ttl,
+      JSON.stringify(value),
+    ).catch(console.error);
+  }
+
+
+
+  async initAuth() {
+    if (!this.#context.id) return;
+    this.#atomAccessToken = await this.#auth.init({ config: this.#atomConfig });
+    this.#apiContext.atomAccessToken = this.#atomAccessToken;
+  }
+
+  async initLibrary() {
+    const libraryId = this.#context.id;
+    this.#atom = this.#context.project?.libraryAtom || await Atom.get({ id: libraryId });
+    let bundleName = this.#atom.doc.bundleName;
+    bundleName = bundleName || (this.#atom.doc.name || "").toUpperCase().replace(/[^A-Z0-9]/g, "_");
+    this.#atom.doc.bundleName = bundleName;
+    this.#atom.type = this.#atom.type || "workflow.lib";
+    this.#apiContext.atom = this.#atom;
+  }
+
+  async initLibraryDir() {
+
+    this.setProgress({ message: "Initializing library directory." });
+
+    const projectDir = this.#context.projectDir;
+
+    this.setProgress({ message: "Cleaning project directory." });
+
+    const assets = fnetListFiles({ dir: projectDir, ignore: ['.cache', 'node_modules', '.conda'], absolute: true });
+    for (const asset of assets) {
+      fs.rmSync(asset, { recursive: true, force: true });
+    }
+
+    this.setProgress({ message: "Creating project directory." });
+
+    // .
+    let target = projectDir;
+    if (!fs.existsSync(target)) {
+      fs.mkdirSync(target, { recursive: true });
+    }
+
+    // src
+    target = path.join(projectDir, "src");
+
+    if (!fs.existsSync(target)) {
+      fs.mkdirSync(target, { recursive: true });
+    }
+
+    // default
+    target = path.join(projectDir, "src", "default");
+    if (!fs.existsSync()) {
+      fs.mkdirSync(target, { recursive: true });
+    }
+  }
+
+
+  async initLibraryDirPython() {
+    this.setProgress({ message: "Initializing library directory." });
+
+    const projectDir = this.#context.projectDir;
+
+    this.setProgress({ message: "Cleaning project directory." });
+
+    const assets = fnetListFiles({ dir: projectDir, ignore: ['.cache', 'node_modules', '.conda'], absolute: true });
+    for (const asset of assets) {
+      fs.rmSync(asset, { recursive: true, force: true });
+    }
+
+    this.setProgress({ message: "Creating project directory." });
+
+    let target = projectDir;
+    if (!fs.existsSync(target)) {
+      fs.mkdirSync(target, { recursive: true });
+    }
+
+    target = path.join(projectDir, 'src');
+    if (!fs.existsSync(target)) {
+      fs.mkdirSync(target, { recursive: true });
+    }
+
+    target = path.join(projectDir, 'src', 'default');
+    const source = this.#context.projectSrcDir;
+
+    if (!fs.existsSync(target)) {
+      try {
+        if (os.platform() === 'win32') {
+          // Windows requires special handling
+          fs.symlinkSync(source, target, 'junction');
+        } else {
+          // For Unix-like systems
+          fs.symlinkSync(source, target, 'dir');
+        }
+      } catch (err) {
+        throw new Error(`Couldn't create symlink. Error: ${err.message}`);
+      }
+    }
+  }
+
+  async initNunjucks() {
+    this.setProgress({ message: "Initializing nunjucks." });
+
+    const templateDir = this.#context.templateDir;
+    this.#njEnv = nunjucks.configure(templateDir, { watch: false, dev: true });
+    this.#apiContext.njEnv = this.#njEnv;
+  }
+
+  async initLibs() {
+
+    this.setProgress({ message: "Initializing external libs." });
+
+    const libs = [{
+      name: this.#atom.doc.name,
+      type: "atom",
+      parent_id: this.#atom.parent_id
+    }];
+
+    this.#libs = libs;
+
+    await this.initAtomLibsAndDeps({ libs, packageDependencies: this.#packageDependencies });
+  }
+
+  async initLibsPython() {
+
+    this.setProgress({ message: "Initializing external libs." });
+
+    const atom = this.#atom;
+    atom.protocol = "local:";
+    atom.doc.dependencies = atom.doc.dependencies || [];
+    atom.name = atom.doc.name;
+
+    const libs = [{
+      name: this.#atom.doc.name,
+      type: "atom",
+      parent_id: this.#atom.parent_id,
+      atom
+    }];
+
+    this.#libs = libs;
+  }
+
+  async initAtomLibsAndDeps({ libs, packageDependencies }) {
+    const atomLibRefs = libs.filter(w => w.type === 'atom');
+    for (let i = 0; i < atomLibRefs.length; i++) {
+      const atomLibRef = atomLibRefs[i];
+
+      const atomLib = await this.findAtomLibrary({ url: atomLibRef.name });
+      atomLibRef.atom = atomLib;
+
+      const packageDeps = atomLib.doc.dependencies?.filter(w => typeof w.repo === 'undefined' || w.repo === 'npm');
+      packageDeps?.forEach(npmDep => {
+        const found = packageDependencies.find(w => w.package === npmDep.package);
+        if (found) {
+          if (typeof npmDep.path === 'string') {
+            if (!(found.path || []).some(w => w === npmDep.path)) {
+              found.path = found.path || [];
+              found.path.push(npmDep.path);
+            }
+          }
+          else if (Array.isArray(npmDep.path)) {
+            npmDep.path.forEach(item => {
+              if (!(found.path || []).some(w => w === item)) {
+                found.path = found.path || [];
+                found.path.push(item);
+              }
+            });
+          }
+        }
+        else packageDependencies.push(npmDep);
+      });
+    }
+    packageDependencies.sort((a, b) => a.package?.localeCompare(b.package));
+  }
+
+  async findAtomLibrary({ url }) {
+    const parsedUrl = fnetParseNodeUrl({ url: url });
+    if (!parsedUrl) throw new Error(`Invalid package name: ${url}`);
+
+    if (!parsedUrl.protocol) parsedUrl.protocol = this.#protocol;
+
+    if (parsedUrl.protocol === 'ac:') {
+      const parts = parsedUrl.pathname.split('/');
+      if (parts.length === 1) {
+        return await Atom.first({ where: { name: url, parent_id: this.#atomConfig.env.ATOM_LIBRARIES_ID, type: "workflow.lib" } });
+      }
+
+      if (parts.length === 2) {
+        const folder = await Atom.first({ where: { name: parts[0], parent_id: this.#atomConfig.env.ATOM_LIBRARIES_ID, type: "folder" } });
+        return await Atom.first({ where: { name: parts[1], parent_id: folder.id, type: "workflow.lib" } });
+      }
+    }
+    else if (parsedUrl.protocol === 'local:') {
+
+      const atom = this.#atom;
+      atom.protocol = "local:";
+      atom.doc.dependencies = atom.doc.dependencies || [];
+      atom.name = atom.doc.name;
+
+      const srcFilePath = path.resolve(this.#context.projectSrcDir, `${'index'}.js`);
+      const parsedImports = await fnetParseImports({ file: srcFilePath, recursive: true });
+      const dependencies = atom.doc.dependencies;
+      const targetImports = parsedImports.all;
+
+      for await (const parsedImport of targetImports) {
+        if (parsedImport.type !== 'npm') continue;
+
+        if (dependencies.find(w => w.package === parsedImport.package)) continue;
+
+        const npmVersions = await pickNpmVersions({
+          name: parsedImport.package,
+          projectDir: this.#context.projectDir,
+          setProgress: this.#apiContext.setProgress
+        });
+
+        dependencies.push({
+          package: parsedImport.package,
+          subpath: parsedImport.subpath,
+          version: npmVersions.minorRange,
+          type: "npm"
+        });
+      }
+
+      return atom;
+    }
+  }
+
+  async createAtomLibFiles({ libs }) {
+    await this.setProgress({ message: "Creating external lib files." });
+
+    this.#atom.typesDir = './types';
+
+    const atomLibRefs = libs.filter(w => w.type === 'atom');
+    for (let i = 0; i < atomLibRefs.length; i++) {
+      const atomLibRef = atomLibRefs[i];
+
+      const atomLib = atomLibRef.atom;
+      const projectDir = this.#context.projectDir;
+      if (atomLib.protocol === 'local:') {
+        const srcFilePath = path.resolve(this.#context.projectSrcDir, `${atomLib.fileName || atomLib.name}.js`);
+        const relativePath = path.relative(path.join(this.#context.projectDir, 'src', 'default'), srcFilePath);
+
+        if (!fs.existsSync(srcFilePath)) {
+          fs.mkdirSync(path.dirname(srcFilePath), { recursive: true });
+          let template = 'export default async (args)=>{\n';
+          template += '}';
+          fs.writeFileSync(srcFilePath, template, 'utf8');
+        }
+
+        atomLib.relativePath = relativePath.split(path.sep).join('/');
+
+        this.#atom.typesDir = `./types/${path.basename(projectDir)}/src`;
+      }
+      else {
+        const atomLibPath = path.join(projectDir, 'src', 'libs', `${atomLib.id}.js`);
+        const content = atomLib.doc.contents?.find(w => w.format === 'esm') || atomLib.doc;
+        fs.writeFileSync(atomLibPath, content.content, 'utf8');
+      }
+    }
+  }
+
+  async createAtomLibFilesPython({ libs }) {
+    await this.setProgress({ message: "Creating external lib files." });
+
+    const atomLibRefs = libs.filter(w => w.type === 'atom');
+    for (let i = 0; i < atomLibRefs.length; i++) {
+      const atomLibRef = atomLibRefs[i];
+
+      const atomLib = atomLibRef.atom;
+      if (atomLib.protocol === 'local:') {
+        const srcFilePath = path.resolve(this.#context.projectSrcDir, `${atomLib.fileName || atomLib.name}.py`);
+        if (!fs.existsSync(srcFilePath)) {
+          fs.mkdirSync(path.dirname(srcFilePath), { recursive: true });
+          let template = 'def default():\n';
+          template += '  print("Hello world!")\n';
+          fs.writeFileSync(srcFilePath, template, 'utf8');
+        }
+      }
+    }
+  }
+
+  async createEngine() {
+
+    await this.setProgress({ message: "Creating engine file." });
+
+    const libs = this.#libs.filter(w => w.type === 'atom');
+
+    const templateContext = { libs, libraryAtom: this.#atom, atom: this.#atom };
+
+    const templateDir = this.#context.templateDir;
+    const template = nunjucks.compile(
+      fs.readFileSync(path.resolve(templateDir, path.join('src', 'default', 'engine.js.njk')), "utf8"),
+      this.#njEnv
+    );
+
+    const templateRender = template.render(templateContext);
+
+    const projectDir = this.#context.projectDir;
+    const filePath = path.resolve(projectDir, path.join('src', 'default', 'index.js'));
+    fs.writeFileSync(filePath, templateRender, 'utf8');
+  }
+
+  async createProjectYaml() {
+
+    const fileBase = `node.yaml`;
+    const message = `Creating ${fileBase}`;
+
+    await this.setProgress({ message: message });
+
+    const { content: main, ...content } = this.#atom.doc;
+
+    const templateContext = { content: yaml.stringify(content) };
+
+    const templateDir = this.#context.templateDir;
+    const template = nunjucks.compile(
+      fs.readFileSync(path.resolve(templateDir, `${fileBase}.njk`), "utf8"),
+      this.#njEnv
+    );
+
+    const templateRender = template.render(templateContext);
+
+    const projectDir = this.#context.projectDir;
+    const filePath = path.resolve(projectDir, `${fileBase}`);
+    fs.writeFileSync(filePath, templateRender, 'utf8');
+  }
+
+  async deploy() {
+
+    await this.setProgress({ message: "Deploying." });
+
+    if (this.#context.project?.devops) {
+      const devopsProjects = [this.#context.project?.devops];
+      for (let i = 0; i < devopsProjects.length; i++) {
+        let deploymentProject = devopsProjects[i];
+        await this.deployProject({ deploymentProject });
+
+        if (deploymentProject.isDirty === true) {
+          await deploymentProject.save();
+        }
+      }
+
+    }
+    else if (this.#atom.id) {
+      const devopsProjects = await Atom.list({ type: "library.deploy", parent_id: this.#atom.id });
+      for (let i = 0; i < devopsProjects.length; i++) {
+        let deploymentProject = devopsProjects[i];
+        await this.deployProject({ deploymentProject });
+
+        if (deploymentProject.isDirty === true) {
+          deploymentProject = await Atom.update(deploymentProject, { id: deploymentProject.id });
+        }
+      }
+    }
+  }
+
+  async deployProject(context) {
+    const { deploymentProject } = context;
+    const { yamlDocument } = deploymentProject;
+
+    if (deploymentProject.doc.targets && Array.isArray(deploymentProject.doc.targets))
+      throw new Error("Deployment project targets are deprecated. Please update targets in the yaml file.");
+
+    const targetKeys = Object.keys(deploymentProject.doc || {});
+    const yamlTargets = yamlDocument || {};
+    for (let i = 0; i < targetKeys.length; i++) {
+      const deploymentProjectTarget = deploymentProject.doc[targetKeys[i]];
+      deploymentProjectTarget.name = targetKeys[i];
+      const yamlTarget = yamlTargets.get(targetKeys[i]);
+      await deployTo({ ...this.#apiContext, deploymentProject, deploymentProjectTarget, yamlTarget });
+    }
+  }
+
+  async registerToPackageManager(context) {
+    const { target, packageJSON } = context;
+
+    if (!this.#context.id) return;
+
+    // update
+    let packageAtom = await Atom.first({ name: target.params.name, parent_id: this.#atomConfig.env.ATOM_PACKAGES_ID });
+
+    if (!packageAtom) {
+      // create new
+      packageAtom = await Atom.create({
+        parent_id: this.#atomConfig.env.ATOM_PACKAGES_ID,
+        doc: {
+          name: target.params.name,
+          type: "pm",
+          versions: [{ v: packageJSON.version }]
+        }
+      });
+    }
+    else {
+      // update existing
+      packageAtom.doc.versions.splice(0, 0, { v: packageJSON.version });
+
+      await Atom.update(packageAtom, { id: packageAtom.id });
+    }
+  }
+
+  async setProgress(args) {
+
+    const message = typeof args === 'string' ? args : args?.message;
+
+    console.log(chalk.blue(message));
+
+    await this._cache_set(this.#buildKey, { status: "IN_PROGRESS", message });
+  }
+
+  async initNode() {
+    await initFeatures(this.#apiContext);
+    await initDependencies(this.#apiContext);
+    await this.initLibraryDir();
+    await this.initNunjucks();
+    await this.initLibs();
+  }
+
+  async initPython() {
+    await initPythonFeature(this.#apiContext);
+    await initPythonDependencies(this.#apiContext);
+    await this.initLibraryDirPython();
+    await this.initNunjucks();
+    await this.initLibsPython();
+  }
+
+  async nodeBuild() {
+    if (this.#fileMode) {
+      await this.createAtomLibFiles({ libs: this.#libs });
+      await this.createEngine();
+      await this.createProjectYaml();
+
+      await createProjectReadme(this.#apiContext);
+      await createTsConfig(this.#apiContext);
+      await createGitIgnore(this.#apiContext);
+      await createToYargs(this.#apiContext);
+      await createCli(this.#apiContext);
+      await createApp(this.#apiContext);
+      await createRollup(this.#apiContext);
+      await createPackageJson(this.#apiContext);
+
+      await formatFiles(this.#apiContext);
+
+      await createDts(this.#apiContext);
+
+      if (this.#buildMode) {
+
+        await installNpmPackages(this.#apiContext);
+        await runNpmBuild(this.#apiContext);
+
+        if (this.#deployMode)
+          await this.deploy();
+      }
+    }
+  }
+
+  async pythonBuild() {
+    if (this.#fileMode) {
+      await this.createAtomLibFilesPython({ libs: this.#libs });
+      // await this.createEngine();
+      await this.createProjectYaml();
+
+      await createProjectReadme(this.#apiContext);
+      // await createTsConfig(this.#apiContext);
+      await createGitIgnore(this.#apiContext);
+      // await createToYargs(this.#apiContext);
+      await createCliPython(this.#apiContext);
+      // await createApp(this.#apiContext);
+      // await createRollup(this.#apiContext);
+      // await createPackageJson(this.#apiContext);
+
+      // await formatFiles(this.#apiContext);
+
+      // await createDts(this.#apiContext);
+
+      if (this.#buildMode) {
+        await installPythonPackages(this.#apiContext);
+        // await runNpmBuild(this.#apiContext);
+
+        if (this.#deployMode)
+          await this.deploy();
+      }
+    }
+  }
+
+  async init() {
+
+    this._redis_client = await createRedisClient();
+
+    this.#buildId = this.#context.buildId || randomUUID();
+    this.#apiContext.buildId = this.#buildId;
+
+    this.#mode = this.#context.mode;
+    this.#fileMode = ['all', 'deploy', 'build', 'file'].includes(this.#mode);
+    this.#buildMode = ['all', 'deploy', 'build'].includes(this.#mode);
+    this.#deployMode = ['all', 'deploy'].includes(this.#mode);
+
+    this.#protocol = this.#context.protocol;
+    this.#buildKey = "BUILD:" + this.#buildId;
+
+    this.#atomConfig = (await fnetConfig({ optional: true, name: this.#context.atomConfig || "atom", dir: this.#context.projectDir, tags: this.#context.tags }))?.data;
+
+    try {
+      await this.setProgress({ message: "Initialization started." });
+
+      await this.initAuth();
+      await this.initLibrary();
+      if (this.#atom.doc.features.runtime.type === 'node')
+        await this.initNode();
+      else if (this.#atom.doc.features.runtime.type === 'python')
+        await this.initPython();
+    }
+    catch (error) {
+      await this._cache_set(this.#buildKey, { status: "FAILED", message: error?.message || error });
+      throw error;
+    }
+  }
+
+  async build() {
+    try {
+      if (this.#atom.doc.features.runtime.type === 'node')
+        await this.nodeBuild();
+      else if (this.#atom.doc.features.runtime.type === 'python')
+        await this.pythonBuild();
+
+      await this._cache_set(this.#buildKey, { status: "COMPLETED" });
+    }
+    catch (error) {
+      await this._cache_set(this.#buildKey, { status: "FAILED", message: error.message || error });
+      console.log(error);
+      throw error;
+    }
+  }
+}
+
+const __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
+
+function findNodeModules({ baseDir }) {
+
+  baseDir = baseDir || __dirname$1;
+
+  let currentDir = baseDir;
+
+  while (currentDir !== path.parse(currentDir).root) {
+    const potentialPath = path.join(currentDir, 'node_modules');
+
+    if (fs.existsSync(potentialPath)) {
+      return potentialPath;
+    }
+
+    currentDir = path.dirname(currentDir);
+  }
+
+  return null;
+}
+
+var version = "0.101.0";
+var pkg = {
+	version: version};
+
+const __dirname = path$1.dirname(fileURLToPath(import.meta.url));
+const cwd = process.cwd();
+
+// fnet env (Assuming this sets up environment variables based on redis config)
+fnetConfig({
+  name: ["redis"],
+  dir: cwd,
+  optional: true
+});
+
+const nodeModulesDir = findNodeModules({ baseDir: __dirname });
+const pathSeparator = process.platform === 'win32' ? ';' : ':';
+
+if (nodeModulesDir)
+  process.env.PATH = `${path$1.join(nodeModulesDir, '/.bin')}${pathSeparator}${process.env.PATH}`;
+
+// --- Commander Setup ---
+const program = new Command();
+
+program
+  .name('fnode') // Optional: Set the name for help messages
+  .version(pkg.version) // Set the version from package.json
+  .description('CLI tool for FlowNet node projects');
+
+// --- Create Command ---
+program
+  .command('create')
+  .description('Create flow node project')
+  .requiredOption('-n, --name <string>', 'Project name') // Required option
+  .addOption(new Option('-r, --runtime <type>', 'Runtime environment').choices(['node', 'python']).default('node')) // Option with choices and default
+  .option('--vscode', 'Open project in VSCode after creation', true) // Boolean option, default true
+  .option('--no-vscode', 'Do not open project in VSCode') // Commander automatically creates the negation
+  .action(async (options) => { // Handler receives options object
+    try {
+      const templateDir = path$1.resolve(nodeModulesDir, '@fnet/cli-project-node/dist/template/project');
+      const outDir = path$1.resolve(cwd, options.name); // Access options via options object
+      if (!fs$1.existsSync(outDir)) fs$1.mkdirSync(outDir);
+
+      await fnetRender({
+        dir: templateDir,
+        outDir,
+        context: {
+          name: options.name,
+          runtime: options.runtime,
+          platform: os$1.platform(),
+        },
+        copyUnmatchedAlso: true
+      });
+
+      let shellResult = await fnetShellJs(`fnode build`, { cwd: outDir });
+      if (shellResult.code !== 0) throw new Error('Failed to build project.');
+
+      if (which('git')) {
+        shellResult = await fnetShellJs(`git init --initial-branch=main`, { cwd: outDir });
+        if (shellResult.code !== 0) throw new Error('Failed to initialize git.');
+      }
+
+      // Check the boolean flag correctly
+      if (options.vscode && which('code')) {
+        shellResult = await fnetShellJs(`cd ${outDir} && code .`);
+        if (shellResult.code !== 0) throw new Error('Failed to open vscode.');
+      }
+
+      console.log('Creating project succeeded!');
+      process.exit(0);
+    } catch (error) {
+      console.error('Initialization failed!', error.message);
+      process.exit(1);
+    }
+  });
+
+// --- Project Command ---
+program
+  .command('project')
+  .description('Flow node project operations')
+  .option('-u, --update', 'Update project files from template', false) // Boolean option, default false
+  .action(async (options) => {
+    try {
+      const templateDir = path$1.resolve(nodeModulesDir, '@fnet/cli-project-node/dist/template/project');
+      const outDir = process.cwd();
+
+      // Pass options to createContext
+      const context = await createContext(options);
+
+      if (options.update) {
+        await fnetRender({
+          dir: templateDir,
+          outDir,
+          context: {
+            name: context.project.projectFileParsed.name,
+            runtime: context.project.runtime.type,
+            platform: os$1.platform(),
+          },
+          copyUnmatchedAlso: true
+        });
+
+        let shellResult = await fnetShellJs(`fnode build`, { cwd: outDir });
+        if (shellResult.code !== 0) throw new Error('Failed to build project.');
+
+        console.log('Updating project succeeded!');
+      } else {
+        console.log("Use 'fnode project --update' to update project files."); // Inform user if no action taken
+      }
+
+
+      process.exit(0);
+    } catch (error) {
+      console.error('Project command failed.', error.message);
+      process.exit(1);
+    }
+  });
+
+// --- Build Command ---
+program
+  .command('build')
+  .description('Build flow node project')
+  .option('--id <string>', 'Build identifier')
+  .option('--buildId <string>', 'Specific build ID (alias: bid)') // Alias needs manual handling if desired, or just use long form
+  .addOption(new Option('--mode <mode>', 'Build mode').choices(['all', 'file', 'build', 'deploy', 'bpmn']).default('build'))
+  .option('--ftag <tags...>', 'Filter tags (specify multiple times or space-separated)') // Array option
+  .action(async (options) => {
+    try {
+      // Pass options to createContext
+      const context = await createContext(options);
+      const builder = new Builder(context);
+      await builder.init();
+      await builder.build();
+
+      console.log('Building library succeeded!');
+      process.exit(0);
+    } catch (error) {
+      console.error('Building library failed!', error.message);
+      process.exit(1);
+    }
+  });
+
+
+// --- Deploy Command ---
+program
+  .command('deploy')
+  .description('Build and deploy flow node project')
+  .option('--id <string>', 'Build identifier')
+  .option('--buildId <string>', 'Specific build ID')
+  .option('--ftag <tags...>', 'Filter tags')
+  .action(async (options) => {
+    try {
+      // Pass options to createContext, overriding mode
+      const context = await createContext({ ...options, mode: "all" });
+      const builder = new Builder(context);
+      await builder.init();
+      await builder.build();
+
+      console.log('Building and deploying library succeeded!'); // Message updated
+      process.exit(0);
+    } catch (error) {
+      console.error('Building/deploying library failed!', error.message);
+      process.exit(1);
+    }
+  });
+
+
+// --- File Command ---
+program
+  .command('file')
+  .description('Just create files (part of build process)')
+  .option('--id <string>', 'Build identifier')
+  .option('--buildId <string>', 'Specific build ID')
+  .option('--ftag <tags...>', 'Filter tags')
+  .action(async (options) => {
+    try {
+      // Pass options to createContext, overriding mode
+      const context = await createContext({ ...options, mode: "file" });
+      const builder = new Builder(context);
+      await builder.init();
+      await builder.build();
+
+      console.log('Creating files succeeded!'); // Message updated
+      process.exit(0);
+    } catch (error) {
+      console.error('Creating files failed!', error.message);
+      process.exit(1);
+    }
+  });
+
+
+// --- Input Command ---
+program
+  .command('input')
+  .description('Create or modify an input config file')
+  .argument('[name]', 'Optional input configuration name (e.g., dev, prod)') // Positional argument
+  .action(async (name, options) => { // Handler receives positional args first, then options
+    try {
+      // Pass options and name to createContext
+      const context = await createContext({ ...options, name }); // Include name if needed by createContext
+      const { project } = context;
+      const { projectDir, projectFileParsed } = project;
+      const schema = projectFileParsed.input;
+      if (!schema) throw new Error('Config schema not found in project file.');
+
+      let configName = name; // Use the positional argument
+      if (!configName) {
+        const answers = await prompt({ type: 'input', name: 'inputName', message: 'Input name:', initial: 'dev' });
+        configName = answers.inputName;
+      }
+
+      const dotFnetDir = path$1.resolve(projectDir, '.fnet');
+      if (!fs$1.existsSync(dotFnetDir)) fs$1.mkdirSync(dotFnetDir);
+
+      const configFilePath = path$1.resolve(dotFnetDir, `${configName}.fnet`);
+      const exists = fs$1.existsSync(configFilePath);
+
+      const result = await fnetObjectFromSchema({ schema, format: "yaml", ref: exists ? configFilePath : undefined });
+      fs$1.writeFileSync(configFilePath, result);
+      console.log(`Input config '${configName}.fnet' ${exists ? 'updated' : 'created'}.`);
+    } catch (error) {
+      console.error(error.message);
+      process.exit(1);
+    }
+  });
+
+// --- Helper function for simple pass-through commands ---
+function bindSimpleContextCommand(prog, { name, bin, preArgs = [] }) {
+  const cmdName = name || bin;
+  prog
+    .command(cmdName, { isDefault: false, hidden: false }) // Explicitly define command
+    .description(`Run ${bin} ${preArgs.join(' ')} in project context. Pass arguments after '--'.`)
+    .argument('[command_args...]', `Arguments for ${bin}`) // Capture arguments
+    .allowUnknownOption() // Allow options meant for the sub-process
+    .action(async (command_args, options) => {
+      try {
+        // Pass command's own options (if any were defined) to createContext
+        const context = await createContext(options);
+        const { projectDir } = context;
+
+        // Use the captured arguments
+        const rawArgs = command_args;
+        console.log(rawArgs);
+
+        // Ensure bin exists? (Optional, spawn will fail anyway)
+        // const binPath = which(bin);
+        // if (!binPath) throw new Error(`Command not found: ${bin}`);
+
+        const subprocess = spawn(bin, [...preArgs, ...rawArgs], {
+          cwd: projectDir,
+          stdio: 'inherit',
+          shell: true // Keep shell true for convenience, though direct execution is safer
+        });
+
+        subprocess.on('close', (code) => {
+          process.exit(code);
+        });
+        subprocess.on('error', (err) => {
+          console.error(`Failed to start ${bin}:`, err);
+          process.exit(1);
+        });
+
+      } catch (error) {
+        console.error(error.message);
+        process.exit(1);
+      }
+    });
+}
+
+
+// --- Helper function for conda pass-through commands ---
+function bindCondaContextCommand(prog, { name, bin, preArgs = [] }) {
+  const cmdName = name || bin;
+  prog
+    .command(cmdName, { isDefault: false, hidden: false })
+    .description(`Run ${bin} ${preArgs.join(' ')} using project's conda env. Pass arguments after '--'.`)
+    .argument('[command_args...]', `Arguments for ${bin}`)
+    .allowUnknownOption()
+    .action(async (command_args, options) => {
+      try {
+        const context = await createContext(options);
+        const { projectDir } = context;
+
+        const binPath = path$1.join(projectDir, '.conda', 'bin', bin || name);
+        // Basic check if conda env seems present
+        if (!fs$1.existsSync(path$1.dirname(binPath))) {
+          throw new Error(`Conda environment not found in ${path$1.join(projectDir, '.conda')}. Did you initialize it?`);
+        }
+        if (!fs$1.existsSync(binPath)) {
+          throw new Error(`Command '${bin || name}' not found in conda environment: ${binPath}`);
+        }
+
+
+        const rawArgs = command_args; // Use captured args
+
+        const subprocess = spawn(binPath, [...preArgs, ...rawArgs], {
+          cwd: projectDir,
+          stdio: 'inherit',
+          shell: false, // Safer to run specific binary directly
+          env: {
+            ...process.env, // Inherit current env
+            "PYTHONPATH": projectDir // Add projectDir to PYTHONPATH
+          }
+        });
+
+        subprocess.on('close', (code) => {
+          process.exit(code);
+        });
+        subprocess.on('error', (err) => {
+          console.error(`Failed to start ${binPath}:`, err);
+          process.exit(1);
+        });
+
+      } catch (error) {
+        console.error(error.message);
+        process.exit(1);
+      }
+    });
+}
+
+
+// --- Helper function for "with" command ---
+function bindWithContextCommand(prog, { name, preArgs = [] }) { // Added prog parameter
+  prog
+    .command(name)
+    .description('Run a command with environment variables from a .fnet config file.')
+    .argument('<config>', 'Name of the .fnet config file (without extension)')
+    .argument('<command>', 'The command to execute')
+    .argument('[command_args...]', 'Arguments for the command')
+    .option('--ftag <tags...>', 'Filter tags for loading config') // Added ftag option for context creation
+    .allowUnknownOption() // Allow options intended for the sub-process
+    .action(async (configName, commandName, command_args, options) => { // Arguments come first
+      try {
+        // Pass the 'with' command's own options to createContext
+        const context = await createContext(options);
+        const { projectDir } = context;
+
+        // Load the specified .fnet config
+        const config = await fnetConfig({
+          name: configName,
+          dir: projectDir,
+          transferEnv: false, // Keep false as per original
+          optional: true,     // Keep true as per original
+          tags: context.tags  // Pass tags from context
+        });
+        const env = config?.data?.env || {}; // Default to empty object if not found
+
+        const rawArgs = command_args; // Use captured args
+
+        const subprocess = spawn(commandName, [...preArgs, ...rawArgs], {
+          cwd: fs$1.existsSync(projectDir) ? projectDir : cwd, // Original logic for cwd
+          stdio: 'inherit',
+          shell: true, // Keep shell: true
+          env: {
+            ...process.env, // Inherit current env
+            ...env          // Override with config env
+          }
+        });
+
+        subprocess.on('close', (code) => {
+          process.exit(code);
+        });
+        subprocess.on('error', (err) => {
+          // Provide more context on error
+          if (err.code === 'ENOENT') {
+            console.error(`Error: Command not found: '${commandName}'. Is it installed or in your PATH?`);
+          } else {
+            console.error(`Failed to start command '${commandName}':`, err);
+          }
+          process.exit(1);
+        });
+      } catch (error) {
+        console.error(error.message);
+        process.exit(1);
+      }
+    });
+}
+
+// --- Helper function for "run" command ---
+// Disable --version on parent command
+function bindRunContextCommand(prog, { name, preArgs = [] }) { // Added prog parameter
+  prog
+    .command(name)
+    .description('Run a command group defined in node.yaml.')
+    .argument('<group>', 'Name of the command group in node.yaml commands section')
+    // .argument('[command_options...]', 'Options passed to the commands (not implemented in original)')
+    .option('--ftag <tags...>', 'Filter tags for loading project config')
+    .version(false) // Disable version for this command
+    // .allowUnknownOption() // Not needed unless passing through options
+    .action(async (groupName, options) => { // Capture positional arg 'group' as groupName
+      try {
+        // Pass the 'run' command's own options to createContext
+        const context = await createContext(options);
+        const { project } = context;
+        const { projectFileParsed } = project;
+        const commands = projectFileParsed.commands;
+        if (!commands) throw new Error('`commands` section not found in project file (node.yaml).');
+
+        const group = commands[groupName]; // Use the captured groupName
+        if (!group) throw new Error(`Command group '${groupName}' not found in project file.`);
+
+        // Execute the command flow
+        await fnetShellFlow({ commands: group });
+        // Success is implicit if fnetShellFlow doesn't throw
+        process.exit(0);
+
+      } catch (error) {
+        // fnetShellFlow might throw errors, catch them here
+        console.error(`Error running command group '${groupName}':`, error.message);
+        process.exit(1);
+      }
+    });
+}
+
+// --- Bind dynamic/pass-through commands ---
+bindSimpleContextCommand(program, { bin: 'npm' });
+bindSimpleContextCommand(program, { bin: 'node' });
+bindSimpleContextCommand(program, { bin: 'bun' });
+bindSimpleContextCommand(program, { name: "serve", bin: 'npm', preArgs: ['run', 'serve'] }); // simplified preArgs for commander handling
+bindSimpleContextCommand(program, { name: "watch", bin: 'npm', preArgs: ['run', 'watch'] });
+bindSimpleContextCommand(program, { name: "app", bin: 'npm', preArgs: ['run', 'app'] });
+bindSimpleContextCommand(program, { name: "cli", bin: 'npm', preArgs: ['run', 'cli'] });
+bindSimpleContextCommand(program, { bin: 'npx' });
+bindSimpleContextCommand(program, { bin: 'cdk' });
+bindSimpleContextCommand(program, { bin: 'aws' });
+bindWithContextCommand(program, { name: 'with' }); // Pass program instance
+bindRunContextCommand(program, { name: 'run' });   // Pass program instance
+bindCondaContextCommand(program, { name: 'python' });
+bindCondaContextCommand(program, { name: 'python3' });
+bindCondaContextCommand(program, { name: 'pip' });
+bindCondaContextCommand(program, { name: 'pip3' });
+
+
+// --- createContext Function (modified to accept commander options) ---
+async function createContext(options) { // Accepts commander's options object
+  // Check for options specific to build/deploy/file commands
+  if (options.id) {
+    return {
+      id: options.id,
+      buildId: options.buildId, // Use options.buildId
+      mode: options.mode,
+      protocol: options.protocol || "ac:", // options.protocol might not be defined, handle default
+      templateDir: path$1.resolve(nodeModulesDir, './@fnet/cli-project-node/dist/template/default'),
+      templateCommonDir: path$1.resolve(nodeModulesDir, './@fnet/cli-project-common/dist/template/default'),
+      projectDir: path$1.resolve(cwd, `./.output/${options.id}`),
+      tags: options.ftag || [], // Default to empty array if undefined
+    };
+  } else {
+    // Load project based on CWD, pass tags from options
+    const project = await loadLocalProject({ tags: options.ftag || [] });
+    return {
+      buildId: options.buildId,
+      mode: options.mode,
+      protocol: options.protocol || "local:",
+      templateDir: path$1.resolve(nodeModulesDir, `./@fnet/cli-project-node/dist/template/${project.runtime.template}`),
+      templateCommonDir: path$1.resolve(nodeModulesDir, `./@fnet/cli-project-common/dist/template/${project.runtime.template}`),
+      projectDir: path$1.resolve(project.projectDir, `./.workspace`),
+      projectSrcDir: path$1.resolve(project.projectDir, `./src`),
+      project,
+      tags: options.ftag || [], // Ensure tags is always an array
+    };
+  }
+}
+
+// --- loadLocalProject Function (Unchanged, but ensure tags are handled) ---
+async function loadLocalProject({ tags = [] }) { // Default tags to empty array
+  const projectFilePath = path$1.resolve(cwd, 'node.yaml');
+  if (!fs$1.existsSync(projectFilePath)) throw new Error('node.yaml file not found in current directory.');
+
+  // Ensure tags is an array before passing to fnetYaml
+  const effectiveTags = Array.isArray(tags) ? tags : (tags ? [tags] : []);
+
+  const { raw, parsed: projectFileParsed } = await fnetYaml({ file: projectFilePath, tags: effectiveTags });
+  const projectDir = path$1.dirname(projectFilePath);
+
+  projectFileParsed.features = projectFileParsed.features || {};
+
+  const features = projectFileParsed.features;
+  features.runtime = features.runtime || {};
+  features.runtime.type = features.runtime.type || "node";
+
+  if (features.runtime.type === "python") features.runtime.template = features.runtime.template || "python";
+  else features.runtime.template = features.runtime.template || "default";
+
+  const libraryAtom = {
+    doc: {
+      ...projectFileParsed,
+    },
+    fileName: "index"
+  };
+
+  const result = {
+    libraryAtom,
+    projectDir,
+    projectFilePath,
+    projectFileContent: raw,
+    projectFileParsed,
+    runtime: features.runtime
+  };
+
+  // Load devops file (logic remains the same)
+  let devopsFilePath = path$1.resolve(projectDir, 'fnet/targets.yaml');
+  if (!fs$1.existsSync(devopsFilePath)) {
+    // migrate legacy devops file
+    devopsFilePath = path$1.resolve(projectDir, 'node.devops.yaml');
+    if (fs$1.existsSync(devopsFilePath)) {
+      const fnetDir = path$1.resolve(projectDir, 'fnet');
+      if (!fs$1.existsSync(fnetDir)) fs$1.mkdirSync(fnetDir);
+      const targetPath = path$1.resolve(projectDir, 'fnet/targets.yaml');
+      fs$1.copyFileSync(devopsFilePath, targetPath);
+      // delete legacy devops file
+      try {
+        fs$1.unlinkSync(devopsFilePath);
+        console.log(`Migrated legacy devops file: ${devopsFilePath} to ${targetPath}`);
+      } catch (err) {
+        console.warn(`Could not delete legacy devops file ${devopsFilePath}: ${err.message}`);
+      }
+
+    }
+  }
+
+  if (fs$1.existsSync(devopsFilePath)) {
+    const { raw: devopsFileContent, parsed: devopsFileParsed } = await fnetYaml({ file: devopsFilePath, tags: effectiveTags }); // Pass tags here too
+    const yamlDocument = yaml.parseDocument(devopsFileContent);
+
+    result.devops = {
+      filePath: devopsFilePath,
+      fileContent: devopsFileContent,
+      yamlDocument,
+      doc: {
+        ...devopsFileParsed,
+      },
+      type: "library.deploy",
+      save: async () => {
+        // Ensure doc is up-to-date before saving
+        // This assumes mutations happen on yamlDocument, which is good practice
+        fs$1.writeFileSync(result.devops.filePath, yamlDocument.toString());
+        // fs.writeFileSync(result.devops.filePath, YAML.stringify(result.devops.doc)); // Stringifying doc might lose comments/formatting
+      }
+    };
+  }
+
+  const readmeFilePath = path$1.resolve(projectDir, 'readme.md');
+  if (fs$1.existsSync(readmeFilePath)) {
+    const readmeFileContent = fs$1.readFileSync(readmeFilePath, 'utf8');
+    result.readme = {
+      filePath: readmeFilePath,
+      fileContent: readmeFileContent,
+      doc: {
+        content: readmeFileContent,
+        "content-type": "markdown",
+      },
+      type: "wiki"
+    };
+  }
+
+  return result;
+}
+
+
+// --- Parse Arguments ---
+// This replaces the final .argv call in yargs
+program.parse(process.argv);
+
+// Add a fallback for when no command is provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}
+
+export { which as w };