@cloudnux/cli 0.1.0 → 0.11.0

package/dist/{cli.js → cli.mjs}

@@ -7,10 +7,6 @@ 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";
@@ -18,10 +14,11 @@ import rechoir from "rechoir";
 import { extensions } from "interpret";
 import findUp from "findup-sync";
 
-// src/task-manager/task-manager.ts
+// src/task-manager/base-task-manager.ts
 import EventEmitter from "node:events";
 import path2 from "node:path";
-var TaskManager = class {
+var BaseTaskManager = class {
+  _tasksCount;
   config;
   environment;
   taskResults;
@@ -31,6 +28,13 @@ var TaskManager = class {
     this.environment = environment;
     this.taskResults = /* @__PURE__ */ new Map();
     this.events = new EventEmitter();
+    const envConfig = this.config.environments[this.environment];
+    if (!envConfig) {
+      throw new Error(`Environment ${this.environment} not found in config`);
+    }
+    this._tasksCount = envConfig.tasks.reduce((count, task) => {
+      return count + (task.children ? task.children.length + 1 : 1);
+    }, 0);
   }
   generateTaskId() {
     return Math.random().toString(36).substring(2, 11);
@@ -49,6 +53,7 @@ var TaskManager = class {
       modulesPath: this.config.modulesPath,
       cloudProvider: this.config.cloudProvider,
       workingDir: path2.resolve(this.config.workingDir, this.environment),
+      externalPackages: this.config.externalPackages,
       ...this.taskResults
     };
     delete taskParams.tasks;
@@ -57,7 +62,7 @@ var TaskManager = class {
       title: taskParams.title,
       parentTaskId
     });
-    if (task.skip && task.skip(taskParams)) {
+    if (task.skip?.(taskParams)) {
       this.events.emit("skip", {
         id: taskId
       });
@@ -99,8 +104,11 @@ var TaskManager = class {
         data
       });
     };
+    taskParams.logger = logger;
+    taskParams.eventEmitter = eventEmitter;
+    taskParams.executeSubTasks = executeSubTasks;
     try {
-      const result = await task.action(taskParams, logger, eventEmitter, executeSubTasks);
+      const result = await task.action(taskParams);
       if (!parentTaskId) {
         this.taskResults = {
           ...this.taskResults,
@@ -119,6 +127,25 @@ var TaskManager = class {
       throw new Error(`Task ${taskId} failed: ${error.message}`);
     }
   }
+  on(event, listener) {
+    this.events.on(event, listener);
+  }
+  off(event) {
+    if (event)
+      this.events.removeAllListeners(event);
+    else
+      this.events.removeAllListeners();
+  }
+  get tasksCount() {
+    return this._tasksCount;
+  }
+};
+
+// src/task-manager/build-task-manager.ts
+var BuildTaskManager = class extends BaseTaskManager {
+  constructor(config2, environment) {
+    super(config2, environment);
+  }
   async execute() {
     const envConfig = this.config.environments[this.environment];
     if (!envConfig) {
@@ -128,28 +155,28 @@ var TaskManager = class {
       try {
         await this.executeTask(task, {});
       } catch (error) {
+        console.error(error);
         return;
       }
     }
   }
-  async watch() {
+};
+
+// src/task-manager/watch-task-manager.ts
+var WatchTaskManager = class extends BaseTaskManager {
+  constructor(config2, environment) {
+    super(config2, environment);
+  }
+  async execute() {
     const envConfig = this.config.environments[this.environment];
-    if (envConfig.watch)
+    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();
+    }
   }
 };
 
@@ -206,13 +233,8 @@ var helpers = {
 var transformModule = {
   title: ({ moduleName }) => `Transform module ${moduleName}`,
   skip: () => false,
-  action: async ({
-    moduleTemplateFunc,
-    entrypointPath,
-    moduleName,
-    workingDir,
-    source
-  }) => {
+  action: async (params) => {
+    const { workingDir, moduleName, entrypointPath, source, moduleTemplateFunc } = params;
     const entrypointContent = await fs3.readFile(entrypointPath, "utf-8");
     const rendered = moduleTemplateFunc({
       source: process.platform === "win32" ? source.replace(/\\/g, "/") : source,
@@ -313,7 +335,6 @@ var buildServer = {
     return params.environment === "develop";
   },
   action: async ({ moduleDir, cloudProvider, externalPackages }) => {
-    debugger;
     const modulePath = path8.resolve(moduleDir, "index.ts");
     return await tsup.build({
       entry: {
@@ -331,12 +352,26 @@ var buildServer = {
         };
         return options;
       },
+      format: ["esm"],
+      banner: {
+        js: `
+                    import __node_module from 'node:module';
+                    import __node_url from 'node:url';
+                    import __node_path from 'node:path';
+                    const require = __node_module.createRequire(import.meta.url);
+                    const __filename = __node_url.fileURLToPath(import.meta.url);
+                    const __dirname = __node_path.dirname(__filename);
+                    `.trim()
+      },
+      outExtension: () => ({ js: ".mjs" }),
       bundle: true,
-      sourcemap: false,
+      sourcemap: true,
+      minify: false,
       outDir: moduleDir,
       platform: "node",
       dts: false,
       watch: false,
+      shims: false,
       define: {
         __DEV__: process.env.__DEV__ || "false"
       },
@@ -349,7 +384,8 @@ var buildServer = {
 var locateModules = {
   title: "load all entrypoints.json",
   skip: () => false,
-  action: async (params, _logger, _eventEmitter, executeSubTasks) => {
+  action: async (params) => {
+    const { executeSubTasks } = params;
     const entrypoints = await fg(params.modulesPath);
     const moduleNames = entrypoints.map((entrypoint) => path9.basename(path9.dirname(entrypoint)));
     let output = {
@@ -401,46 +437,49 @@ var transformDevServer = {
 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) => {
+  action: async (params) => {
+    const { workingDir, logger, eventEmitter } = params;
     const entryPath = path11.resolve(workingDir, "app.ts");
     await tsup2.build({
+      format: ["esm"],
+      banner: {
+        js: `
+                    import __node_module from 'node:module';
+                    import __node_url from 'node:url';
+                    import __node_path from 'node:path';
+                    const require = __node_module.createRequire(import.meta.url);
+                    const __filename = __node_url.fileURLToPath(import.meta.url);
+                    const __dirname = __node_path.dirname(__filename);
+                    `.trim()
+      },
+      outExtension: () => ({ js: ".mjs" }),
+      //========================================
       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,
+      noExternal: [],
       sourcemap: true,
+      minify: false,
       outDir: workingDir,
       platform: "node",
+      cjsInterop: true,
+      shims: true,
       dts: false,
       watch: false,
       env: {
-        __ENV_PATH__: '"' + path11.resolve(__dirname, "../.env").replace(/\\/g, "\\\\") + '"',
+        __ENV_PATH__: '"' + path11.resolve(workingDir, "../../.env").replace(/\\/g, "\\\\") + '"',
+        __DEV__: process.env.__DEV__ || '"development"'
+      },
+      define: {
+        __ENV_PATH__: '"' + path11.resolve(workingDir, "../../.env").replace(/\\/g, "\\\\") + '"',
         __DEV__: process.env.__DEV__ || '"development"'
       },
       esbuildPlugins: [
@@ -459,7 +498,6 @@ var devServerWatch = {
         },
         startServerPlugin(logger, eventEmitter)
       ]
-      // silent: true // Prevent console output
     });
   }
 };
@@ -472,33 +510,22 @@ function startModule(main, execArgv, logger, eventEmitter) {
         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);
+        break;
       default:
-        logger("Unknown message:", message);
         break;
     }
   });
   child.on("error", function(error) {
     console.error(error);
+    child.kill("SIGINT");
   });
-  child.on("close", function(code) {
+  child.on("close", function() {
     child.kill("SIGINT");
   });
   return child;
@@ -509,17 +536,18 @@ function startServerPlugin(logger, eventEmitter) {
     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 }) {
+      build.onEnd(async function({ errors, outputFiles }) {
         if (child) {
           child.kill("SIGINT");
           if (!child.killed) {
             console.error(`cannot stop process ${child.pid}`);
           }
         }
-        if (errors && errors.length > 0) return;
+        if (errors && errors.length > 0) {
+          errors.forEach(logger);
+          return;
+        }
+        const main = outputFiles?.find((file) => file.path.endsWith(".js") || file.path.endsWith(".mjs"))?.path;
         child = startModule(main, ["--enable-source-maps"], logger, eventEmitter);
       });
     }
@@ -572,12 +600,12 @@ var transferTerraformModules = {
 var defaultConfig = {
   modulesPath: "./packages/modules/**/entrypoint.json",
   cloudProvider: "aws",
-  workingDir: "./.epf",
+  workingDir: "./.nux",
+  externalPackages: ["aws-sdk", "@aws-sdk/*"],
   environments: {
     develop: {
       moduleTemplatePath: "./templates/local/module.ts.ejs",
       devServerTemplatePath: "./templates/local/dev-server.ts.ejs",
-      externalPackages: ["sqlite3", "pino"],
       tasks: [
         loadModuleTemplate,
         loadDevServerTemplate,
@@ -589,7 +617,6 @@ var defaultConfig = {
     production: {
       moduleTemplatePath: "./templates/cloud/entrypoint-build.ts.ejs",
       triggerTemplatePath: "./templates/cloud/entrypoint-triggers.tf.ejs",
-      externalPackages: ["aws-sdk", "@aws-sdk/*"],
       tasks: [
         loadModuleTemplate,
         loadTriggerTemplate,
@@ -657,7 +684,7 @@ function validateConfig(config2) {
 }
 
 // src/config/index.ts
-var CONFIG_FILE_NAMES = ["epf.config", "epfrc"];
+var CONFIG_FILE_NAMES = ["nux.config", "nuxrc"];
 async function resolveConfig(config2, configContext) {
   if (typeof config2 === "function") {
     try {
@@ -723,13 +750,13 @@ function loadArgs() {
   const args2 = meow(
     `
 	Usage
-	  $ epf <enviroment>
+	  $ nux <enviroment>
 
 	Options
 		--config  Your config file path
 
 	Examples
-	  $ epf develop --config=./config.json
+	  $ nux develop --config=./config.json
 `,
     {
       importMeta: import.meta,
@@ -752,379 +779,10 @@ function loadArgs() {
   };
 }
 
-// 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
+// src/cli.ts
 var args = loadArgs();
 var config = await loadConfig(args.flags.configFile);
-render(/* @__PURE__ */ React7.createElement(App, { args, config }));
+var builder = new BuildTaskManager(config, args.inputs.env);
+await builder.execute();
+var watcher = new WatchTaskManager(config, args.inputs.env);
+await watcher.execute();