pepr 0.1.45 → 0.2.1

package/dist/package.json

@@ -9,7 +9,7 @@
     "engines": {
         "node": ">=18.0.0"
     },
-    "version": "0.1.45",
+    "version": "0.2.1",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "pepr": {
@@ -26,24 +26,23 @@
     "scripts": {
         "prebuild": "rm -fr dist/* && node hack/build-template-data.js",
         "build": "tsc -p tsconfig.build.json",
-        "test": "npm run build && ava && node dist/cli.js -V",
-        "test:e2e": "ava hack/e2e.test.js",
-        "test:e2e-setup": "npm run build && npm uninstall pepr -g && npm install -g .",
-        "lint": "npx eslint src",
-        "lint:fix": "npm run lint -- --fix",
-        "prettier": "npx prettier src --check",
-        "prettier:fix": "npm run prettier -- --write",
-        "prepublishOnly": "npm run lint:fix && npm run prettier:fix && npm run test",
-        "e2e-dev-setup": "k3d cluster delete pepr-dev && k3d cluster create pepr-dev --k3s-arg '--debug@server:0'"
+        "test:unit": "npm run build && ava",
+        "test:e2e": "npm run test:e2e:k3d && npm run test:e2e:build && npm run test:e2e:image && npm run test:e2e:run",
+        "test:e2e:k3d": "k3d cluster delete pepr-dev && k3d cluster create pepr-dev --k3s-arg '--debug@server:0'",
+        "test:e2e:build": "npm run build && npm uninstall pepr -g && npm install -g . && pepr",
+        "test:e2e:image": "docker buildx build --tag pepr:dev . && k3d image import pepr:dev -c pepr-dev",
+        "test:e2e:run": "ava hack/e2e.test.js --sequential",
+        "format:check": "eslint src && prettier src --check",
+        "format:fix": "eslint src --fix && prettier src --write"
     },
     "dependencies": {
         "@kubernetes/client-node": "^0.18.1",
         "@rollup/plugin-json": "^6.0.0",
-        "@rollup/plugin-node-resolve": "^15.0.1",
-        "@rollup/plugin-typescript": "^11.0.0",
+        "@rollup/plugin-node-resolve": "^15.0.2",
+        "@rollup/plugin-typescript": "^11.1.0",
         "@types/ramda": "^0.29.0",
         "chokidar": "^3.5.3",
-        "commander": "^10.0.0",
+        "commander": "^10.0.1",
         "express": "^4.18.2",
         "fast-json-patch": "^3.1.1",
         "node-fetch": "^2.6.9",
@@ -51,10 +50,10 @@
         "prettier": "^2.8.7",
         "prompts": "^2.4.2",
         "ramda": "^0.29.0",
-        "rollup": "^3.20.2",
+        "rollup": "^3.20.6",
         "ts-node": "^10.9.1",
         "tslib": "^2.5.0",
-        "typescript": "^5.0.2",
+        "typescript": "^5.0.4",
         "uuid": "^9.0.0"
     },
     "devDependencies": {
@@ -63,10 +62,10 @@
         "@types/node-forge": "^1.3.2",
         "@types/prompts": "^2.4.4",
         "@types/uuid": "^9.0.1",
-        "@typescript-eslint/eslint-plugin": "^5.57.0",
-        "@typescript-eslint/parser": "^5.57.0",
+        "@typescript-eslint/eslint-plugin": "^5.59.0",
+        "@typescript-eslint/parser": "^5.59.0",
         "ava": "^5.2.0",
-        "eslint": "^8.37.0",
+        "eslint": "^8.38.0",
         "nock": "^13.3.0"
     },
     "ava": {

package/dist/run.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./src/cli/run";

package/dist/run.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./src/cli/run");

package/dist/src/cli/build.d.ts

@@ -1,6 +1,6 @@
 import { RootCmd } from "./root";
 export default function (program: RootCmd): void;
-export declare function buildModule(moduleDir: string): Promise<{
+export declare function buildModule(): Promise<{
     path: string;
     cfg: any;
     uuid: any;

package/dist/src/cli/build.js

@@ -19,12 +19,11 @@ function default_1(program) {
     program
         .command("build")
         .description("Build a Pepr Module for deployment")
-        .option("-d, --dir [directory]", "Pepr module directory", ".")
-        .action(async (opts) => {
+        .action(async () => {
         // Build the module
-        const { cfg, path, uuid } = await buildModule(opts.dir);
+        const { cfg, path, uuid } = await buildModule();
         // Read the compiled module code
-        const code = await fs_1.promises.readFile(path, { encoding: "utf-8" });
+        const code = await fs_1.promises.readFile(path);
         // Generate a secret for the module
         const webhook = new webhook_1.Webhook({
             ...cfg.pepr,
@@ -46,12 +45,21 @@ exports.default = default_1;
 const externalLibs = Object.keys(package_json_1.dependencies).map(dep => new RegExp(`^${dep}.*`));
 // Add the pepr library to the list of external libraries
 externalLibs.push("pepr");
-async function buildModule(moduleDir) {
+async function buildModule() {
     try {
         // Resolve the path to the module's package.json file
-        const cfgPath = (0, path_1.resolve)(moduleDir, "package.json");
-        const input = (0, path_1.resolve)(moduleDir, "pepr.ts");
-        // Read the module's UUID from the package.json filel
+        const cfgPath = (0, path_1.resolve)(".", "package.json");
+        const input = (0, path_1.resolve)(".", "pepr.ts");
+        // Ensure the module's package.json and pepr.ts files exist
+        try {
+            await fs_1.promises.access(cfgPath);
+            await fs_1.promises.access(input);
+        }
+        catch (e) {
+            logger_1.default.error(`Could not find ${cfgPath} or ${input} in the current directory. Please run this command from the root of your module's directory.`);
+            process.exit(1);
+        }
+        // Read the module's UUID from the package.json file
         const moduleText = await fs_1.promises.readFile(cfgPath, { encoding: "utf-8" });
         const cfg = JSON.parse(moduleText);
         const { uuid } = cfg.pepr;

package/dist/src/cli/capability.js

@@ -6,7 +6,6 @@ function default_1(program) {
     program
         .command("new")
         .description("Create a new Pepr Capability")
-        .option("-d, --dir [directory]", "Pepr module directory", ".")
         .action(() => {
         // TODO: Create a new capability
         console.log("new");

package/dist/src/cli/deploy.js

@@ -14,11 +14,10 @@ function default_1(program) {
     program
         .command("deploy")
         .description("Deploy a Pepr Module")
-        .option("-d, --dir [directory]", "Pepr module directory", ".")
         .option("-i, --image [image]", "Override the image tag")
-        .option("-f, --force", "Force redeployment")
+        .option("--confirm", "Skip confirmation prompt")
         .action(async (opts) => {
-        if (!opts.force) {
+        if (!opts.confirm) {
             // Prompt the user to confirm
             const confirm = await (0, prompts_1.prompt)({
                 type: "confirm",
@@ -31,9 +30,9 @@ function default_1(program) {
             }
         }
         // Build the module
-        const { cfg, path } = await (0, build_1.buildModule)(opts.dir);
+        const { cfg, path } = await (0, build_1.buildModule)();
         // Read the compiled module code
-        const code = await fs_1.promises.readFile(path, { encoding: "utf-8" });
+        const code = await fs_1.promises.readFile(path);
         // Generate a secret for the module
         const webhook = new webhook_1.Webhook({
             ...cfg.pepr,

package/dist/src/cli/dev.js

@@ -17,7 +17,6 @@ function default_1(program) {
     program
         .command("dev")
         .description("Setup a local webhook development environment")
-        .option("-d, --dir [directory]", "Pepr module directory", ".")
         .option("-h, --host [host]", "Host to listen on", "host.docker.internal")
         .option("--confirm", "Skip confirmation prompt")
         .action(async (opts) => {
@@ -34,9 +33,9 @@ function default_1(program) {
             }
         }
         // Build the module
-        const { cfg, path } = await (0, build_1.buildModule)(opts.dir);
+        const { cfg, path } = await (0, build_1.buildModule)();
         // Read the compiled module code
-        const code = await fs_1.promises.readFile(path, { encoding: "utf-8" });
+        const code = await fs_1.promises.readFile(path);
         // Generate a secret for the module
         const webhook = new webhook_1.Webhook({
             ...cfg.pepr,
@@ -48,9 +47,9 @@ function default_1(program) {
         try {
             await webhook.deploy(code);
             logger_1.default.info(`Module deployed successfully`);
-            const moduleFiles = (0, path_1.resolve)(opts.dir, "**", "*.ts");
+            const moduleFiles = (0, path_1.resolve)(".", "**", "*.ts");
             const watcher = (0, chokidar_1.watch)(moduleFiles);
-            const peprTS = (0, path_1.resolve)(opts.dir, "pepr.ts");
+            const peprTS = (0, path_1.resolve)(".", "pepr.ts");
             let program;
             // Run the module once to start the server
             runDev(peprTS);
@@ -80,6 +79,7 @@ function runDev(path) {
         const program = (0, child_process_1.spawn)("./node_modules/.bin/ts-node", [path], {
             env: {
                 ...process.env,
+                LOG_LEVEL: "debug",
                 SSL_KEY_PATH: "insecure-tls.key",
                 SSL_CERT_PATH: "insecure-tls.crt",
             },

package/dist/src/cli/init/templates/data.json

@@ -1 +1 @@
-{ "gitignore": "# Ignore node_modules and Pepr build artifacts\nnode_modules\ndist\ninsecure*\n", "readme": "# Pepr Module\n\nThis is a Pepr Module. [Pepr](https://github.com/defenseunicorns/pepr) is a Kubernetes transformation system\nwritten in Typescript.\n\nThe `capabilities` directory contains all the capabilities for this module. By default,\na capability is a single typescript file in the format of `capability-name.ts` that is\nimported in the root `pepr.ts` file as `import { HelloPepr } from \"./capabilities/hello-pepr\";`.\nBecause this is typescript, you can organize this however you choose, e.g. creating a sub-folder\nper-capability or common logic in shared files or folders.\n\nExample Structure:\n\n```\nModule Root\n├── package.json\n├── pepr.ts\n└── capabilities\n    ├── example-one.ts\n    ├── example-three.ts\n    └── example-two.ts\n```\n", "peprTS": "import { PeprModule } from \"pepr\";\nimport { HelloPepr } from \"./capabilities/hello-pepr\";\nimport cfg from \"./package.json\";\n\n/**\n * This is the main entrypoint for the Pepr module. It is the file that is run when the module is started.\n * This is where you register your configurations and capabilities with the module.\n */\nnew PeprModule(cfg, [\n  // \"HelloPepr\" is a demo capability that is included with Pepr. You can remove it if you want.\n  HelloPepr,\n\n  // Your additional capabilities go here\n]);\n", "helloPeprTS": "import { Capability, PeprRequest, RegisterKind, a, fetch } from \"pepr\";\n\n/**\n *  The HelloPepr Capability is an example capability to demonstrate some general concepts of Pepr.\n *  To test this capability you can run `pepr dev` or `npm start` and then run the following command:\n *  `kubectl apply -f capabilities/hello-pepr.samples.yaml`\n */\nexport const HelloPepr = new Capability({\n  name: \"hello-pepr\",\n  description: \"A simple example capability to show how things work.\",\n  namespaces: [\"pepr-demo\"],\n});\n\n// Use the 'When' function to create a new Capability Action\nconst { When } = HelloPepr;\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION                                               *\n * ---------------------------------------------------------------------------------------------------\n *\n * This Capability Action removes the label `remove-me` when a Namespace is created.\n * Note we don't need to specify the namespace here, because we've already specified\n * it in the Capability definition above.\n */\nWhen(a.Namespace)\n  .IsCreated()\n  .Then(ns => ns.RemoveLabel(\"remove-me\"));\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION                                               *\n * ---------------------------------------------------------------------------------------------------\n *\n * This is a single Capability Action. They can be in the same file or put imported from other files.\n * In this exmaple, when a ConfigMap is created with the name `example-1`, then add a label and annotation.\n *\n * Equivelant to manually running:\n * `kubectl label configmap example-1 pepr=was-here`\n * `kubectl annotate configmap example-1 pepr.dev=annotations-work-too`\n */\nWhen(a.ConfigMap)\n  .IsCreated()\n  .WithName(\"example-1\")\n  .Then(request =>\n    request\n      .SetLabel(\"pepr\", \"was-here\")\n      .SetAnnotation(\"pepr.dev\", \"annotations-work-too\")\n  );\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION                                               *\n * ---------------------------------------------------------------------------------------------------\n *\n * This Capabiility Action does the exact same changes for example-2, except this time it uses\n * the `.ThenSet()` feature. You can stack multiple `.Then()` calls, but only a single `.ThenSet()`\n */\nWhen(a.ConfigMap)\n  .IsCreated()\n  .WithName(\"example-2\")\n  .ThenSet({\n    metadata: {\n      labels: {\n        pepr: \"was-here\",\n      },\n      annotations: {\n        \"pepr.dev\": \"annotations-work-too\",\n      },\n    },\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION                                               *\n * ---------------------------------------------------------------------------------------------------\n *\n * This Capability Action combines different styles. Unlike the previous actions, this one will look\n * for any ConfigMap in the `pepr-demo` namespace that has the label `change=by-label` during either\n * CREATE or UPDATE. Note that all conditions added such as `WithName()`, `WithLabel()`, `InNamespace()`,\n * are ANDs so all conditions must be true for the request to be procssed.\n */\nWhen(a.ConfigMap)\n  .IsCreatedOrUpdated()\n  .WithLabel(\"change\", \"by-label\")\n  .Then(request => {\n    // The K8s object e are going to mutate\n    const cm = request.Raw;\n\n    // Get the username and uid of the K8s reuest\n    const { username, uid } = request.Request.userInfo;\n\n    // Store some data about the request in the configmap\n    cm.data[\"username\"] = username;\n    cm.data[\"uid\"] = uid;\n\n    // You can still mix other ways of making changes too\n    request.SetAnnotation(\"pepr.dev\", \"making-waves\");\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION                                               *\n * ---------------------------------------------------------------------------------------------------\n *\n * This Capability Action show how you can use the `Then()` function to make multiple changes to the\n * same object from different functions. This is useful if you want to keep your Capability Actions\n * small and focused on a single task, or if you want to reuse the same function in multiple\n * Capability Actions.\n *\n * Note that the order of the `.Then()` calls matters. The first call will be executed first,\n * then the second, and so on. Also note the functions are not called until the Capability Action\n * is triggered.\n */\nWhen(a.ConfigMap)\n  .IsCreated()\n  .WithName(\"example-5\")\n  .Then(cm => cm.SetLabel(\"pepr.dev/first\", \"true\"))\n  .Then(addSecond)\n  .Then(addThird);\n\n//This function uses the complete type definition, but is not required.\nfunction addSecond(cm: PeprRequest<a.ConfigMap>) {\n  cm.SetLabel(\"pepr.dev/second\", \"true\");\n}\n\n// This function has no type definition, so you won't have intelisense in the function body.\nfunction addThird(cm) {\n  cm.SetLabel(\"pepr.dev/third\", \"true\");\n}\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION                                               *\n * ---------------------------------------------------------------------------------------------------\n *\n * This Capability Action is a bit more complex. It will look for any ConfigMap in the `pepr-demo`\n * namespace that has the label `chuck-norris` during CREATE. When it finds one, it will fetch a\n * random Chuck Norris joke from the API and add it to the ConfigMap. This is a great example of how\n * you can use Pepr to make changes to your K8s objects based on external data.\n *\n * Note the use of the `async` keyword. This is required for any Capability Action that uses `await` or `fetch()`.\n *\n * Also note we are passing a type to the `fetch()` function. This is optional, but it will help you\n * avoid mistakes when working with the data returned from the API. You can also use the `as` keyword to\n * cast the data returned from the API.\n *\n * These are equivelant:\n * ```ts\n * const joke = await fetch<TheChuckNorrisJoke>(\"https://api.chucknorris.io/jokes/random?category=dev\");\n * const joke = await fetch(\"https://api.chucknorris.io/jokes/random?category=dev\") as TheChuckNorrisJoke;\n * ```\n *\n * Alternatively, you can drop the type completely:\n *\n * ```ts\n * fetch(\"https://api.chucknorris.io/jokes/random?category=dev\")\n * ```\n */\ninterface TheChuckNorrisJoke {\n  icon_url: string;\n  id: string;\n  url: string;\n  value: string;\n}\n\nWhen(a.ConfigMap)\n  .IsCreated()\n  .WithLabel(\"chuck-norris\")\n  .Then(async change => {\n    const joke = await fetch<TheChuckNorrisJoke>(\n      \"https://api.chucknorris.io/jokes/random?category=dev\"\n    );\n\n    // Add the Chuck Norris joke to the configmap\n    change.Raw.data[\"chuck-says\"] = joke.value;\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION                                               *\n * ---------------------------------------------------------------------------------------------------\n *\n * Out of the box, Pepr supports all the standard Kubernetes objects. However, you can also create\n * your own types. This is useful if you are working with an Operator that creates custom resources.\n * There are two ways to do this, the first is to use the `When()` function with a `GenericKind`,\n * the second is to create a new class that extends `GenericKind` and use the `RegisterKind()` function.\n *\n * This example shows how to use the `When()` function with a `GenericKind`. Note that you\n * must specify the `group`, `version`, and `kind` of the object (if applicable). This is how Pepr knows\n * if the Capability Action should be triggered or not. Since we are using a `GenericKind`,\n * Pepr will not be able to provide any intelisense for the object, so you will need to refer to the\n * Kubernetes API documentation for the object you are working with.\n *\n * You will need ot wait for the CRD in `hello-pepr.samples.yaml` to be created, then you can apply\n *\n * ```yaml\n * apiVersion: pepr.dev/v1\n * kind: Unicorn\n * metadata:\n *   name: example-1\n *   namespace: pepr-demo\n * spec:\n *   message: replace-me\n *   counter: 0\n * ```\n */\nWhen(a.GenericKind, {\n  group: \"pepr.dev\",\n  version: \"v1\",\n  kind: \"Unicorn\",\n})\n  .IsCreated()\n  .WithName(\"example-1\")\n  .ThenSet({\n    spec: {\n      message: \"Hello Pepr without type data!\",\n      counter: Math.random(),\n    },\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION                                               *\n * ---------------------------------------------------------------------------------------------------\n *\n * This example shows how to use the `RegisterKind()` function to create a new type. This is useful\n * if you are working with an Operator that creates custom resources and you want to have intelisense\n * for the object. Note that you must specify the `group`, `version`, and `kind` of the object (if applicable)\n * as this is how Pepr knows if the Capability Action should be triggered or not.\n *\n * Once you register a new Kind with Pepr, you can use the `When()` function with the new Kind. Ideally,\n * you should register custom Kinds at the top of your Capability file or Pepr Module so they are available\n * to all Capability Actions, but we are putting it here for demonstration purposes.\n *\n * You will need ot wait for the CRD in `hello-pepr.samples.yaml` to be created, then you can apply\n *\n * ```yaml\n * apiVersion: pepr.dev/v1\n * kind: Unicorn\n * metadata:\n *   name: example-2\n *   namespace: pepr-demo\n * spec:\n *   message: replace-me\n *   counter: 0\n * ```*\n */\nclass UnicornKind extends a.GenericKind {\n  spec: {\n    /**\n     * JSDoc comments can be added to explain more details about the field.\n     *\n     * @example\n     * ```ts\n     * request.Raw.spec.message = \"Hello Pepr!\";\n     * ```\n     * */\n    message: string;\n    counter: number;\n  };\n}\n\nRegisterKind(UnicornKind, {\n  group: \"pepr.dev\",\n  version: \"v1\",\n  kind: \"Unicorn\",\n});\n\nWhen(UnicornKind)\n  .IsCreated()\n  .WithName(\"example-2\")\n  .ThenSet({\n    spec: {\n      message: \"Hello Pepr now with type data!\",\n      counter: Math.random(),\n    },\n  });\n" }
+{ "gitignore": "# Ignore node_modules and Pepr build artifacts\nnode_modules\ndist\ninsecure*\n", "readme": "# Pepr Module\n\nThis is a Pepr Module. [Pepr](https://github.com/defenseunicorns/pepr) is a Kubernetes transformation system\nwritten in Typescript.\n\nThe `capabilities` directory contains all the capabilities for this module. By default,\na capability is a single typescript file in the format of `capability-name.ts` that is\nimported in the root `pepr.ts` file as `import { HelloPepr } from \"./capabilities/hello-pepr\";`.\nBecause this is typescript, you can organize this however you choose, e.g. creating a sub-folder\nper-capability or common logic in shared files or folders.\n\nExample Structure:\n\n```\nModule Root\n├── package.json\n├── pepr.ts\n└── capabilities\n    ├── example-one.ts\n    ├── example-three.ts\n    └── example-two.ts\n```\n", "peprTS": "import { PeprModule } from \"pepr\";\nimport { HelloPepr } from \"./capabilities/hello-pepr\";\nimport cfg from \"./package.json\";\n\n/**\n * This is the main entrypoint for the Pepr module. It is the file that is run when the module is started.\n * This is where you register your configurations and capabilities with the module.\n */\nnew PeprModule(cfg, [\n  // \"HelloPepr\" is a demo capability that is included with Pepr. You can remove it if you want.\n  HelloPepr,\n\n  // Your additional capabilities go here\n]);\n", "helloPeprTS": "import { Capability, PeprRequest, RegisterKind, a, fetch } from \"pepr\";\n\n/**\n *  The HelloPepr Capability is an example capability to demonstrate some general concepts of Pepr.\n *  To test this capability you can run `pepr dev` or `npm start` and then run the following command:\n *  `kubectl apply -f capabilities/hello-pepr.samples.yaml`\n */\nexport const HelloPepr = new Capability({\n  name: \"hello-pepr\",\n  description: \"A simple example capability to show how things work.\",\n  namespaces: [\"pepr-demo\"],\n});\n\n// Use the 'When' function to create a new Capability Action\nconst { When } = HelloPepr;\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION (Namespace)                                   *\n * ---------------------------------------------------------------------------------------------------\n *\n * This Capability Action removes the label `remove-me` when a Namespace is created.\n * Note we don't need to specify the namespace here, because we've already specified\n * it in the Capability definition above.\n */\nWhen(a.Namespace)\n  .IsCreated()\n  .Then(ns => ns.RemoveLabel(\"remove-me\"));\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION (CM Example 1)                                *\n * ---------------------------------------------------------------------------------------------------\n *\n * This is a single Capability Action. They can be in the same file or put imported from other files.\n * In this example, when a ConfigMap is created with the name `example-1`, then add a label and annotation.\n *\n * Equivalent to manually running:\n * `kubectl label configmap example-1 pepr=was-here`\n * `kubectl annotate configmap example-1 pepr.dev=annotations-work-too`\n */\nWhen(a.ConfigMap)\n  .IsCreated()\n  .WithName(\"example-1\")\n  .Then(request =>\n    request\n      .SetLabel(\"pepr\", \"was-here\")\n      .SetAnnotation(\"pepr.dev\", \"annotations-work-too\")\n  );\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION (CM Example 2)                                *\n * ---------------------------------------------------------------------------------------------------\n *\n * This Capability Action does the exact same changes for example-2, except this time it uses\n * the `.ThenSet()` feature. You can stack multiple `.Then()` calls, but only a single `.ThenSet()`\n */\nWhen(a.ConfigMap)\n  .IsCreated()\n  .WithName(\"example-2\")\n  .ThenSet({\n    metadata: {\n      labels: {\n        pepr: \"was-here\",\n      },\n      annotations: {\n        \"pepr.dev\": \"annotations-work-too\",\n      },\n    },\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION (CM Example 3)                                *\n * ---------------------------------------------------------------------------------------------------\n *\n * This Capability Action combines different styles. Unlike the previous actions, this one will look\n * for any ConfigMap in the `pepr-demo` namespace that has the label `change=by-label` during either\n * CREATE or UPDATE. Note that all conditions added such as `WithName()`, `WithLabel()`, `InNamespace()`,\n * are ANDs so all conditions must be true for the request to be processed.\n */\nWhen(a.ConfigMap)\n  .IsCreatedOrUpdated()\n  .WithLabel(\"change\", \"by-label\")\n  .Then(request => {\n    // The K8s object e are going to mutate\n    const cm = request.Raw;\n\n    // Get the username and uid of the K8s request\n    const { username, uid } = request.Request.userInfo;\n\n    // Store some data about the request in the configmap\n    cm.data[\"username\"] = username;\n    cm.data[\"uid\"] = uid;\n\n    // You can still mix other ways of making changes too\n    request.SetAnnotation(\"pepr.dev\", \"making-waves\");\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION (CM Example 4)                                *\n * ---------------------------------------------------------------------------------------------------\n *\n * This Capability Action show how you can use the `Then()` function to make multiple changes to the\n * same object from different functions. This is useful if you want to keep your Capability Actions\n * small and focused on a single task, or if you want to reuse the same function in multiple\n * Capability Actions.\n *\n * Note that the order of the `.Then()` calls matters. The first call will be executed first,\n * then the second, and so on. Also note the functions are not called until the Capability Action\n * is triggered.\n */\nWhen(a.ConfigMap)\n  .IsCreated()\n  .WithName(\"example-4\")\n  .Then(cm => cm.SetLabel(\"pepr.dev/first\", \"true\"))\n  .Then(addSecond)\n  .Then(addThird);\n\n//This function uses the complete type definition, but is not required.\nfunction addSecond(cm: PeprRequest<a.ConfigMap>) {\n  cm.SetLabel(\"pepr.dev/second\", \"true\");\n}\n\n// This function has no type definition, so you won't have intellisense in the function body.\nfunction addThird(cm) {\n  cm.SetLabel(\"pepr.dev/third\", \"true\");\n}\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION (CM Example 5)                                *\n * ---------------------------------------------------------------------------------------------------\n *\n * This Capability Action is a bit more complex. It will look for any ConfigMap in the `pepr-demo`\n * namespace that has the label `chuck-norris` during CREATE. When it finds one, it will fetch a\n * random Chuck Norris joke from the API and add it to the ConfigMap. This is a great example of how\n * you can use Pepr to make changes to your K8s objects based on external data.\n *\n * Note the use of the `async` keyword. This is required for any Capability Action that uses `await` or `fetch()`.\n *\n * Also note we are passing a type to the `fetch()` function. This is optional, but it will help you\n * avoid mistakes when working with the data returned from the API. You can also use the `as` keyword to\n * cast the data returned from the API.\n *\n * These are equivalent:\n * ```ts\n * const joke = await fetch<TheChuckNorrisJoke>(\"https://api.chucknorris.io/jokes/random?category=dev\");\n * const joke = await fetch(\"https://api.chucknorris.io/jokes/random?category=dev\") as TheChuckNorrisJoke;\n * ```\n *\n * Alternatively, you can drop the type completely:\n *\n * ```ts\n * fetch(\"https://api.chucknorris.io/jokes/random?category=dev\")\n * ```\n */\ninterface TheChuckNorrisJoke {\n  icon_url: string;\n  id: string;\n  url: string;\n  value: string;\n}\n\nWhen(a.ConfigMap)\n  .IsCreated()\n  .WithLabel(\"chuck-norris\")\n  .Then(async change => {\n    const joke = await fetch<TheChuckNorrisJoke>(\n      \"https://api.chucknorris.io/jokes/random?category=dev\"\n    );\n\n    // Add the Chuck Norris joke to the configmap\n    change.Raw.data[\"chuck-says\"] = joke.value;\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION (Untyped Custom Resource)                     *\n * ---------------------------------------------------------------------------------------------------\n *\n * Out of the box, Pepr supports all the standard Kubernetes objects. However, you can also create\n * your own types. This is useful if you are working with an Operator that creates custom resources.\n * There are two ways to do this, the first is to use the `When()` function with a `GenericKind`,\n * the second is to create a new class that extends `GenericKind` and use the `RegisterKind()` function.\n *\n * This example shows how to use the `When()` function with a `GenericKind`. Note that you\n * must specify the `group`, `version`, and `kind` of the object (if applicable). This is how Pepr knows\n * if the Capability Action should be triggered or not. Since we are using a `GenericKind`,\n * Pepr will not be able to provide any intellisense for the object, so you will need to refer to the\n * Kubernetes API documentation for the object you are working with.\n *\n * You will need ot wait for the CRD in `hello-pepr.samples.yaml` to be created, then you can apply\n *\n * ```yaml\n * apiVersion: pepr.dev/v1\n * kind: Unicorn\n * metadata:\n *   name: example-1\n *   namespace: pepr-demo\n * spec:\n *   message: replace-me\n *   counter: 0\n * ```\n */\nWhen(a.GenericKind, {\n  group: \"pepr.dev\",\n  version: \"v1\",\n  kind: \"Unicorn\",\n})\n  .IsCreated()\n  .WithName(\"example-1\")\n  .ThenSet({\n    spec: {\n      message: \"Hello Pepr without type data!\",\n      counter: Math.random(),\n    },\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   CAPABILITY ACTION (Typed Custom Resource)                       *\n * ---------------------------------------------------------------------------------------------------\n *\n * This example shows how to use the `RegisterKind()` function to create a new type. This is useful\n * if you are working with an Operator that creates custom resources and you want to have intellisense\n * for the object. Note that you must specify the `group`, `version`, and `kind` of the object (if applicable)\n * as this is how Pepr knows if the Capability Action should be triggered or not.\n *\n * Once you register a new Kind with Pepr, you can use the `When()` function with the new Kind. Ideally,\n * you should register custom Kinds at the top of your Capability file or Pepr Module so they are available\n * to all Capability Actions, but we are putting it here for demonstration purposes.\n *\n * You will need ot wait for the CRD in `hello-pepr.samples.yaml` to be created, then you can apply\n *\n * ```yaml\n * apiVersion: pepr.dev/v1\n * kind: Unicorn\n * metadata:\n *   name: example-2\n *   namespace: pepr-demo\n * spec:\n *   message: replace-me\n *   counter: 0\n * ```*\n */\nclass UnicornKind extends a.GenericKind {\n  spec: {\n    /**\n     * JSDoc comments can be added to explain more details about the field.\n     *\n     * @example\n     * ```ts\n     * request.Raw.spec.message = \"Hello Pepr!\";\n     * ```\n     * */\n    message: string;\n    counter: number;\n  };\n}\n\nRegisterKind(UnicornKind, {\n  group: \"pepr.dev\",\n  version: \"v1\",\n  kind: \"Unicorn\",\n});\n\nWhen(UnicornKind)\n  .IsCreated()\n  .WithName(\"example-2\")\n  .ThenSet({\n    spec: {\n      message: \"Hello Pepr now with type data!\",\n      counter: Math.random(),\n    },\n  });\n" }

package/dist/src/cli/init/templates/samples.json

@@ -51,10 +51,7 @@
         "kind": "ConfigMap",
         "metadata": {
             "name": "example-4",
-            "namespace": "pepr-demo",
-            "labels": {
-                "chuck-norris": "test"
-            }
+            "namespace": "pepr-demo"
         },
         "data": {
             "key": "ex-4-val"
@@ -65,7 +62,13 @@
         "kind": "ConfigMap",
         "metadata": {
             "name": "example-5",
-            "namespace": "pepr-demo"
+            "namespace": "pepr-demo",
+            "labels": {
+                "chuck-norris": "test"
+            }
+        },
+        "data": {
+            "key": "ex-5-val"
         }
     },
     {

package/dist/src/cli/init/templates.d.ts

@@ -18,6 +18,7 @@ export declare function genPkgJSON(opts: InitOptions, pgkVerOverride?: string):
         scripts: {
             "k3d-setup": string;
             build: string;
+            deploy: string;
             start: string;
         };
         dependencies: {

package/dist/src/cli/init/templates.js

@@ -39,8 +39,9 @@ function genPkgJSON(opts, pgkVerOverride) {
             },
         },
         scripts: {
-            "k3d-setup": package_json_1.scripts["e2e-dev-setup"],
+            "k3d-setup": package_json_1.scripts["test:e2e:k3d"],
             build: "pepr build",
+            deploy: "pepr deploy",
             start: "pepr dev",
         },
         dependencies: {

package/dist/src/cli/run.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/cli/run.js

@@ -0,0 +1,58 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const zlib_1 = require("zlib");
+const package_json_1 = require("../../package.json");
+const logger_1 = __importDefault(require("../lib/logger"));
+commander_1.program
+    .version(package_json_1.version)
+    .description(`Pepr Kubernetes Runtime (v${package_json_1.version})`)
+    .argument("<hash>", "Hash of the module to run")
+    .option("-l, --log-level [level]", "Log level: debug, info, warn, error", "info")
+    .action((expectedHash, opts) => {
+    const gzPath = `/app/load/module-${expectedHash}.js.gz`;
+    const jsPath = `/app/module-${expectedHash}.js`;
+    // Require the has to be 64 characters long
+    if (expectedHash.length !== 64) {
+        logger_1.default.error("Invalid hash");
+        process.exit(1);
+    }
+    // Check if the path is a valid file
+    if (!fs_1.default.existsSync(gzPath)) {
+        logger_1.default.error(`File not found: ${gzPath}`);
+        process.exit(1);
+    }
+    // Set the log level
+    logger_1.default.SetLogLevel(opts.logLevel);
+    try {
+        logger_1.default.info(`Loading module ${gzPath}`);
+        // Extract the code from the file
+        const codeGZ = fs_1.default.readFileSync(gzPath);
+        const code = (0, zlib_1.gunzipSync)(codeGZ);
+        // Get the hash of the extracted code
+        const actualHash = crypto_1.default.createHash("sha256").update(code).digest("hex");
+        // If the hash doesn't match, exit
+        if (expectedHash !== actualHash) {
+            logger_1.default.error(`File hash does not match, expected ${expectedHash} but got ${actualHash}`);
+            process.exit(1);
+        }
+        logger_1.default.info(`File hash matches, running module`);
+        // Write the code to a file
+        fs_1.default.writeFileSync(jsPath, code);
+        // Run the module
+        // @todo: evaluate vm (isolate) vs require
+        require(jsPath);
+    }
+    catch (e) {
+        logger_1.default.error(`Failed to decompress module: ${e}`);
+        process.exit(1);
+    }
+});
+commander_1.program.parse();

package/dist/src/cli/test.js

@@ -16,27 +16,26 @@ function default_1(program) {
     program
         .command("test")
         .description("Test a Pepr Module locally")
-        .option("-d, --dir [directory]", "Pepr module directory", ".")
         .option("-w, --watch", "Watch for changes and re-run the test")
         .action(async (opts) => {
         logger_1.default.info("Test Module");
-        await buildAndTest(opts.dir);
+        await buildAndTest();
         if (opts.watch) {
-            const moduleFiles = (0, path_1.resolve)(opts.dir, "**", "*.ts");
+            const moduleFiles = (0, path_1.resolve)(".", "**", "*.ts");
             const watcher = (0, chokidar_1.watch)(moduleFiles);
             watcher.on("ready", () => {
                 logger_1.default.info(`Watching for changes in ${moduleFiles}`);
                 watcher.on("all", async (event, path) => {
                     logger_1.default.debug({ event, path }, "File changed");
-                    await buildAndTest(opts.dir);
+                    await buildAndTest();
                 });
             });
         }
     });
 }
 exports.default = default_1;
-async function buildAndTest(dir) {
-    const { path } = await (0, build_1.buildModule)(dir);
+async function buildAndTest() {
+    const { path } = await (0, build_1.buildModule)();
     logger_1.default.info(`Module built successfully at ${path}`);
     try {
         const { stdout, stderr } = await exec(`node ${path}`);

package/dist/src/lib/capability.js

@@ -74,7 +74,7 @@ class Capability {
             };
             const ThenSet = (merge) => {
                 // Add the new action to the binding
-                Then(async (req) => req.Merge(merge));
+                Then(req => req.Merge(merge));
                 return { Then };
             };
             function InNamespace(...namespaces) {

package/dist/src/lib/filter.js

@@ -18,6 +18,10 @@ function shouldSkipRequest(binding, req) {
     const { group, kind, version } = binding.kind || {};
     const { namespaces, labels, annotations, name } = binding.filters || {};
     const { metadata } = req.object || {};
+    // Test for matching operation
+    if (binding.event && !binding.event.includes(req.operation)) {
+        return true;
+    }
     // Test name first, since it's the most specific
     if (name && name !== req.name) {
         return true;
@@ -39,7 +43,7 @@ function shouldSkipRequest(binding, req) {
         logger_1.default.debug("Namespace does not match");
         return true;
     }
-    // Test for matching lables
+    // Test for matching labels
     for (const [key, value] of Object.entries(labels)) {
         const testKey = metadata?.labels?.[key];
         // First check if the label exists

package/dist/src/lib/k8s/index.d.ts

@@ -1,5 +1,5 @@
 import * as kind from "./upstream";
-/** a is a colleciton of K8s types to be used within a CapabilityAction: `When(a.Configmap)` */
+/** a is a collection of K8s types to be used within a CapabilityAction: `When(a.Configmap)` */
 export { kind as a };
 export { modelToGroupVersionKind, gvkMap, RegisterKind } from "./kinds";
 export * from "./types";

package/dist/src/lib/k8s/kinds.d.ts

@@ -6,6 +6,6 @@ export declare function modelToGroupVersionKind(key: string): GroupVersionKind;
  * Registers a new model and GroupVersionKind with Pepr for use with `When(a.<Kind>)`
  *
  * @param model Used to match the GroupVersionKind and define the type-data for the request
- * @param groupVersionKind Contains the match paramaters to determine the request should be handled
+ * @param groupVersionKind Contains the match parameters to determine the request should be handled
  */
 export declare const RegisterKind: (model: GenericClass, groupVersionKind: GroupVersionKind) => void;

package/dist/src/lib/k8s/kinds.js

@@ -433,7 +433,7 @@ exports.modelToGroupVersionKind = modelToGroupVersionKind;
  * Registers a new model and GroupVersionKind with Pepr for use with `When(a.<Kind>)`
  *
  * @param model Used to match the GroupVersionKind and define the type-data for the request
- * @param groupVersionKind Contains the match paramaters to determine the request should be handled
+ * @param groupVersionKind Contains the match parameters to determine the request should be handled
  */
 const RegisterKind = (model, groupVersionKind) => {
     const name = model.name;

package/dist/src/lib/k8s/types.d.ts

@@ -28,8 +28,8 @@ export declare class GenericKind {
     [key: string]: any;
 }
 /**
- *  GroupVersionKind unambiguously identifies a kind.  It doesn't anonymously include GroupVersion
- * to avoid automatic coercion.  It doesn't use a GroupVersion to avoid custom marshalling
+ * GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion
+ * to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling
  **/
 export interface GroupVersionKind {
     /** The K8s resource kind, e..g "Pod". */
@@ -38,8 +38,8 @@ export interface GroupVersionKind {
     readonly version?: string;
 }
 /**
- * GroupVersionResource unambiguously identifies a resource.  It doesn't anonymously include GroupVersion
- * to avoid automatic coercion.  It doesn't use a GroupVersion to avoid custom marshalling
+ * GroupVersionResource unambiguously identifies a resource. It doesn't anonymously include GroupVersion
+ * to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling
  */
 export interface GroupVersionResource {
     readonly group: string;
@@ -56,13 +56,13 @@ export interface Request<T = KubernetesObject> {
     readonly kind: GroupVersionKind;
     /** Resource is the fully-qualified resource being requested (for example, v1.pods) */
     readonly resource: GroupVersionResource;
-    /** SubResource is the subresource being requested, if any (for example, "status" or "scale") */
+    /** SubResource is the sub-resource being requested, if any (for example, "status" or "scale") */
     readonly subResource?: string;
     /** RequestKind is the fully-qualified type of the original API request (for example, v1.Pod or autoscaling.v1.Scale). */
     readonly requestKind?: GroupVersionKind;
     /** RequestResource is the fully-qualified resource of the original API request (for example, v1.pods). */
     readonly requestResource?: GroupVersionResource;
-    /** RequestSubResource is the subresource of the original API request, if any (for example, "status" or "scale"). */
+    /** RequestSubResource is the sub-resource of the original API request, if any (for example, "status" or "scale"). */
     readonly requestSubResource?: string;
     /**
      * Name is the name of the object as presented in the request. On a CREATE operation, the client may omit name and

package/dist/src/lib/k8s/webhook.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { V1ClusterRole, V1ClusterRoleBinding, V1Deployment, V1MutatingWebhookConfiguration, V1Namespace, V1NetworkPolicy, V1Secret, V1Service, V1ServiceAccount } from "@kubernetes/client-node";
 import { ModuleConfig } from "../types";
 import { TLSOut } from "./tls";
@@ -22,12 +23,12 @@ export declare class Webhook {
     serviceAccount(): V1ServiceAccount;
     tlsSecret(): V1Secret;
     mutatingWebhook(): V1MutatingWebhookConfiguration;
-    deployment(): V1Deployment;
-    /** Only permit the  */
+    deployment(hash: string): V1Deployment;
+    /** Only permit the kube-system ns ingress access to the controller */
     networkPolicy(): V1NetworkPolicy;
     service(): V1Service;
-    moduleSecret(data: string): V1Secret;
+    moduleSecret(data: Buffer, hash: string): V1Secret;
     zarfYaml(path: string): string;
-    allYaml(code: string): string;
-    deploy(code: string): Promise<void>;
+    allYaml(code: Buffer): string;
+    deploy(code: Buffer): Promise<void>;
 }

package/dist/src/lib/k8s/webhook.js

@@ -7,6 +7,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Webhook = void 0;
 const client_node_1 = require("@kubernetes/client-node");
+const crypto_1 = __importDefault(require("crypto"));
 const zlib_1 = require("zlib");
 const logger_1 = __importDefault(require("../logger"));
 const tls_1 = require("./tls");
@@ -160,7 +161,7 @@ class Webhook {
             ],
         };
     }
-    deployment() {
+    deployment(hash) {
         return {
             apiVersion: "apps/v1",
             kind: "Deployment",
@@ -192,6 +193,7 @@ class Webhook {
                                 name: "server",
                                 image: this.image,
                                 imagePullPolicy: "IfNotPresent",
+                                command: ["node", "/app/node_modules/pepr/dist/run.js", hash, "-l", "debug"],
                                 livenessProbe: {
                                     httpGet: {
                                         path: "/healthz",
@@ -222,7 +224,7 @@ class Webhook {
                                     },
                                     {
                                         name: "module",
-                                        mountPath: "/app/module.js.gz",
+                                        mountPath: `/app/load`,
                                         readOnly: true,
                                     },
                                 ],
@@ -247,7 +249,7 @@ class Webhook {
             },
         };
     }
-    /** Only permit the  */
+    /** Only permit the kube-system ns ingress access to the controller */
     networkPolicy() {
         return {
             apiVersion: "networking.k8s.io/v1",
@@ -306,9 +308,10 @@ class Webhook {
             },
         };
     }
-    moduleSecret(data) {
+    moduleSecret(data, hash) {
         // Compress the data
         const compressed = (0, zlib_1.gzipSync)(data);
+        const path = `module-${hash}.js.gz`;
         return {
             apiVersion: "v1",
             kind: "Secret",
@@ -318,7 +321,7 @@ class Webhook {
             },
             type: "Opaque",
             data: {
-                module: compressed.toString("base64"),
+                [path]: compressed.toString("base64"),
             },
         };
     }
@@ -349,6 +352,8 @@ class Webhook {
         return (0, client_node_1.dumpYaml)(zarfCfg, { noRefs: true });
     }
     allYaml(code) {
+        // Generate a hash of the code
+        const hash = crypto_1.default.createHash("sha256").update(code).digest("hex");
         const resources = [
             this.namespace(),
             this.networkPolicy(),
@@ -357,9 +362,9 @@ class Webhook {
             this.serviceAccount(),
             this.tlsSecret(),
             this.mutatingWebhook(),
-            this.deployment(),
+            this.deployment(hash),
             this.service(),
-            this.moduleSecret(code),
+            this.moduleSecret(code, hash),
         ];
         // Convert the resources to a single YAML string
         return resources.map(r => (0, client_node_1.dumpYaml)(r, { noRefs: true })).join("---\n");
@@ -367,6 +372,7 @@ class Webhook {
     async deploy(code) {
         logger_1.default.info("Establishing connection to Kubernetes");
         const namespace = "pepr-system";
+        const hash = crypto_1.default.createHash("sha256").update(code).digest("hex");
         // Deploy the resources using the k8s API
         const kubeConfig = new client_node_1.KubeConfig();
         kubeConfig.loadFromDefault();
@@ -385,16 +391,6 @@ class Webhook {
             logger_1.default.info("Creating namespace");
             await coreV1Api.createNamespace(ns);
         }
-        const netpol = this.networkPolicy();
-        try {
-            logger_1.default.info("Checking for network policy");
-            await networkApi.readNamespacedNetworkPolicy(netpol.metadata.name, namespace);
-        }
-        catch (e) {
-            logger_1.default.debug(e.body);
-            logger_1.default.info("Creating network policy");
-            await networkApi.createNamespacedNetworkPolicy(namespace, netpol);
-        }
         const wh = this.mutatingWebhook();
         try {
             logger_1.default.info("Creating mutating webhook");
@@ -406,6 +402,20 @@ class Webhook {
             await admissionApi.deleteMutatingWebhookConfiguration(wh.metadata.name);
             await admissionApi.createMutatingWebhookConfiguration(wh);
         }
+        // If a host is specified, we don't need to deploy the rest of the resources
+        if (this.host) {
+            return;
+        }
+        const netpol = this.networkPolicy();
+        try {
+            logger_1.default.info("Checking for network policy");
+            await networkApi.readNamespacedNetworkPolicy(netpol.metadata.name, namespace);
+        }
+        catch (e) {
+            logger_1.default.debug(e.body);
+            logger_1.default.info("Creating network policy");
+            await networkApi.createNamespacedNetworkPolicy(namespace, netpol);
+        }
         const crb = this.clusterRoleBinding();
         try {
             logger_1.default.info("Creating cluster role binding");
@@ -444,11 +454,7 @@ class Webhook {
             await coreV1Api.deleteNamespacedServiceAccount(sa.metadata.name, namespace);
             await coreV1Api.createNamespacedServiceAccount(namespace, sa);
         }
-        // If a host is specified, we don't need to deploy the rest of the resources
-        if (this.host) {
-            return;
-        }
-        const mod = this.moduleSecret(code);
+        const mod = this.moduleSecret(code, hash);
         try {
             logger_1.default.info("Creating module secret");
             await coreV1Api.createNamespacedSecret(namespace, mod);
@@ -481,7 +487,7 @@ class Webhook {
             await coreV1Api.deleteNamespacedSecret(tls.metadata.name, namespace);
             await coreV1Api.createNamespacedSecret(namespace, tls);
         }
-        const dep = this.deployment();
+        const dep = this.deployment(hash);
         try {
             logger_1.default.info("Creating deployment");
             await appsApi.createNamespacedDeployment(namespace, dep);

package/dist/src/lib/logger.js

@@ -119,4 +119,7 @@ class Logger {
 exports.Logger = Logger;
 /** Log is an instance of Logger used to generate log entries. */
 const Log = new Logger(LogLevel.info);
+if (process.env.LOG_LEVEL) {
+    Log.SetLogLevel(process.env.LOG_LEVEL);
+}
 exports.default = Log;

package/dist/src/lib/processor.js

@@ -29,19 +29,26 @@ async function processor(config, capabilities, req) {
             logger_1.default.info(`Processing matched action ${action.kind.kind}`, prefix);
             // Add annotations to the request to indicate that the capability started processing
             // this will allow tracking of failed mutations that were permitted to continue
-            const { metadata } = wrapped.Raw;
-            const identifier = `${config.uuid}.pepr.dev/${name}`;
-            metadata.annotations = metadata.annotations || {};
-            metadata.annotations[identifier] = "started";
+            const updateStatus = (status) => {
+                // Only update the status if the request is a CREATE or UPDATE (we don't use CONNECT)
+                if (req.operation == "DELETE") {
+                    return;
+                }
+                const identifier = `${config.uuid}.pepr.dev/${name}`;
+                wrapped.Raw.metadata.annotations = wrapped.Raw.metadata.annotations || {};
+                wrapped.Raw.metadata.annotations[identifier] = status;
+            };
+            updateStatus("started");
             try {
                 // Run the action
                 await action.callback(wrapped);
+                logger_1.default.info(`Action succeeded`, prefix);
                 // Add annotations to the request to indicate that the capability succeeded
-                metadata.annotations[identifier] = "succeeded";
+                updateStatus("succeeded");
             }
             catch (e) {
                 response.warnings.push(`Action failed: ${e}`);
-                // If errors are not allowed, note the failure in the Reponse
+                // If errors are not allowed, note the failure in the Response
                 if (config.onError) {
                     logger_1.default.error(`Action failed: ${e}`, prefix);
                     response.result = "Pepr module configured to reject on error";
@@ -49,7 +56,7 @@ async function processor(config, capabilities, req) {
                 }
                 else {
                     logger_1.default.warn(`Action failed: ${e}`, prefix);
-                    metadata.annotations[identifier] = "warning";
+                    updateStatus("warning");
                 }
             }
         }

package/dist/src/lib/types.d.ts

@@ -15,7 +15,7 @@ export declare enum ErrorBehavior {
  */
 export declare enum HookPhase {
     mutate = "mutate",
-    valdiate = "validate"
+    validate = "validate"
 }
 /**
  * Recursively make all properties in T optional.
@@ -24,13 +24,13 @@ export type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
 };
 /**
- * The type of Kubernetes mutating webhook event ethat the capability action is registered for.
+ * The type of Kubernetes mutating webhook event that the capability action is registered for.
  */
 export declare enum Event {
-    Create = "create",
-    Update = "update",
-    Delete = "delete",
-    CreateOrUpdate = "createOrUpdate"
+    Create = "CREATE",
+    Update = "UPDATE",
+    Delete = "DELETE",
+    CreateOrUpdate = "CREATEORUPDATE"
 }
 export interface CapabilityCfg {
     /**
@@ -155,7 +155,7 @@ export type BindingWithName<T extends GenericClass> = BindingFilter<T> & {
     WithName: (name: string) => BindingFilter<T>;
 };
 export type BindingAll<T extends GenericClass> = BindingWithName<T> & {
-    /** Only apply the cabability action if the resource is in one of the specified namespaces.*/
+    /** Only apply the capability action if the resource is in one of the specified namespaces.*/
     InNamespace: (...namespaces: string[]) => BindingFilter<T>;
 };
 export type BindToAction<T extends GenericClass> = {

package/dist/src/lib/types.js

@@ -20,15 +20,15 @@ var ErrorBehavior;
 var HookPhase;
 (function (HookPhase) {
     HookPhase["mutate"] = "mutate";
-    HookPhase["valdiate"] = "validate";
+    HookPhase["validate"] = "validate";
 })(HookPhase = exports.HookPhase || (exports.HookPhase = {}));
 /**
- * The type of Kubernetes mutating webhook event ethat the capability action is registered for.
+ * The type of Kubernetes mutating webhook event that the capability action is registered for.
  */
 var Event;
 (function (Event) {
-    Event["Create"] = "create";
-    Event["Update"] = "update";
-    Event["Delete"] = "delete";
-    Event["CreateOrUpdate"] = "createOrUpdate";
+    Event["Create"] = "CREATE";
+    Event["Update"] = "UPDATE";
+    Event["Delete"] = "DELETE";
+    Event["CreateOrUpdate"] = "CREATEORUPDATE";
 })(Event = exports.Event || (exports.Event = {}));

package/package.json

@@ -9,7 +9,7 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "version": "0.1.45",
+  "version": "0.2.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "pepr": {
@@ -26,24 +26,23 @@
   "scripts": {
     "prebuild": "rm -fr dist/* && node hack/build-template-data.js",
     "build": "tsc -p tsconfig.build.json",
-    "test": "npm run build && ava && node dist/cli.js -V",
-    "test:e2e": "ava hack/e2e.test.js",
-    "test:e2e-setup": "npm run build && npm uninstall pepr -g && npm install -g .",
-    "lint": "npx eslint src",
-    "lint:fix": "npm run lint -- --fix",
-    "prettier": "npx prettier src --check",
-    "prettier:fix": "npm run prettier -- --write",
-    "prepublishOnly": "npm run lint:fix && npm run prettier:fix && npm run test",
-    "e2e-dev-setup": "k3d cluster delete pepr-dev && k3d cluster create pepr-dev --k3s-arg '--debug@server:0'"
+    "test:unit": "npm run build && ava",
+    "test:e2e": "npm run test:e2e:k3d && npm run test:e2e:build && npm run test:e2e:image && npm run test:e2e:run",
+    "test:e2e:k3d": "k3d cluster delete pepr-dev && k3d cluster create pepr-dev --k3s-arg '--debug@server:0'",
+    "test:e2e:build": "npm run build && npm uninstall pepr -g && npm install -g . && pepr",
+    "test:e2e:image": "docker buildx build --tag pepr:dev . && k3d image import pepr:dev -c pepr-dev",
+    "test:e2e:run": "ava hack/e2e.test.js --sequential",
+    "format:check": "eslint src && prettier src --check",
+    "format:fix": "eslint src --fix && prettier src --write"
   },
   "dependencies": {
     "@kubernetes/client-node": "^0.18.1",
     "@rollup/plugin-json": "^6.0.0",
-    "@rollup/plugin-node-resolve": "^15.0.1",
-    "@rollup/plugin-typescript": "^11.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.2",
+    "@rollup/plugin-typescript": "^11.1.0",
     "@types/ramda": "^0.29.0",
     "chokidar": "^3.5.3",
-    "commander": "^10.0.0",
+    "commander": "^10.0.1",
     "express": "^4.18.2",
     "fast-json-patch": "^3.1.1",
     "node-fetch": "^2.6.9",
@@ -51,10 +50,10 @@
     "prettier": "^2.8.7",
     "prompts": "^2.4.2",
     "ramda": "^0.29.0",
-    "rollup": "^3.20.2",
+    "rollup": "^3.20.6",
     "ts-node": "^10.9.1",
     "tslib": "^2.5.0",
-    "typescript": "^5.0.2",
+    "typescript": "^5.0.4",
     "uuid": "^9.0.0"
   },
   "devDependencies": {
@@ -63,10 +62,10 @@
     "@types/node-forge": "^1.3.2",
     "@types/prompts": "^2.4.4",
     "@types/uuid": "^9.0.1",
-    "@typescript-eslint/eslint-plugin": "^5.57.0",
-    "@typescript-eslint/parser": "^5.57.0",
+    "@typescript-eslint/eslint-plugin": "^5.59.0",
+    "@typescript-eslint/parser": "^5.59.0",
     "ava": "^5.2.0",
-    "eslint": "^8.37.0",
+    "eslint": "^8.38.0",
     "nock": "^13.3.0"
   },
   "ava": {