puls-dev 0.2.9 → 0.3.1

package/dist/core/config.d.ts

@@ -1,3 +1,4 @@
+import "dotenv/config";
 export interface GlobalConfig {
     dryRun?: boolean;
     parallel?: boolean;

package/dist/core/config.js

@@ -1,3 +1,4 @@
+import "dotenv/config";
 class ConfigManager {
     config = {
         providers: {},

package/dist/core/group.test.d.ts

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

package/dist/core/group.test.js

@@ -0,0 +1,94 @@
+import { test, describe } from "node:test";
+import assert from "node:assert";
+import { BaseBuilder, createBuilderArray } from "./resource.js";
+import { Stack } from "./stack.js";
+import { Config } from "./config.js";
+class MockResourceBuilder extends BaseBuilder {
+    val = 0;
+    strVal = "";
+    deployCount = 0;
+    destroyCount = 0;
+    constructor(name) {
+        super(name);
+    }
+    setVal(n) {
+        // Overloaded to support array assignment in proxy test
+        if (typeof n === "number") {
+            this.val = n;
+        }
+        return this;
+    }
+    setStr(s) {
+        if (typeof s === "string") {
+            this.strVal = s;
+        }
+        return this;
+    }
+    async deploy() {
+        this.deployCount++;
+        return { name: this.name, val: this.val, strVal: this.strVal };
+    }
+    async destroy() {
+        this.destroyCount++;
+        return { destroyedName: this.name };
+    }
+}
+describe("Resource Builder Groups Unit Tests", () => {
+    test("createBuilderArray proxies and chains methods", () => {
+        const b1 = new MockResourceBuilder("r1");
+        const b2 = new MockResourceBuilder("r2");
+        const group = createBuilderArray([b1, b2]);
+        // Test method chaining and uniform distribution
+        group.setVal(42).setStr("hello");
+        assert.strictEqual(b1.val, 42);
+        assert.strictEqual(b2.val, 42);
+        assert.strictEqual(b1.strVal, "hello");
+        assert.strictEqual(b2.strVal, "hello");
+    });
+    test("createBuilderArray distributes array arguments by index", () => {
+        const b1 = new MockResourceBuilder("r1");
+        const b2 = new MockResourceBuilder("r2");
+        const group = createBuilderArray([b1, b2]);
+        // Test index-based distribution
+        group.setVal([10, 20]).setStr(["first", "second"]);
+        // In MockResourceBuilder, calling setVal with [10, 20] gets distributed by proxy:
+        // b1 gets setVal(10) -> val = 10
+        // b2 gets setVal(20) -> val = 20
+        assert.strictEqual(b1.val, 10);
+        assert.strictEqual(b2.val, 20);
+        assert.strictEqual(b1.strVal, "first");
+        assert.strictEqual(b2.strVal, "second");
+    });
+    test("Stack deploy gathers array builders and structures outputs as array", async () => {
+        Config.set({ dryRun: false });
+        const b1 = new MockResourceBuilder("s1");
+        const b2 = new MockResourceBuilder("s2");
+        class ArrayStack extends Stack {
+            servers = createBuilderArray([b1, b2]).setVal([100, 200]);
+        }
+        const stack = new ArrayStack();
+        const result = await stack.deploy();
+        assert.strictEqual(b1.deployCount, 1);
+        assert.strictEqual(b2.deployCount, 1);
+        assert.ok(Array.isArray(result.servers));
+        assert.strictEqual(result.servers.length, 2);
+        assert.deepStrictEqual(result.servers[0], { name: "s1", val: 100, strVal: "" });
+        assert.deepStrictEqual(result.servers[1], { name: "s2", val: 200, strVal: "" });
+    });
+    test("Stack destroy gathers array builders and structures outputs as array", async () => {
+        Config.set({ dryRun: false });
+        const b1 = new MockResourceBuilder("s1");
+        const b2 = new MockResourceBuilder("s2");
+        class ArrayStack extends Stack {
+            servers = createBuilderArray([b1, b2]);
+        }
+        const stack = new ArrayStack();
+        const result = await stack.destroy();
+        assert.strictEqual(b1.destroyCount, 1);
+        assert.strictEqual(b2.destroyCount, 1);
+        assert.ok(Array.isArray(result.servers));
+        assert.strictEqual(result.servers.length, 2);
+        assert.deepStrictEqual(result.servers[0], { destroyedName: "s1" });
+        assert.deepStrictEqual(result.servers[1], { destroyedName: "s2" });
+    });
+});

package/dist/core/resource.d.ts

@@ -41,3 +41,10 @@ export declare abstract class BaseBuilder {
     destroy(): Promise<any>;
     abstract deploy(): Promise<any>;
 }
+export type DistributeArgs<Args extends any[]> = {
+    [K in keyof Args]: Args[K] | Args[K][];
+};
+export type BuilderGroup<B extends BaseBuilder> = B[] & {
+    [K in keyof B]: B[K] extends (...args: infer Args) => any ? (...args: DistributeArgs<Args>) => BuilderGroup<B> : B[K];
+};
+export declare function createBuilderArray<T extends BaseBuilder>(builders: T[]): BuilderGroup<T>;

package/dist/core/resource.js

@@ -129,3 +129,38 @@ export class BaseBuilder {
         return { destroyed: this.name };
     }
 }
+export function createBuilderArray(builders) {
+    return new Proxy(builders, {
+        get(target, prop, receiver) {
+            if (prop in target) {
+                const val = Reflect.get(target, prop, receiver);
+                if (typeof val === "function") {
+                    return val.bind(target);
+                }
+                return val;
+            }
+            if (builders.length > 0) {
+                const first = builders[0];
+                const val = Reflect.get(first, prop);
+                if (typeof val === "function") {
+                    return function (...args) {
+                        builders.forEach((b, idx) => {
+                            const method = Reflect.get(b, prop);
+                            if (typeof method === "function") {
+                                const mappedArgs = args.map((arg) => {
+                                    if (Array.isArray(arg) && arg.length === builders.length) {
+                                        return arg[idx];
+                                    }
+                                    return arg;
+                                });
+                                method.apply(b, mappedArgs);
+                            }
+                        });
+                        return receiver;
+                    };
+                }
+            }
+            return undefined;
+        },
+    });
+}

package/dist/core/stack.js

@@ -170,6 +170,20 @@ export class Stack {
                             val.forceConfigCheck();
                         }
                     }
+                    else if (Array.isArray(val)) {
+                        const isProtected = Reflect.getMetadata("protected", this, prop);
+                        const forceConfigCheck = Reflect.getMetadata("forceConfigCheck", this, prop);
+                        for (const item of val) {
+                            if (item instanceof BaseBuilder) {
+                                resources.push({ prop, resource: item });
+                                if (isProtected)
+                                    item.protect();
+                                if (forceConfigCheck && typeof item.forceConfigCheck === "function") {
+                                    item.forceConfigCheck();
+                                }
+                            }
+                        }
+                    }
                 }
                 // 2. Schedule execution
                 if (isParallel) {
@@ -203,7 +217,19 @@ export class Stack {
                                     res = await resource.deploy();
                                     await resource._runAfterDeploy(res);
                                 }
-                                outputs[prop] = res;
+                                const propVal = this[prop];
+                                if (Array.isArray(propVal)) {
+                                    const idx = propVal.indexOf(resource);
+                                    if (idx !== -1) {
+                                        if (!outputs[prop]) {
+                                            outputs[prop] = [];
+                                        }
+                                        outputs[prop][idx] = res;
+                                    }
+                                }
+                                else {
+                                    outputs[prop] = res;
+                                }
                                 return res;
                             }
                             catch (err) {
@@ -234,7 +260,19 @@ export class Stack {
                                 res = await resource.deploy();
                                 await resource._runAfterDeploy(res);
                             }
-                            outputs[prop] = res;
+                            const propVal = this[prop];
+                            if (Array.isArray(propVal)) {
+                                const idx = propVal.indexOf(resource);
+                                if (idx !== -1) {
+                                    if (!outputs[prop]) {
+                                        outputs[prop] = [];
+                                    }
+                                    outputs[prop][idx] = res;
+                                }
+                            }
+                            else {
+                                outputs[prop] = res;
+                            }
                         }
                         catch (err) {
                             controller.abort();
@@ -322,6 +360,17 @@ export class Stack {
                         }
                         resources.push({ prop, resource: val });
                     }
