@cloudnux/cli 0.1.0 → 0.11.0

package/dist/templates/local/module.ts.ejs

@@ -1,75 +1,55 @@
 <%# Template generated from a single entrypoint
     input: 
       - source : the main export of the package
+      - module : the module (package) name
       - config: the full entrypoint object 
 %>
-import { AddressInfo } from "node:net";
-import querystring from "node:querystring"; 
-import jwt from "jsonwebtoken";
-
-import { FastifyInstance } from "fastify";
-
-import {
-  HTTPAuth,
-  HttpMethod,
-  createHttpContext,
-  createScheduleContext,
-} from "@@cloudcore";
+import { RouterInstance } from '@cloudnux/local-cloud-provider';
+import { httpHandler, scheduleHandler, eventBrokerHandler, websocketHandler } from "@cloudnux/cloud-sdk";
+import "@cloudnux/local-cloud-provider/schedule-plugin";
+import "@cloudnux/local-cloud-provider/queue-plugin";
+import "@cloudnux/local-cloud-provider/websocket-plugin";
 
 import * as src from "<%= source %>";
 
-const prefix = "DEV_IDENTITY_";
-function buildAuth(headers: { authorization?: any; }) {
-  try {
-    // Case 1: DEV_IDENTITY_TOKEN
-    const devToken = process.env[`${prefix}TOKEN`];
-    if (devToken) {
-      const claims = jwt.decode(devToken) as Record<string, unknown>;
-      return { token: devToken, ...claims };
-    }
-
-    // Case 2: DEV_IDENTITY_ variables
-    const devIdentityVars = Object.entries(process.env)
-      .filter(([key]) => key.startsWith(prefix) && key !== `${prefix}TOKEN`)
-      .reduce((acc, [key, value]) => {
-        const claimKey = key.replace(prefix, '').toLowerCase();
-        acc[claimKey] = value;
-        return acc;
-      }, {} as Record<string, unknown>);
-
-    if (Object.keys(devIdentityVars).length > 0) {
-      return { token: '', ...devIdentityVars };
-    }
-
-    // Case 3: Authorization header
-    const authHeader = headers.authorization;
-    if (authHeader?.startsWith('Bearer ')) {
-      const token = authHeader.substring(7);
-      const claims = jwt.decode(token) as Record<string, unknown>;
-      return { token, ...claims };
-    }
-
-    // Case 4: Nothing exists
-    return undefined;
-  } catch (error) {
-    console.error('Error processing identity token:', error);
-    return undefined;
-  }
-}
-
-async function entries(app: FastifyInstance) {
+async function entries(app: RouterInstance) {
   <%_ for (const [name, entry] of Object.entries(entries)) { _%>
     <%_ if (entry.trigger.type === "http") { _%>
-      <%- include("triggers/http.ts.ejs", {
-        name,
-        entry
-      }) %>
+        app.route({
+          method: "<%= entry.trigger.options.method %>" as any,
+          url: `/http<%= $$convertRouteParamstoFastifyRouteTemplate(entry.trigger.options.route) %>`,
+          module : "<%=module%>",
+          handler: async (request, reply) => {
+              await httpHandler(src["<%= entry.handler %>"], request, reply); 
+          }
+    });
     <%_ } _%>
     <%_ if (entry.trigger.type === "schedule") { _%>
-      <%- include("triggers/schedule.ts.ejs", {
-        name,
-        entry
-      }) %>
+      app.scheduler.addJob({
+       name: '<%= name %>',
+       cronExpression: '<%= entry.trigger.options.pattern %>',
+       module : "<%=module%>",
+       handler: async (job, execution) => {
+          return scheduleHandler(src["<%= entry.handler %>"], job,execution)
+       }});
+    <%_ } _%>
+    <%_ if(entry.trigger.type === "event") { _%>
+         app.queues.addQueue("<%=entry.trigger.options.source%>",
+          (msg) => eventBrokerHandler(src["<%= entry.handler %>"], msg),
+          "<%=module%>"
+          );
+    <%_ } _%>
+    <%_ if(entry.trigger.type === "websocket") { _%>
+        app.websockets.registerHandler({
+          path: "<%= entry.trigger.options.path %>",
+          event: "<%= entry.trigger.options.event %>",
+          <%_ if(entry.trigger.options.route) { _%>
+          route: "<%= entry.trigger.options.route %>",
+          <%_ } _%>
+          handler: async (connectionId, event, data) => {
+            return websocketHandler(src["<%= entry.handler %>"], connectionId, event, data);
+          }
+        });
     <%_ } _%>
   <%_ } _%>
 }

package/dist/templates/local/triggers/event.ts.ejs

@@ -0,0 +1,7 @@
+app.route({
+    method: "GET",
+    url: `/event/<%= name %>`,
+    handler: async function (...args) {
+        await eventBrokerHandler(src["<%= entry.handler %>"], ..args);
+      }
+  });

package/dist/templates/local/triggers/http.ts.ejs

@@ -5,29 +5,7 @@
     app.route({
       method: "<%= entry.trigger.options.method %>" as any,
       url: `/http<%= $$convertRouteParamstoFastifyRouteTemplate(entry.trigger.options.route) %>`,
-      handler: async function (request, reply) {
-        const baseAddress = app.server.address() as AddressInfo;
-        const routePath = `/http<%= $$convertRouteParamstoFastifyRouteTemplate(entry.trigger.options.route) %>`;
-        const ctx = createHttpContext({
-            body: request.rawBody as string,
-            headers: request.headers,
-            method: request.method as HttpMethod,
-            url: `http://${request.hostname}:${baseAddress!.port}/api${routePath}`,
-            matchingKey: "<%= entry.trigger.options.route %>",
-            params: request.params as Record<string, string>,
-            rawQueryString : querystring.stringify(request.query),
-            host: request.hostname
-          }, buildAuth(request.headers));
-
-        try {
-          await src["<%= entry.handler %>"](ctx);
-          reply
-            .headers(ctx.response.headers || {})
-            .status(ctx.response.status)
-            .send(ctx.response.body);
-        }
-        catch(e){
-          reply.send(e);
-        }
+      handler: async (request, reply) => {
+        await httpHandler(src["<%= entry.handler %>"], request, reply); 
       }
   });

package/dist/templates/local/triggers/schedule.ts.ejs

@@ -1,15 +1,7 @@
-    logEntryURL('GET','/schedule/<%= name %>');
-    app.route({
-      method: "GET",
-      url: `/schedule/<%= name %>`,
-      handler: async function (request, reply) {
-        const ctx = createScheduleContext("<%= name %>");
-        try {
-          await src["<%= entry.handler %>"](ctx);
-          reply.status(200).send("success");
-        }
-        catch (e) {
-          reply.send(e);
-        }
-      }
-    });
+app.route({
+  method: "GET",
+  url: `/schedule/<%= name %>`,
+  handler: async function (...args) {
+      await scheduleHandler(src["<%= entry.handler %>"], ...args);
+    }
+});

package/dist/types.d.ts

@@ -0,0 +1,165 @@
+type TaskParamBase = Record<string, any>;
+type TaskParam = {
+    modulesPath: string;
+    /**
+     * cloud provider package to use, any locally installed package can be used
+     * aws is an alias for @cloudnux/aws-cloud-provider
+     * azure is an alias for @cloudnux/azure-cloud-provider
+     * gcp is an alias for @cloudnux/gcp-cloud-provider
+     */
+    cloudProvider: string;
+    /**
+     * Path to store the current environment build artifacts
+     * @default '.nux/<environment>'
+     */
+    workingDir: string;
+    /**
+     * task title
+     * @note: this is set by the task manager
+     */
+    title?: string;
+    /**
+     * environment name
+     */
+    environment: string;
+    /**
+     * logger function to log messages
+     */
+    logger: (arg: any, data?: any) => void;
+    /**
+     * event emitter function to emit events
+     */
+    eventEmitter: (type: string, data?: any) => void;
+    children?: Task[];
+    [key: string]: any;
+};
+type TaskTitle = string | ((params: TaskParam) => string);
+type Task<TTaskParams extends TaskParamBase = any> = {
+    title: string | ((params: TTaskParams) => string);
+    action: (params: TTaskParams) => any | Promise<any>;
+    skip?: (params: TTaskParams) => boolean;
+    children?: Task<TTaskParams>[];
+};
+type Environment<TTaskParams extends TaskParamBase = any> = {
+    /**
+     * tasks to be executed for this environment
+     */
+    tasks: Task<TTaskParams>[];
+    /**
+     * watch task
+     * if set, task will be executed and all logs will be routed to the watch view.
+     * This is useful for development environments where you want to see the logs in real-time
+     * @note: process will not exit until error or ctrl+c is pressed
+     * @default undefined
+     */
+    watch?: Task;
+    /**
+     * additional parameters for this environment
+     */
+    [key: string]: any;
+};
+type Config<TTaskParams extends TaskParamBase = any> = {
+    /**
+     * glob Path to find all modules (package.json) having entrypoints
+     * @default './packages/modules/**\/package.json'
+    */
+    modulesPath: string;
+    /**
+     * cloud provider package to use, any locally installed package can be used
+     * aws is an alias for @cloudnux/aws-cloud-provider
+     * azure is an alias for @cloudnux/azure-cloud-provider
+     * gcp is an alias for @cloudnux/gcp-cloud-provider
+     * @default 'aws'
+     */
+    cloudProvider: string;
+    /**
+     * Path to store the build artifacts for all environments
+     * @default './.nux'
+     */
+    workingDir: string;
+    /**
+     * environment configuration with key as environment name and value as Environment
+     * @default { develop: { tasks: [] }, prod: { tasks: [] } }
+     */
+    environments: Record<string, Environment<TTaskParams>>;
+    /**
+     * External packages to be used in the module build
+     * @default: ["aws-sdk", "@aws-sdk/*"]
+     */
+    externalPackages: string[];
+};
+type Args = {
+    inputs: {
+        env: string;
+        module?: string;
+    };
+    flags: {
+        configFile: string | undefined;
+    };
+};
+type AppProps = {
+    config: Config;
+    args: Args;
+};
+type Module = {
+    id: string;
+    name: string;
+    endpoints: any[];
+    data?: any;
+};
+type TaskStatus = 'pending' | 'running' | 'completed' | 'error' | 'skipped';
+interface TaskState {
+    id: string;
+    title: string;
+    status: TaskStatus;
+    error?: string;
+    children: string[];
+    logs: any[];
+    parentId?: string;
+}
+interface TaskManagerStore {
+    tasks: Record<string, TaskState>;
+    currentTaskId: string | null;
+    environment: string;
+    isRunning: boolean;
+    tasksCount: number;
+    start: (config: Config, env: string) => Promise<void>;
+    addTask: (task: {
+        id: string;
+        title: string;
+        parentTaskId?: string;
+    }) => void;
+    updateTaskStatus: (taskId: string, status: TaskStatus, error?: string) => void;
+    addTaskLog: (taskId: string, log: any, data: any) => void;
+}
+interface Log {
+    url: string;
+    method: string;
+    status: number;
+    payload: any;
+    time: Date;
+}
+interface DevServerStore {
+    isRunning: boolean;
+    modules: Module[];
+    selectedModule: string | null;
+    selectedEndpoint: any | null;
+    port: string;
+    host: string;
+    logs: Array<any>;
+    pinoLogs: Array<any>;
+    watch: (config: Config, env: string) => Promise<void>;
+    addModule: (id: string, opts: any) => void;
+    addRoute: (route: any) => void;
+    addActionLog(id: string, data: any): void;
+    addPinoLog(id: string, data: any): void;
+    startListening: ({ host, port }: {
+        host: string;
+        port: string;
+    }) => void;
+    selectModule: (id: string) => void;
+    selectEndpoint: (endpoint: any) => void;
+    resetSelection: () => void;
+}
+
+export type { AppProps, Args, Config, DevServerStore, Environment, Log, Task, TaskManagerStore, TaskParam, TaskParamBase, TaskState, TaskStatus, TaskTitle };

package/dist/types.mjs

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/package.json

@@ -1,54 +1,58 @@
 {
 	"name": "@cloudnux/cli",
-	"version": "0.1.0",
+	"version": "0.11.0",
 	"license": "MIT",
 	"bin": {
-		"epf": "dist/cli.js"
+		"nux": "dist/cli.mjs"
+	},
+	"main": "./dist/cli.js",
+	"types": "./dist/cli.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/types.d.ts",
+			"import": "./dist/types.mjs"
+		}
 	},
 	"type": "module",
 	"engines": {
 		"node": ">=22"
 	},
 	"scripts": {
-		"develop": "tsup --watch && chmod +x dist/cli.js",
-		"build": "tsup && chmod +x dist/cli.js",
-		"link": "yarn link"
+		"dev": "tsup",
+		"build": "tsup",
+		"link": "yarn link",
+		"type-check": "tsc --noEmit",
+		"clean": "rm -rf dist"
 	},
 	"files": [
 		".deploy",
 		"dist",
-		"pakage.json",
+		"package.json",
 		"README.md"
 	],
 	"dependencies": {
-		"@inkjs/ui": "^2.0.0",
 		"@types/findup-sync": "^4.0.5",
 		"ejs": "^3.1.10",
 		"fast-glob": "^3.3.2",
 		"fastify": "^5.2.1",
 		"fastify-raw-body": "^5.0.0",
 		"findup-sync": "^5.0.0",
-		"immer": "^10.1.1",
-		"ink": "^4.1.0",
-		"ink-spinner": "^5.0.0",
 		"interpret": "^3.1.1",
 		"jsonwebtoken": "^9.0.2",
 		"meow": "^11.0.0",
 		"pino-pretty": "^13.0.0",
-		"react": "^18.2.0",
 		"rechoir": "^0.8.0",
 		"tsup": "^8.3.5",
-		"zustand": "^5.0.2"
+		"@cloudnux/aws-cloud-provider": "0.11.0",
+		"@cloudnux/local-cloud-provider": "0.11.0",
+		"@cloudnux/cloud-sdk": "0.11.0",
+		"@cloudnux/dev-console": "0.11.0"
 	},
 	"devDependencies": {
 		"@types/ejs": "^3.1.5",
 		"@types/findup-sync": "^4.0.5",
 		"@types/jsonwebtoken": "^9.0.7",
-		"@types/react": "^18.0.32",
 		"@types/rechoir": "^0.6.4",
-		"chalk": "^5.2.0",
-		"ink-testing-library": "^4.0.0",
-		"react-devtools-core": "^6.0.1",
 		"typescript": "^5.0.3"
 	},
 	"publishConfig": {

package/readme.md

@@ -1,4 +1,4 @@
-# EntryPoint Framework CLI
+# CloudNux CLI
 
 A task-based CLI framework for managing cloud function deployments and local development.
 
@@ -6,7 +6,7 @@ A task-based CLI framework for managing cloud function deployments and local dev
 
 Create an 
 
-`epf.config.js` or `.epfrc.js` in your project root:
+`nux.config.js` or `.nuxrc.js` in your project root:
 
 ```typescript
 export default {
@@ -42,7 +42,7 @@ export default {
 
 ## Task System
 
-Tasks are the core building blocks of EPF workflows. Each task has:
+Tasks are the core building blocks of CloudNux workflows. Each task has:
 
 ```typescript
 {
@@ -64,10 +64,10 @@ Tasks are the core building blocks of EPF workflows. Each task has:
 
 ```bash
 # Run with environment
-epf <environment>
+nux <environment>
 
 # Specify config file
-epf <environment> --config=./custom-config.js
+nux <environment> --config=./custom-config.js
 ```
 
 ## Environments
@@ -125,12 +125,12 @@ Tasks receive parameters including:
 
 ```
 .
-├── epf.config.js           # CLI configuration
+├── nux.config.js           # CLI configuration
 ├── packages/
 │   └── modules/           # Function modules
 │       └── */
 │           └── entrypoint.json  # Module definition
-└── .epf/                  # Build artifacts
+└── .nux/                  # Build artifacts
     └── <environment>/     # Environment builds
 ```
 

package/dist/schema/schema.json

@@ -1,134 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-07/schema#",
-    "title": "Task Configuration Schema",
-    "type": "object",
-    "definitions": {
-        "TaskParamBase": {
-            "type": "object",
-            "properties": {
-                "modulesPath": {
-                    "type": "string",
-                    "description": "Path to find all modules"
-                },
-                "cloudProvider": {
-                    "type": "string",
-                    "description": "Cloud provider package to use. aws/azure/gcp are aliases for respective @entrypoint-framework packages"
-                },
-                "workingDir": {
-                    "type": "string",
-                    "description": "Path to store the current environment build artifacts",
-                    "default": ".epf/<environment>"
-                },
-                "title": {
-                    "type": "string",
-                    "description": "Task title (set by task manager)"
-                },
-                "environment": {
-                    "type": "string",
-                    "description": "Environment name"
-                },
-                "children": {
-                    "type": "array",
-                    "items": {
-                        "$ref": "#/definitions/Task"
-                    }
-                }
-            },
-            "required": [
-                "modulesPath",
-                "cloudProvider",
-                "workingDir",
-                "environment"
-            ],
-            "additionalProperties": true
-        },
-        "Task": {
-            "type": "object",
-            "properties": {
-                "title": {
-                    "oneOf": [
-                        {
-                            "type": "string"
-                        },
-                        {
-                            "type": "object",
-                            "description": "Function that returns a string based on task parameters"
-                        }
-                    ]
-                },
-                "skip": {
-                    "type": "object",
-                    "description": "Function that determines if task should be skipped"
-                },
-                "action": {
-                    "type": "object",
-                    "description": "Async function that executes the task"
-                },
-                "children": {
-                    "type": "array",
-                    "items": {
-                        "$ref": "#/definitions/Task"
-                    }
-                }
-            },
-            "required": [
-                "title",
-                "action"
-            ]
-        },
-        "Environment": {
-            "type": "object",
-            "properties": {
-                "tasks": {
-                    "type": "array",
-                    "items": {
-                        "$ref": "#/definitions/Task"
-                    },
-                    "description": "Tasks to be executed for this environment"
-                }
-            },
-            "required": [
-                "tasks"
-            ],
-            "additionalProperties": true
-        }
-    },
-    "properties": {
-        "modulesPath": {
-            "type": "string",
-            "description": "Glob path to find all modules (package.json) having entrypoints",
-            "default": "./packages/modules/**/package.json"
-        },
-        "cloudProvider": {
-            "type": "string",
-            "description": "Cloud provider package to use",
-            "default": "aws"
-        },
-        "workingDir": {
-            "type": "string",
-            "description": "Path to store the build artifacts for all environments",
-            "default": "./.epf"
-        },
-        "environments": {
-            "type": "object",
-            "description": "Environment configuration with key as environment name",
-            "additionalProperties": {
-                "$ref": "#/definitions/Environment"
-            },
-            "default": {
-                "develop": {
-                    "tasks": []
-                },
-                "prod": {
-                    "tasks": []
-                }
-            }
-        }
-    },
-    "required": [
-        "modulesPath",
-        "cloudProvider",
-        "workingDir",
-        "environments"
-    ]
-}

package/dist/templates/cloude/entrypoint-build.ts.ejs

@@ -1,50 +0,0 @@
-import { Context, S3Event,
-         APIGatewayProxyEventV2WithJWTAuthorizer,
-         ScheduledEvent
-} from "aws-lambda";
-
-import { createRouter, httpMatcher, scheduleMatcher } from "@anubis/cloud-provider";
-import { functions } from "@anubis/aws-cloud-provider";
-import { initialize } from "@anubis/datastore";
-import { logger } from "@anubis/utils";
-
-import * as src from "../../packages/components/<%=component%>/src";
-
-type AWSEventType = S3Event | APIGatewayProxyEventV2WithJWTAuthorizer | ScheduledEvent;
-
-const router = createRouter();
-<%_ for(var [key,entry] of Object.entries(entries)) { _%>
-    <%_ if(entry.trigger.type.toLowerCase() === "http") { _%>
-router.add(httpMatcher("<%=entry.trigger.options.method%>", "<%=entry.trigger.options.route%>"), src["<%= entry.handler %>"])
-    <%_ } _%>
-    <%_ if(entry.trigger.type.toLowerCase() === "schedule") { _%>
-router.add(scheduleMatcher("<%= key %>"), src["<%= entry.handler %>"])
-    <%_ } _%>
-<%_ } _%>
-
-export async function handler(event: AWSEventType, context: Context) {
-    logger.initialize("locations", context.awsRequestId);
-    logger.info("request started");
-    logger.debug({ event }, "Received event");
-
-    try {
-        await initialize();
-        let output = null;
-        if ("rawPath" in event) {
-            output = await router.run("Http", functions.httpAdapter, event, context);
-        }
-        else if ("source" in event) {
-            output = await router.run("Schedule", functions.scheduleAdapter, event, context);
-        }
-        else {
-            throw new Error("invalid handler");
-        }
-        logger.debug({ output }, "Response Sent");
-        logger.info("request completed");
-        return output;
-    }
-    catch (error) {
-        logger.error({ error }, "Error occurred");
-        throw error;
-    }
-}