@cloudnux/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1130 @@
+#!/usr/bin/env node
+
+// node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+import path from "path";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// src/cli.tsx
+import React7 from "react";
+import { render } from "ink";
+
+// src/config/index.ts
+import fs9 from "node:fs";
+import path14 from "node:path";
+import rechoir from "rechoir";
+import { extensions } from "interpret";
+import findUp from "findup-sync";
+
+// src/task-manager/task-manager.ts
+import EventEmitter from "node:events";
+import path2 from "node:path";
+var TaskManager = class {
+  config;
+  environment;
+  taskResults;
+  events;
+  constructor(config2, environment) {
+    this.config = config2;
+    this.environment = environment;
+    this.taskResults = /* @__PURE__ */ new Map();
+    this.events = new EventEmitter();
+  }
+  generateTaskId() {
+    return Math.random().toString(36).substring(2, 11);
+  }
+  getTaskTitle(task, params) {
+    return typeof task.title === "function" ? task.title(params) : task.title;
+  }
+  async executeTask(task, params, parentTaskId) {
+    const taskId = parentTaskId ? `${parentTaskId}:${this.generateTaskId()}` : this.generateTaskId();
+    const envConfig = this.config.environments[this.environment];
+    const taskParams = {
+      ...params,
+      ...envConfig,
+      title: this.getTaskTitle(task, params),
+      environment: this.environment,
+      modulesPath: this.config.modulesPath,
+      cloudProvider: this.config.cloudProvider,
+      workingDir: path2.resolve(this.config.workingDir, this.environment),
+      ...this.taskResults
+    };
+    delete taskParams.tasks;
+    this.events.emit("new", {
+      id: taskId,
+      title: taskParams.title,
+      parentTaskId
+    });
+    if (task.skip && task.skip(taskParams)) {
+      this.events.emit("skip", {
+        id: taskId
+      });
+      return null;
+    }
+    this.events.emit("start", {
+      id: taskId
+    });
+    const executeSubTasks = async (subTaskParams) => {
+      if (!task.children || task.children.length === 0) {
+        return [];
+      }
+      const results = [];
+      for (const child of task.children) {
+        const newSubTaskParams = {
+          ...subTaskParams,
+          ...results.reduce((acc, result2) => {
+            return {
+              ...acc,
+              ...result2
+            };
+          }, {})
+        };
+        const result = await this.executeTask(child, newSubTaskParams, taskId);
+        results.push(result);
+      }
+      return results;
+    };
+    const logger = (arg, data) => {
+      this.events.emit("log", {
+        id: taskId,
+        log: arg,
+        data
+      });
+    };
+    const eventEmitter = (type, data) => {
+      this.events.emit(type, {
+        id: taskId,
+        data
+      });
+    };
+    try {
+      const result = await task.action(taskParams, logger, eventEmitter, executeSubTasks);
+      if (!parentTaskId) {
+        this.taskResults = {
+          ...this.taskResults,
+          ...result
+        };
+      }
+      this.events.emit("success", {
+        id: taskId
+      });
+      return result;
+    } catch (error) {
+      this.events.emit("failure", {
+        id: taskId,
+        error: error.message
+      });
+      throw new Error(`Task ${taskId} failed: ${error.message}`);
+    }
+  }
+  async execute() {
+    const envConfig = this.config.environments[this.environment];
+    if (!envConfig) {
+      throw new Error(`Environment ${this.environment} not found in config`);
+    }
+    for (const task of envConfig.tasks) {
+      try {
+        await this.executeTask(task, {});
+      } catch (error) {
+        return;
+      }
+    }
+  }
+  async watch() {
+    const envConfig = this.config.environments[this.environment];
+    if (envConfig.watch)
+      try {
+        await this.executeTask(envConfig.watch, {});
+      } catch (error) {
+        console.error(error);
+        return;
+      }
+  }
+  on(event, listener) {
+    this.events.on(event, listener);
+  }
+  off(event) {
+    if (event)
+      this.events.removeAllListeners(event);
+    else
+      this.events.removeAllListeners();
+  }
+};
+
+// src/task-manager/tasks/load-dev-server-template.ts
+import fs from "node:fs/promises";
+import path3 from "node:path";
+import ejs from "ejs";
+var loadDevServerTemplate = {
+  title: "Load Dev Server template",
+  skip: () => false,
+  action: async ({ devServerTemplatePath }) => {
+    const devServerTemplatePathResolved = path3.resolve(__dirname, devServerTemplatePath);
+    const template = await fs.readFile(devServerTemplatePathResolved, "utf-8");
+    const devServerTemplate = ejs.compile(template, {
+      "views": [path3.dirname(devServerTemplatePathResolved)]
+    });
+    return {
+      devServerTemplateFunc: devServerTemplate
+    };
+  }
+};
+
+// src/task-manager/tasks/load-module-template.ts
+import fs2 from "node:fs/promises";
+import path4 from "node:path";
+import ejs2 from "ejs";
+var loadModuleTemplate = {
+  title: "Load module template",
+  skip: () => false,
+  action: async ({ moduleTemplatePath }) => {
+    const moduleTemplatePathResolved = path4.resolve(__dirname, moduleTemplatePath);
+    const template = await fs2.readFile(moduleTemplatePathResolved, "utf-8");
+    const moduleTemplate = ejs2.compile(template, {
+      "views": [path4.dirname(moduleTemplatePathResolved)]
+    });
+    return {
+      moduleTemplateFunc: moduleTemplate
+    };
+  }
+};
+
+// src/task-manager/tasks/locate-modules.ts
+import path9 from "node:path";
+import fg from "fast-glob";
+
+// src/task-manager/tasks/transform-module.ts
+import fs3 from "node:fs/promises";
+import path5 from "node:path";
+var helpers = {
+  $$convertRouteParamstoFastifyRouteTemplate: (route) => {
+    return route.replace(/{(.*?)}/g, (sub) => ":" + sub.slice(1, -1));
+  }
+};
+var transformModule = {
+  title: ({ moduleName }) => `Transform module ${moduleName}`,
+  skip: () => false,
+  action: async ({
+    moduleTemplateFunc,
+    entrypointPath,
+    moduleName,
+    workingDir,
+    source
+  }) => {
+    const entrypointContent = await fs3.readFile(entrypointPath, "utf-8");
+    const rendered = moduleTemplateFunc({
+      source: process.platform === "win32" ? source.replace(/\\/g, "/") : source,
+      module: moduleName,
+      ...JSON.parse(entrypointContent),
+      ...helpers
+    });
+    const moduleDir = path5.join(workingDir, moduleName);
+    await fs3.mkdir(moduleDir, { recursive: true });
+    await fs3.writeFile(path5.join(moduleDir, `index.ts`), rendered, "utf-8");
+    return {
+      moduleDir
+    };
+  }
+};
+
+// src/task-manager/tasks/locate-source-entry.ts
+import findupSync from "findup-sync";
+import fs4 from "node:fs/promises";
+import path6 from "node:path";
+async function getPackageEntryPaths(packagePath) {
+  const content = await fs4.readFile(packagePath, "utf-8");
+  const pkg = JSON.parse(content);
+  const pkgDir = path6.dirname(packagePath);
+  const paths = /* @__PURE__ */ new Set();
+  [pkg.main, pkg.module].filter(Boolean).forEach((entry) => paths.add(path6.join(pkgDir, entry)));
+  if (pkg.exports) {
+    const exportPaths = Object.entries(pkg.exports).filter(([_, value]) => {
+      if (typeof value === "string") {
+        return value.endsWith(".ts") || value.endsWith(".tsx");
+      }
+      return false;
+    }).map(([_, value]) => path6.join(pkgDir, value));
+    exportPaths.forEach((path15) => paths.add(path15));
+  }
+  return Array.from(paths);
+}
+var locateSourceEntry = {
+  title: ({ moduleName }) => `Locate source for module ${moduleName}`,
+  skip: () => false,
+  action: async ({ moduleName, entrypointPath }) => {
+    const pkgJson = findupSync("package.json", { cwd: path6.dirname(entrypointPath) });
+    if (!pkgJson) {
+      throw new Error("Could not locate package.json for module" + moduleName);
+    }
+    const entries = await getPackageEntryPaths(pkgJson);
+    return {
+      source: entries[0]
+    };
+  }
+};
+
+// src/task-manager/tasks/transform-trigger-template.ts
+import fs5 from "node:fs/promises";
+import path7 from "node:path";
+var transformTriggerTemplate = {
+  title: ({ moduleName }) => `Transform terraform trigger ${moduleName}`,
+  skip: (params) => {
+    return params.environment === "develop";
+  },
+  action: async ({
+    triggerTemplateFunc,
+    entrypointPath,
+    moduleName,
+    workingDir,
+    source
+  }) => {
+    const entrypointContent = await fs5.readFile(entrypointPath, "utf-8");
+    const rendered = triggerTemplateFunc({
+      source: process.platform === "win32" ? source.replace(/\\/g, "/") : source,
+      module: moduleName,
+      ...JSON.parse(entrypointContent)
+    });
+    const moduleDir = path7.join(workingDir, moduleName);
+    await fs5.mkdir(moduleDir, { recursive: true });
+    await fs5.writeFile(path7.join(moduleDir, `${moduleName}-triggers.tf`), rendered, "utf-8");
+  }
+};
+
+// src/task-manager/tasks/build-server.ts
+import path8 from "node:path";
+import tsup from "tsup";
+function mapCloud(provider) {
+  switch (provider) {
+    case "aws":
+      return "@cloudnux/aws-cloud-provider";
+    case "azure":
+      return "@cloudnux/azure-cloud-provider";
+    case "gcp":
+      return "@cloudnux/gcp-cloud-provider";
+    default:
+      return provider;
+  }
+}
+var buildServer = {
+  title: ({ moduleName }) => `Build Server for ${moduleName}`,
+  skip: (params) => {
+    return params.environment === "develop";
+  },
+  action: async ({ moduleDir, cloudProvider, externalPackages }) => {
+    debugger;
+    const modulePath = path8.resolve(moduleDir, "index.ts");
+    return await tsup.build({
+      entry: {
+        index: modulePath
+      },
+      external: [...externalPackages],
+      noExternal: ["lodash"],
+      esbuildOptions: (options) => {
+        options.absWorkingDir = moduleDir;
+        options.alias = {
+          "@@cloudcore": "@cloudnux/cloud-core",
+          "@@cloud": mapCloud(cloudProvider),
+          "@@datastore": "@cloudnux/datastore",
+          "@@utils": "@cloudnux/utils"
+        };
+        return options;
+      },
+      bundle: true,
+      sourcemap: false,
+      outDir: moduleDir,
+      platform: "node",
+      dts: false,
+      watch: false,
+      define: {
+        __DEV__: process.env.__DEV__ || "false"
+      },
+      esbuildPlugins: []
+    });
+  }
+};
+
+// src/task-manager/tasks/locate-modules.ts
+var locateModules = {
+  title: "load all entrypoints.json",
+  skip: () => false,
+  action: async (params, _logger, _eventEmitter, executeSubTasks) => {
+    const entrypoints = await fg(params.modulesPath);
+    const moduleNames = entrypoints.map((entrypoint) => path9.basename(path9.dirname(entrypoint)));
+    let output = {
+      entrypoints,
+      moduleNames
+    };
+    for (const entrypoint of entrypoints) {
+      const taskOutput = await executeSubTasks({
+        ...params,
+        entrypointPath: entrypoint,
+        moduleName: path9.basename(path9.dirname(entrypoint))
+      });
+      output = {
+        ...output,
+        ...taskOutput
+      };
+    }
+    return output;
+  },
+  children: [
+    locateSourceEntry,
+    transformModule,
+    transformTriggerTemplate,
+    buildServer
+  ]
+};
+
+// src/task-manager/tasks/transform-dev-server.ts
+import fs6 from "node:fs/promises";
+import path10 from "node:path";
+var transformDevServer = {
+  title: `Transform Dev Server`,
+  skip: () => false,
+  action: async ({
+    moduleNames,
+    devServerTemplateFunc,
+    workingDir
+  }) => {
+    const rendered = devServerTemplateFunc({
+      source: "./src",
+      moduleNames
+    });
+    await fs6.mkdir(workingDir, { recursive: true });
+    await fs6.writeFile(path10.join(workingDir, `app.ts`), rendered, "utf-8");
+  }
+};
+
+// src/task-manager/tasks/dev-server-watch.ts
+import path11 from "node:path";
+import { fork } from "node:child_process";
+import tsup2 from "tsup";
+function mapCloud2(provider) {
+  switch (provider) {
+    case "aws":
+      return "@cloudnux/aws-cloud-provider";
+    case "azure":
+      return "@cloudnux/azure-cloud-provider";
+    case "gcp":
+      return "@cloudnux/gcp-cloud-provider";
+    default:
+      return provider;
+  }
+}
+var devServerWatch = {
+  title: "Dev Server Watch",
+  skip: () => false,
+  action: async ({ workingDir, cloudProvider, externalPackages, ...rest }, logger, eventEmitter) => {
+    const entryPath = path11.resolve(workingDir, "app.ts");
+    await tsup2.build({
+      entry: {
+        index: entryPath
+      },
+      external: [...externalPackages],
+      esbuildOptions: (options) => {
+        options.absWorkingDir = workingDir;
+        options.alias = {
+          "@@cloudcore": "@cloudnux/cloud-core",
+          "@@cloud": mapCloud2(cloudProvider),
+          "@@datastore": "@cloudnux/datastore",
+          "@@utils": "@cloudnux/utils"
+        };
+        return options;
+      },
+      bundle: true,
+      sourcemap: true,
+      outDir: workingDir,
+      platform: "node",
+      dts: false,
+      watch: false,
+      env: {
+        __ENV_PATH__: '"' + path11.resolve(__dirname, "../.env").replace(/\\/g, "\\\\") + '"',
+        __DEV__: process.env.__DEV__ || '"development"'
+      },
+      esbuildPlugins: [
+        {
+          name: "capture-logs",
+          setup: (build) => {
+            build.onEnd((buildResult) => {
+              if (buildResult.errors.length > 0) {
+                buildResult.errors.forEach(logger);
+              }
+              if (buildResult.warnings.length > 0) {
+                buildResult.warnings.forEach(logger);
+              }
+            });
+          }
+        },
+        startServerPlugin(logger, eventEmitter)
+      ]
+      // silent: true // Prevent console output
+    });
+  }
+};
+function startModule(main, execArgv, logger, eventEmitter) {
+  const child = fork(main, { env: process.env, execArgv });
+  child.on("message", (message) => {
+    switch (message.type) {
+      case "ERROR":
+        logger("Error:", message.payload);
+        eventEmitter(message.type, message.payload);
+        break;
+      case "APP_REGISTERED":
+        eventEmitter(message.type, message.payload);
+        break;
+      case "ROUTE_REGISTERED":
+        eventEmitter(message.type, message.payload);
+        break;
+      case "LISTENING":
+        eventEmitter(message.type, message.payload);
+        break;
+      case "REQUEST":
+        eventEmitter(message.type, message.payload);
+        break;
+      case "RESPONSE":
+        eventEmitter(message.type, message.payload);
+        break;
+      case "LOG":
+        eventEmitter(message.type, message.payload);
+      case "log":
+        eventEmitter(message.type, message.payload);
+      default:
+        logger("Unknown message:", message);
+        break;
+    }
+  });
+  child.on("error", function(error) {
+    console.error(error);
+  });
+  child.on("close", function(code) {
+    child.kill("SIGINT");
+  });
+  return child;
+}
+function startServerPlugin(logger, eventEmitter) {
+  logger("Starting server plugin");
+  return {
+    name: "start servers",
+    setup(build) {
+      let child;
+      const { outdir, logLevel } = build.initialOptions;
+      console.log(outdir, logLevel);
+      const main = path11.resolve(outdir, "index.cjs");
+      build.onEnd(async function({ errors }) {
+        if (child) {
+          child.kill("SIGINT");
+          if (!child.killed) {
+            console.error(`cannot stop process ${child.pid}`);
+          }
+        }
+        if (errors && errors.length > 0) return;
+        child = startModule(main, ["--enable-source-maps"], logger, eventEmitter);
+      });
+    }
+  };
+}
+
+// src/task-manager/tasks/load-trigger-template.ts
+import fs7 from "node:fs/promises";
+import path12 from "node:path";
+import ejs3 from "ejs";
+var loadTriggerTemplate = {
+  title: "Load trigger template",
+  skip: () => false,
+  action: async ({ triggerTemplatePath }) => {
+    const triggerTemplatePathResolved = path12.resolve(__dirname, triggerTemplatePath);
+    const template = await fs7.readFile(triggerTemplatePathResolved, "utf-8");
+    const triggerTemplate = ejs3.compile(template, {
+      "views": [path12.dirname(triggerTemplatePathResolved)]
+    });
+    return {
+      triggerTemplateFunc: triggerTemplate
+    };
+  },
+  children: [
+    transformTriggerTemplate
+  ]
+};
+
+// src/task-manager/tasks/transfer-terraform-module.ts
+import fs8 from "node:fs/promises";
+import path13 from "node:path";
+var transferTerraformModules = {
+  title: `Transfer Terraform Modules`,
+  skip: () => false,
+  action: async ({
+    workingDir
+  }) => {
+    await fs8.mkdir(workingDir, { recursive: true });
+    const deployDir = path13.join(workingDir, ".deploy");
+    const sourceDir = path13.join(__dirname, "../.deploy");
+    await fs8.cp(sourceDir, deployDir, {
+      recursive: true,
+      force: true,
+      errorOnExist: false
+    });
+  }
+};
+
+// src/config/defaults.ts
+var defaultConfig = {
+  modulesPath: "./packages/modules/**/entrypoint.json",
+  cloudProvider: "aws",
+  workingDir: "./.epf",
+  environments: {
+    develop: {
+      moduleTemplatePath: "./templates/local/module.ts.ejs",
+      devServerTemplatePath: "./templates/local/dev-server.ts.ejs",
+      externalPackages: ["sqlite3", "pino"],
+      tasks: [
+        loadModuleTemplate,
+        loadDevServerTemplate,
+        locateModules,
+        transformDevServer
+      ],
+      watch: devServerWatch
+    },
+    production: {
+      moduleTemplatePath: "./templates/cloud/entrypoint-build.ts.ejs",
+      triggerTemplatePath: "./templates/cloud/entrypoint-triggers.tf.ejs",
+      externalPackages: ["aws-sdk", "@aws-sdk/*"],
+      tasks: [
+        loadModuleTemplate,
+        loadTriggerTemplate,
+        locateModules,
+        transferTerraformModules
+      ],
+      cloudProvider: {
+        type: "aws"
+      }
+    }
+  }
+};
+
+// src/config/validator.ts
+function isString(value) {
+  return typeof value === "string";
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isTaskTitle(value) {
+  return isString(value) || isFunction(value);
+}
+function isTask(value) {
+  if (!value || typeof value !== "object") return false;
+  const task = value;
+  if (!isTaskTitle(task.title)) return false;
+  if (typeof task.action !== "function") return false;
+  if (task.skip !== void 0 && typeof task.skip !== "function") return false;
+  if (task.children !== void 0) {
+    if (!Array.isArray(task.children)) return false;
+    return task.children.every((child) => isTask(child));
+  }
+  return true;
+}
+function isEnvironment(value) {
+  if (!value || typeof value !== "object") return false;
+  const env = value;
+  if (!Array.isArray(env.tasks)) return false;
+  return env.tasks.every((task) => isTask(task));
+}
+function validateConfig(config2) {
+  if (!config2 || typeof config2 !== "object") {
+    throw new Error("Config must be an object or a function that returns an object");
+  }
+  const typedConfig = config2;
+  if (!isString(typedConfig.modulesPath)) {
+    throw new Error("Config.modulesPath must be a string");
+  }
+  if (!isString(typedConfig.cloudProvider)) {
+    throw new Error("Config.cloudProvider must be a string");
+  }
+  if (!isString(typedConfig.workingDir)) {
+    throw new Error("Config.workingDir must be a string");
+  }
+  if (!typedConfig.environments || typeof typedConfig.environments !== "object") {
+    throw new Error("Config.environments must be an object");
+  }
+  for (const [envName, env] of Object.entries(typedConfig.environments)) {
+    if (!isEnvironment(env)) {
+      throw new Error(`Invalid environment configuration for "${envName}"`);
+    }
+  }
+  return true;
+}
+
+// src/config/index.ts
+var CONFIG_FILE_NAMES = ["epf.config", "epfrc"];
+async function resolveConfig(config2, configContext) {
+  if (typeof config2 === "function") {
+    try {
+      const resolvedConfig = await Promise.resolve(config2(configContext));
+      if (!resolvedConfig || typeof resolvedConfig !== "object") {
+        throw new Error("Config function must return an object");
+      }
+      return resolvedConfig;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Error executing config function: ${error?.message}`);
+      } else {
+        throw new Error("Error executing config function");
+      }
+    }
+  }
+  return config2;
+}
+async function loadConfig(configPath = null) {
+  let configFile = configPath;
+  if (configFile && !fs9.existsSync(configFile)) {
+    throw new Error(`Config file not found: ${configFile}`);
+  }
+  if (!configFile) {
+    const searchPath = process.cwd();
+    const filePaths = CONFIG_FILE_NAMES.map((name) => `${name}{${Object.keys(extensions).join(",")}}`);
+    configFile = findUp(filePaths, { cwd: searchPath });
+    if (!configFile) {
+      return defaultConfig;
+    }
+  }
+  const result = rechoir.prepare(extensions, configFile);
+  if (result === true || Array.isArray(result) && result.length === 0) {
+    const ext = path14.extname(configFile);
+    const osSpecificImportPath = process.platform === "win32" ? "file:///" : "";
+    let rawConfig;
+    if (ext === ".json") {
+      rawConfig = await import(osSpecificImportPath + configFile);
+    } else {
+      rawConfig = await import(osSpecificImportPath + configFile);
+    }
+    rawConfig = await resolveConfig(rawConfig.default);
+    const mergedConfig = {
+      ...defaultConfig,
+      ...rawConfig,
+      environments: {
+        ...defaultConfig.environments,
+        ...rawConfig.environments || {}
+      }
+    };
+    if (validateConfig(mergedConfig))
+      return mergedConfig;
+  }
+  if (Array.isArray(result) && result[0].error) {
+    throw new Error(`Failed to load config: ${result[0].error.message}`);
+  }
+  throw new Error("Unknown error occurred while loading config");
+}
+
+// src/arguments/index.ts
+import meow from "meow";
+function loadArgs() {
+  const args2 = meow(
+    `
+	Usage
+	  $ epf <enviroment>
+
+	Options
+		--config  Your config file path
+
+	Examples
+	  $ epf develop --config=./config.json
+`,
+    {
+      importMeta: import.meta,
+      flags: {
+        config: {
+          isRequired: false,
+          type: "string"
+        }
+      }
+    }
+  );
+  return {
+    inputs: {
+      env: args2.input[0],
+      module: args2.input[1]
+    },
+    flags: {
+      configFile: args2.flags.config
+    }
+  };
+}
+
+// src/app.tsx
+import React6, { useEffect, useMemo, useState as useState2 } from "react";
+import { extendTheme, defaultTheme, ThemeProvider } from "@inkjs/ui";
+import { Box as Box6, useStdout, Text as Text6 } from "ink";
+
+// src/store/index.ts
+import { create } from "zustand";
+import { immer } from "zustand/middleware/immer";
+var useTaskManager = create()(immer(
+  (set, get) => {
+    return {
+      tasks: {},
+      currentTaskId: null,
+      environment: "development",
+      isRunning: false,
+      isListening: false,
+      selectedModule: null,
+      selectedEndpoint: null,
+      modules: [],
+      port: "",
+      host: "",
+      logs: [],
+      pinoLogs: [],
+      start: async (config2, env) => {
+        const taskManager = new TaskManager(config2, env);
+        set(() => ({ isRunning: true, environment: env }));
+        taskManager.on("new", (task) => get().addTask(task));
+        taskManager.on("start", ({ id }) => get().updateTaskStatus(id, "running"));
+        taskManager.on("success", ({ id }) => get().updateTaskStatus(id, "completed"));
+        taskManager.on("failure", ({ id, error }) => get().updateTaskStatus(id, "error", error));
+        taskManager.on("skip", ({ id }) => get().updateTaskStatus(id, "skipped"));
+        taskManager.on("log", ({ id, log, data }) => get().addTaskLog(id, log, data));
+        taskManager.on("APP_REGISTERED", ({ id, data }) => get().addModule(id, data));
+        taskManager.on("ROUTE_REGISTERED", ({ id, data }) => get().addRoute(data));
+        taskManager.on("LISTENING", ({ id, data }) => get().startListening(data));
+        taskManager.on("ERROR", ({ id, data }) => get().addActionLog(id, data));
+        taskManager.on("REQUEST", ({ id, data }) => get().addActionLog(id, data));
+        taskManager.on("RESPONSE", ({ id, data }) => get().addActionLog(id, data));
+        taskManager.on("LOG", ({ id, data }) => get().addPinoLog(id, data));
+        await taskManager.execute();
+        set(() => ({ isRunning: false, currentTaskId: null }));
+        await taskManager.watch();
+        set(() => ({ isWatching: true }));
+      },
+      addTask: (task) => {
+        const newTask = {
+          id: task.id,
+          title: task.title,
+          status: "pending",
+          parentId: task.parentTaskId,
+          children: [],
+          logs: []
+        };
+        set((state) => {
+          state.tasks[task.id] = newTask;
+          if (task.parentTaskId) {
+            const parentTaskState = state.tasks[task.parentTaskId];
+            if (parentTaskState) {
+              state.tasks[task.parentTaskId].children = [
+                ...parentTaskState.children,
+                task.id
+              ];
+            }
+          }
+          state.currentTaskId = task.id;
+        });
+      },
+      updateTaskStatus: (taskId, status, error) => {
+        set((state) => {
+          const task = state.tasks[taskId];
+          if (!task) return state;
+          task.status = status;
+          task.error = error || task.error;
+        });
+      },
+      addTaskLog: (taskId, log, data) => {
+        set((state) => {
+          const task = state.tasks[taskId];
+          if (!task) return state;
+          if (data) log = { text: log, data };
+          task.logs = [...task.logs, log];
+        });
+      },
+      addModule: (id, opts) => {
+        set((state) => {
+          let modules = state.modules;
+          if (modules.length > 0) {
+            state.modules = [...modules, {
+              id: opts.prefix,
+              name: opts.prefix,
+              endpoints: [],
+              data: opts
+            }];
+            return state;
+          }
+          state.modules = [{
+            id: opts.prefix,
+            name: opts.prefix,
+            endpoints: [],
+            data: opts
+          }];
+          return state;
+        });
+      },
+      addRoute: (endpoint) => {
+        set((state) => {
+          let modules = state.modules;
+          if (modules.length < 0) {
+            return state;
+          }
+          state.modules[modules.length - 1].endpoints = [...modules[modules.length - 1].endpoints, endpoint];
+          return state;
+        });
+      },
+      addActionLog(id, data) {
+        const logs = get().logs;
+        if (logs.length >= 5) {
+          logs.shift();
+        }
+        set({ logs: [...logs, data] });
+      },
+      addPinoLog: (id, data) => {
+        const logs = get().pinoLogs;
+        if (logs.length >= 5) {
+          logs.shift();
+        }
+        set({ pinoLogs: [...logs, data] });
+      },
+      startListening: (data) => {
+        if (!data) return;
+        set({ isListening: true, port: data.port, host: data.host });
+      },
+      selectModule: (id) => set({ selectedModule: id }),
+      selectEndpoint: (endpoint) => set({ selectedEndpoint: endpoint }),
+      resetSelection: () => set({ selectedModule: null, selectedEndpoint: null })
+      // Reset both select
+    };
+  }
+));
+var selectTask = (taskId) => (state) => state.tasks[taskId];
+var selectRootTasks = () => (state) => {
+  return Object.values(state.tasks).filter((task) => !task.parentId);
+};
+var selectProgress = () => (state) => {
+  const allTasks = Object.values(state.tasks);
+  const completedTasks = allTasks.filter((task) => task.status === "completed");
+  return completedTasks.length / allTasks.length;
+};
+
+// src/components/prepare-view.tsx
+import React2 from "react";
+import { useShallow } from "zustand/react/shallow";
+import { Box as Box2, Text as Text2 } from "ink";
+import { ProgressBar, StatusMessage, Spinner } from "@inkjs/ui";
+
+// src/components/log-entry.tsx
+import React from "react";
+import { Box, Text } from "ink";
+var LogEntry = ({ log }) => {
+  if (typeof log !== "string" && "text" in log && "data" in log) {
+    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: log.color || "white" }, log.text), log.data && /* @__PURE__ */ React.createElement(Text, { dimColor: true }, JSON.stringify(log.data)));
+  }
+  if (typeof log !== "string" && "text" in log) {
+    const location = log.location ? `${log.location.file}:${log.location.line}:${log.location.column}` : "";
+    const details = log.detail ? `
+${log.detail}` : "";
+    const notes = log.notes?.map((note) => note.text).join("\n");
+    const prefix = log.pluginName ? `[${log.pluginName}] ` : "";
+    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "\u26A0 ", prefix, log.text), location && /* @__PURE__ */ React.createElement(Text, { dimColor: true }, " at ", location), details && /* @__PURE__ */ React.createElement(Text, null, details), notes && /* @__PURE__ */ React.createElement(Text, { dimColor: true }, notes));
+  }
+  const logLevelMatch = log.match(/^\[(info|error|warning)\]/i);
+  const level = logLevelMatch ? logLevelMatch[1].toLowerCase() : "info";
+  const message = logLevelMatch ? log.slice(logLevelMatch[0].length).trim() : log;
+  const getLogColor = () => {
+    switch (level) {
+      case "error":
+        return "red";
+      case "warning":
+        return "yellow";
+      case "info":
+      default:
+        return "white";
+    }
+  };
+  const getLogPrefix = () => {
+    switch (level) {
+      case "error":
+        return "\u2716";
+      case "warning":
+        return "\u26A0";
+      case "info":
+      default:
+        return "\u2139";
+    }
+  };
+  return /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { color: getLogColor() }, getLogPrefix(), " ", message));
+};
+
+// src/components/prepare-view.tsx
+var TaskLogs = ({ taskId, maxLogs = 5 }) => {
+  const task = useTaskManager((state) => state.tasks[taskId]);
+  if (!task?.logs?.length) {
+    return null;
+  }
+  const displayLogs = maxLogs ? task.logs.slice(-maxLogs) : task.logs;
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginLeft: 4 }, displayLogs.map((log, index) => /* @__PURE__ */ React2.createElement(LogEntry, { key: `${taskId}-log-${index}`, log })));
+};
+var TaskStatus = ({ taskId, isActive, indent = 0 }) => {
+  const task = useTaskManager(selectTask(taskId));
+  const currentTaskId = useTaskManager((state) => state.currentTaskId);
+  const getStatusVariant = () => {
+    if (task.error) return "error";
+    if (task.status === "completed" && !task.error) return "success";
+    if (task.status === "skipped") return "info";
+    if (task.status === "running") return "info";
+    return "warning";
+  };
+  const shouldShowLogs = isActive || task.status === "error";
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, null, "  ".repeat(indent)), isActive ? /* @__PURE__ */ React2.createElement(Spinner, { label: task.title }) : /* @__PURE__ */ React2.createElement(StatusMessage, { variant: getStatusVariant() }, task.status === "skipped" ? "\u23ED" : void 0, " ", task.title, task.error && /* @__PURE__ */ React2.createElement(Text2, { color: "red" }, " - ", task.error))), shouldShowLogs && /* @__PURE__ */ React2.createElement(TaskLogs, { taskId: task.id }), task.children?.map((child, index) => /* @__PURE__ */ React2.createElement(
+    TaskStatus,
+    {
+      key: `${child}-${index}`,
+      taskId: child,
+      isActive: task.id === currentTaskId,
+      indent: indent + 1
+    }
+  )));
+};
+var BuildProgress = () => {
+  const progress = useTaskManager(selectProgress());
+  const tasks = useTaskManager(useShallow(selectRootTasks()));
+  const currentTaskId = useTaskManager((state) => state.currentTaskId);
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React2.createElement(Box2, { marginBottom: 1 }, /* @__PURE__ */ React2.createElement(ProgressBar, { value: progress * 100 })), /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, Object.values(tasks).map((task) => /* @__PURE__ */ React2.createElement(
+    TaskStatus,
+    {
+      key: task.id,
+      taskId: task.id,
+      isActive: task.id === currentTaskId
+    }
+  ))));
+};
+function PrepareView() {
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(BuildProgress, null));
+}
+
+// src/components/side-bar.tsx
+import React3 from "react";
+import { Box as Box3, Text as Text3, useInput } from "ink";
+var Sidebar = () => {
+  const { selectedModule, modules, selectEndpoint, selectedEndpoint, resetSelection, selectModule } = useTaskManager();
+  const selectedIndex = modules.findIndex((module) => module.id === selectedModule);
+  useInput((input, key) => {
+    if (key.upArrow && !selectedEndpoint) {
+      const newIndex = (selectedIndex - 1 + modules.length) % modules.length;
+      selectModule(modules[newIndex].id);
+    }
+    if (key.downArrow && !selectedEndpoint) {
+      const newIndex = (selectedIndex + 1) % modules.length;
+      selectModule(modules[newIndex].id);
+    }
+    if (key.return && selectedModule) {
+      selectEndpoint(modules[selectedIndex].endpoints[0]);
+    }
+    if (key.escape) {
+      resetSelection();
+    }
+  });
+  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", width: "20%", borderStyle: "round", borderColor: "green" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "yellow" }, "Modules"), modules.map((module) => /* @__PURE__ */ React3.createElement(
+    Text3,
+    {
+      key: module.id,
+      color: selectedModule === module.id ? "cyan" : "white"
+    },
+    module.name
+  )));
+};
+var side_bar_default = Sidebar;
+
+// src/components/content-view.tsx
+import React4, { useState } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
+var ContentView = () => {
+  const { selectedModule, selectedEndpoint, modules, selectEndpoint } = useTaskManager();
+  const module = modules.find((a) => a.id === selectedModule);
+  const selectedIndex = module?.endpoints.findIndex((e) => e.url === selectedEndpoint?.url && e.method === selectedEndpoint?.method) ?? -1;
+  const [logs, setLogs] = useState([
+    "Log entry 1",
+    "Log entry 2",
+    "Log entry 3",
+    "Log entry 4",
+    "Log entry 5",
+    "Log entry 6",
+    "Log entry 7"
+  ]);
+  const displayedLogs = logs.slice(-5);
+  useInput2((input, key) => {
+    if (key.upArrow && selectedModule && module && selectedIndex >= 0) {
+      const newIndex = (selectedIndex - 1 + module.endpoints.length) % module.endpoints.length;
+      selectEndpoint(module.endpoints[newIndex]);
+    }
+    if (key.downArrow && selectedModule && module && selectedIndex >= 0) {
+      const newIndex = (selectedIndex + 1) % module.endpoints.length;
+      selectEndpoint(module.endpoints[newIndex]);
+    }
+    if (key.rightArrow) {
+      setLogs((logs2) => [...logs2, `Log entry ${logs2.length + 1}`]);
+    }
+  });
+  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", justifyContent: "space-between", width: "80%", borderStyle: "round", borderColor: "blue" }, /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", width: "100%" }, /* @__PURE__ */ React4.createElement(Text4, { bold: true, color: "yellow" }, "Endpoints"), module ? module.endpoints.map((endpoint, index) => /* @__PURE__ */ React4.createElement(
+    Text4,
+    {
+      key: index,
+      color: selectedEndpoint?.url === endpoint.url && endpoint.method === selectedEndpoint?.method ? "cyan" : "white"
+    },
+    endpoint.method,
+    "   -   ",
+    endpoint.url
+  )) : /* @__PURE__ */ React4.createElement(Text4, null, "Select an app to view its endpoints")), selectedEndpoint && /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "gray" }, /* @__PURE__ */ React4.createElement(Text4, { bold: true, color: "yellow" }, "Logs for ", selectedEndpoint.method, " - ", selectedEndpoint.url, ":"), displayedLogs.map((log, index) => /* @__PURE__ */ React4.createElement(Text4, { key: index }, log))));
+};
+var content_view_default = ContentView;
+
+// src/components/action-logs.tsx
+import React5 from "react";
+import { Box as Box5, Text as Text5 } from "ink";
+var ActionLogs = () => {
+  const logs = useTaskManager((state) => state.logs);
+  return /* @__PURE__ */ React5.createElement(Box5, { borderStyle: "round", flexDirection: "column", borderColor: "green", width: "100%", height: "60%" }, /* @__PURE__ */ React5.createElement(Text5, { bold: true, color: "yellow" }, "General Logs"), logs.map((log, index) => /* @__PURE__ */ React5.createElement(Box5, null, /* @__PURE__ */ React5.createElement(Text5, { key: index, color: "greenBright" }, "[", log.method, "](", log.url, "): ", log.time), /* @__PURE__ */ React5.createElement(Text5, { key: index }, " - ", JSON.stringify(log)))));
+};
+var action_logs_default = ActionLogs;
+
+// src/app.tsx
+function App({ config: config2, args: args2 }) {
+  const { stdout } = useStdout();
+  const theme = useMemo(() => {
+    return extendTheme(defaultTheme, {
+      components: {
+        ProgressBar: {
+          styles: {
+            completed: () => {
+              return {
+                color: "green"
+              };
+            }
+          }
+        }
+      }
+    });
+  }, []);
+  useMemo(() => {
+    const onResize = () => {
+      setDimensions([stdout.columns, stdout.rows]);
+    };
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  const [dimensions, setDimensions] = useState2([
+    stdout.columns,
+    stdout.rows
+  ]);
+  const [width, height] = dimensions;
+  const start = useTaskManager((state) => state.start);
+  const isListening = useTaskManager((state) => state.isListening);
+  const port = useTaskManager((state) => state.port);
+  const host = useTaskManager((state) => state.host);
+  useEffect(() => {
+    start(config2, args2.inputs.env);
+  }, []);
+  return /* @__PURE__ */ React6.createElement(ThemeProvider, { theme }, /* @__PURE__ */ React6.createElement(PrepareView, null), isListening && /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column", width, height }, /* @__PURE__ */ React6.createElement(Text6, null, "Server Listening on http://[", host, "]:", port), /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "row", width: "100%", height: "40%" }, /* @__PURE__ */ React6.createElement(side_bar_default, null), /* @__PURE__ */ React6.createElement(content_view_default, null)), /* @__PURE__ */ React6.createElement(action_logs_default, null)));
+}
+
+// src/cli.tsx
+var args = loadArgs();
+var config = await loadConfig(args.flags.configFile);
+render(/* @__PURE__ */ React7.createElement(App, { args, config }));