+                    else if (Array.isArray(val)) {
+                        if (Reflect.getMetadata("protected", this, prop)) {
+                            console.log(`   🔒 Skipping protected resource "${prop}"`);
+                            continue;
+                        }
+                        for (const item of val) {
+                            if (item instanceof BaseBuilder) {
+                                resources.push({ prop, resource: item });
+                            }
+                        }
+                    }
                 }
                 // 2. Schedule execution
                 if (isParallel) {
@@ -348,7 +397,19 @@ export class Stack {
                                 await resource._runBeforeDestroy();
                                 const res = await resource.destroy();
                                 await resource._runAfterDestroy(res);
-                                outputs[prop] = res;
+                                const propVal = this[prop];
+                                if (Array.isArray(propVal)) {
+                                    const idx = propVal.indexOf(resource);
+                                    if (idx !== -1) {
+                                        if (!outputs[prop]) {
+                                            outputs[prop] = [];
+                                        }
+                                        outputs[prop][idx] = res;
+                                    }
+                                }
+                                else {
+                                    outputs[prop] = res;
+                                }
                                 return res;
                             }
                             catch (err) {
@@ -370,7 +431,19 @@ export class Stack {
                             await resource._runBeforeDestroy();
                             const res = await resource.destroy();
                             await resource._runAfterDestroy(res);
-                            outputs[prop] = res;
+                            const propVal = this[prop];
+                            if (Array.isArray(propVal)) {
+                                const idx = propVal.indexOf(resource);
+                                if (idx !== -1) {
+                                    if (!outputs[prop]) {
+                                        outputs[prop] = [];
+                                    }
+                                    outputs[prop][idx] = res;
+                                }
+                            }
+                            else {
+                                outputs[prop] = res;
+                            }
                         }
                         catch (err) {
                             controller.abort();

package/dist/providers/aws/secrets.js

@@ -1,6 +1,7 @@
 import { GetSecretValueCommand, CreateSecretCommand, PutSecretValueCommand, DeleteSecretCommand, } from "@aws-sdk/client-secrets-manager";
 import { BaseBuilder } from "../../core/resource.js";
 import { getSecretsClient } from "./api.js";
+import { resolvedSecrets } from "../../core/secret.js";
 export class SecretsBuilder extends BaseBuilder {
     _value;
     _description;
@@ -16,6 +17,9 @@ export class SecretsBuilder extends BaseBuilder {
         try {
             const result = await getSecretsClient().send(new GetSecretValueCommand({ SecretId: secretId }));
             this.resolvedValue = result.SecretString ?? null;
+            if (this.resolvedValue && this.resolvedValue.length >= 3) {
+                resolvedSecrets.add(this.resolvedValue);
+            }
             this.resolvedArn = result.ARN ?? null;
             return result;
         }
@@ -38,10 +42,17 @@ export class SecretsBuilder extends BaseBuilder {
     }
     plainText(v) {
         this._value = v;
+        if (v && v.length >= 3) {
+            resolvedSecrets.add(v);
+        }
         return this;
     }
     keyValue(obj) {
-        this._value = JSON.stringify(obj);
+        const v = JSON.stringify(obj);
+        this._value = v;
+        if (v && v.length >= 3) {
+            resolvedSecrets.add(v);
+        }
         return this;
     }
     description(d) {
@@ -61,7 +72,7 @@ export class SecretsBuilder extends BaseBuilder {
             if (existing) {
                 console.log(`   ✅ Secret "${this.name}" exists`);
                 if (this.resolvedValue !== null)
-                    console.log(`   💬 Value: ${this.resolvedValue}`);
+                    console.log(`   💬 Value: ********`);
                 if (this._value)
                     console.log(`   📝 [PLAN] Update secret value`);
             }
@@ -88,18 +99,24 @@ export class SecretsBuilder extends BaseBuilder {
             }));
             this.resolvedArn = result.ARN ?? null;
             this.resolvedValue = this._value;
+            if (this._value && this._value.length >= 3) {
+                resolvedSecrets.add(this._value);
+            }
             console.log(`🚀 Created secret "${this.name}"`);
         }
         else {
             console.log(`   ✅ Secret "${this.name}" exists`);
             if (this.resolvedValue !== null)
-                console.log(`   💬 Value: ${this.resolvedValue}`);
+                console.log(`   💬 Value: ********`);
             if (this._value && this._value !== this.resolvedValue) {
                 await client.send(new PutSecretValueCommand({
                     SecretId: this.name,
                     SecretString: this._value,
                 }));
                 this.resolvedValue = this._value;
+                if (this._value && this._value.length >= 3) {
+                    resolvedSecrets.add(this._value);
+                }
                 console.log(`   ✅ Updated secret value`);
             }
         }

package/dist/providers/gcp/secrets.js

@@ -1,5 +1,6 @@
 import { BaseBuilder } from "../../core/resource.js";
 import { gcpFetch, getProjectId } from "./api.js";
+import { resolvedSecrets } from "../../core/secret.js";
 const SECRET_BASE = "https://secretmanager.googleapis.com";
 export class GCPSecretBuilder extends BaseBuilder {
     _value;
@@ -20,6 +21,9 @@ export class GCPSecretBuilder extends BaseBuilder {
                 const payload = await gcpFetch(SECRET_BASE, `/v1/projects/${project}/secrets/${secretId}/versions/latest:access`);
                 if (payload.payload?.data) {
                     this.resolvedValue = Buffer.from(payload.payload.data, "base64").toString("utf8");
+                    if (this.resolvedValue && this.resolvedValue.length >= 3) {
+                        resolvedSecrets.add(this.resolvedValue);
+                    }
                 }
             }
             catch (err) {
@@ -42,10 +46,17 @@ export class GCPSecretBuilder extends BaseBuilder {
     }
     plainText(v) {
         this._value = v;
+        if (v && v.length >= 3) {
+            resolvedSecrets.add(v);
+        }
         return this;
     }
     keyValue(obj) {
-        this._value = JSON.stringify(obj);
+        const v = JSON.stringify(obj);
+        this._value = v;
+        if (v && v.length >= 3) {
+            resolvedSecrets.add(v);
+        }
         return this;
     }
     async deploy() {
@@ -58,7 +69,7 @@ export class GCPSecretBuilder extends BaseBuilder {
             if (existing) {
                 console.log(`   ✅ Secret "${secretId}" exists`);
                 if (this.resolvedValue !== null) {
-                    console.log(`   💬 Value: ${this.resolvedValue}`);
+                    console.log(`   💬 Value: ********`);
                 }
                 if (this._value) {
                     console.log(`   📝 [PLAN] Update secret value`);
@@ -101,12 +112,15 @@ export class GCPSecretBuilder extends BaseBuilder {
                 }),
             });
             this.resolvedValue = this._value;
+            if (this._value && this._value.length >= 3) {
+                resolvedSecrets.add(this._value);
+            }
             console.log(`🚀 Created secret "${secretId}"`);
         }
         else {
             console.log(`   ✅ Secret "${secretId}" exists`);
             if (this.resolvedValue !== null) {
-                console.log(`   💬 Value: ${this.resolvedValue}`);
+                console.log(`   💬 Value: ********`);
             }
             if (this._value && this._value !== this.resolvedValue) {
                 const base64Data = Buffer.from(this._value, "utf8").toString("base64");
@@ -119,6 +133,9 @@ export class GCPSecretBuilder extends BaseBuilder {
                     }),
                 });
                 this.resolvedValue = this._value;
+                if (this._value && this._value.length >= 3) {
+                    resolvedSecrets.add(this._value);
+                }
                 console.log(`   ✅ Updated secret value`);
             }
         }

package/dist/providers/proxmox/index.d.ts

@@ -1,5 +1,6 @@
 import { VMBuilder } from "./vm.js";
 import { TemplateBuilder } from "./template.js";
+import { BuilderGroup } from "../../core/resource.js";
 export declare const Proxmox: {
     init: (opts: {
         url: string;
@@ -12,7 +13,7 @@ export declare const Proxmox: {
         dnsServers?: string[];
         verifySsl?: boolean;
     }) => void;
-    VM: (name: string) => VMBuilder;
-    Template: (name: string) => TemplateBuilder;
+    VM: <T extends string | string[]>(name: T) => T extends string[] ? BuilderGroup<VMBuilder> : VMBuilder;
+    Template: <T extends string | string[]>(name: T) => T extends string[] ? BuilderGroup<TemplateBuilder> : TemplateBuilder;
 };
 export * from "../../types/proxmox.js";

package/dist/providers/proxmox/index.js

@@ -1,13 +1,24 @@
 import { Config } from "../../core/config.js";
 import { VMBuilder } from "./vm.js";
 import { TemplateBuilder } from "./template.js";
+import { createBuilderArray } from "../../core/resource.js";
 export const Proxmox = {
     init: (opts) => {
         Config.set({
             providers: { ...Config.get().providers, proxmox: opts },
         });
     },
-    VM: (name) => new VMBuilder(name),
-    Template: (name) => new TemplateBuilder(name),
+    VM: (name) => {
+        if (Array.isArray(name)) {
+            return createBuilderArray(name.map((n) => new VMBuilder(n)));
+        }
+        return new VMBuilder(name);
+    },
+    Template: (name) => {
+        if (Array.isArray(name)) {
+            return createBuilderArray(name.map((n) => new TemplateBuilder(n)));
+        }
+        return new TemplateBuilder(name);
+    },
 };
 export * from "../../types/proxmox.js";

package/dist/providers/proxmox/template.js

@@ -166,14 +166,15 @@ export class TemplateBuilder extends BaseBuilder {
         }
         if (baseTemplate) {
             console.log(`   📋 Cloning base template "${baseTemplate.name}" (vmid=${baseTemplate.vmid}) → "${this.name}" (vmid=${newVmid})`);
-            const taskId = await pm.post(`/nodes/${node}/qemu/${baseTemplate.vmid}/clone`, {
+            const taskId = await pm.post(`/nodes/${baseTemplate.node || node}/qemu/${baseTemplate.vmid}/clone`, {
                 newid: newVmid,
                 name: this.name,
                 full: 1,
                 storage,
                 format: "raw",
+                target: node,
             });
-            await this.waitForTask(node, taskId, pm);
+            await this.waitForTask(baseTemplate.node || node, taskId, pm);
         }
         else {
             console.log(`   🆕 Creating blank VM "${this.name}" (vmid=${newVmid})`);

package/dist/providers/proxmox/template.test.js

@@ -139,13 +139,13 @@ describe("Proxmox TemplateBuilder Unit Tests", () => {
         const templateCall = clientCalls.find(c => c.method === "POST" && c.path === "/nodes/pve1/qemu/600/template");
         assert.ok(templateCall);
     });
-    test("VM clones from Template successfully", async () => {
+    test("VM clones from Template successfully across nodes", async () => {
         const nginxHash = getFileHash("playbooks/nginx.yaml");
         const notes = mergeProvisionMetadata("Pre-baked template notes", {
             "nginx.yaml": nginxHash,
         });
         mockGetResponses["/cluster/resources?type=vm"] = [
-            // Template exists
+            // Template exists on pve1
             { name: "my-game-template", vmid: 500, node: "pve1", template: 1 },
         ];
         mockGetResponses["/nodes/pve1/qemu/500/config"] = {
@@ -153,7 +153,8 @@ describe("Proxmox TemplateBuilder Unit Tests", () => {
         };
         mockGetResponses["/cluster/nextid"] = 205;
         mockGetResponses["/nodes"] = [
-            { node: "pve1", status: "online", maxmem: 32 * 1024 * 1024 * 1024, mem: 12 * 1024 * 1024 * 1024 }
+            // Target node is pve2
+            { node: "pve2", status: "online", maxmem: 32 * 1024 * 1024 * 1024, mem: 12 * 1024 * 1024 * 1024 }
         ];
         class ProxmoxStack extends Stack {
             template = new TemplateBuilder("my-game-template")
@@ -170,10 +171,48 @@ describe("Proxmox TemplateBuilder Unit Tests", () => {
         // Verify VM cloned successfully
         assert.strictEqual(result.template.vmid, 500);
         assert.strictEqual(result.server.vmid, 205);
-        // Verify clone POST used the template's VMID
+        // Verify clone POST used the template's node (pve1) and vmid (500), but with target (pve2)
         const cloneCall = clientCalls.find(c => c.method === "POST" && c.path === "/nodes/pve1/qemu/500/clone");
         assert.ok(cloneCall);
         assert.strictEqual(cloneCall.body.newid, 205);
         assert.strictEqual(cloneCall.body.name, "my-prod-game-01");
+        assert.strictEqual(cloneCall.body.target, "pve2");
+    });
+    test("Template bakes from baseTemplate on a different node successfully", async () => {
+        mockGetResponses["/cluster/resources?type=vm"] = [
+            // Base template exists on pve1
+            { name: "ubuntu-base", vmid: 9000, node: "pve1", template: 1 },
+        ];
+        mockGetResponses["/nodes"] = [
+            // Target node pve2 has more free RAM than pve1
+            { node: "pve1", status: "online", maxmem: 32 * 1024 * 1024 * 1024, mem: 20 * 1024 * 1024 * 1024 },
+            { node: "pve2", status: "online", maxmem: 32 * 1024 * 1024 * 1024, mem: 5 * 1024 * 1024 * 1024 },
+        ];
+        mockGetResponses["/cluster/nextid"] = 9001;
+        mockGetResponses["/nodes/pve2/qemu/9001/agent/network-get-interfaces"] = [
+            {
+                name: "eth0",
+                "ip-addresses": [
+                    { "ip-address-type": "ipv4", "ip-address": "10.8.10.199" }
+                ]
+            }
+        ];
+        const builder = new TemplateBuilder("my-new-template")
+            .baseImage("ubuntu-base")
+            .provision("playbooks/nginx.yaml");
+        builder.waitFor = async (label, condition) => {
+            return await condition();
+        };
+        builder.checkPort = async () => true;
+        builder.checkCloudInit = async () => true;
+        builder.runProvisioner = async () => { };
+        const result = await builder.deploy();
+        assert.strictEqual(result.vmid, 9001);
+        assert.strictEqual(result.node, "pve2");
+        // Verify clone POST was sent to pve1 (source node) but targeted pve2
+        const cloneCall = clientCalls.find(c => c.method === "POST" && c.path === "/nodes/pve1/qemu/9000/clone");
+        assert.ok(cloneCall);
+        assert.strictEqual(cloneCall.body.newid, 9001);
+        assert.strictEqual(cloneCall.body.target, "pve2");
     });
 });

package/dist/providers/proxmox/vm.js

@@ -266,15 +266,16 @@ export class VMBuilder extends BaseBuilder {
         const storage = this._storage ?? "rbd_pool";
         if (template) {
             console.log(`   📋 Cloning template "${template.name}" (vmid=${template.vmid}) → "${this.name}" (vmid=${newVmid})`);
-            const taskId = await pm.post(`/nodes/${node}/qemu/${template.vmid}/clone`, {
+            const taskId = await pm.post(`/nodes/${template.node || node}/qemu/${template.vmid}/clone`, {
                 newid: newVmid,
                 name: this.name,
                 full: 1,
                 storage,
                 format: "raw",
+                target: node,
             });
             // Clone is async - wait for the Proxmox task to finish before configuring
-            await this.waitForTask(node, taskId, pm);
+            await this.waitForTask(template.node || node, taskId, pm);
         }
         else {
             console.log(`   🆕 Creating blank VM "${this.name}" (vmid=${newVmid})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "puls-dev",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "description": "Intent-driven infrastructure-as-code with eager discovery and no state files.",
   "type": "module",
   "main": "./dist/index.js",