puls-dev 0.1.9 → 0.2.1

package/dist/providers/proxmox/vm.js

@@ -1,7 +1,6 @@
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
-import { dirname } from "node:path";
 import { createConnection } from "node:net";
 import { BaseBuilder } from "../../core/resource.js";
 import { Config } from "../../core/config.js";
@@ -25,6 +24,7 @@ export class VMBuilder extends BaseBuilder {
     _vlan;
     _ip;
     _sshKeys;
+    _machine = "q35";
     constructor(name) {
         super(name);
         this.discoveryPromise = this.discoverVm(name);
@@ -81,6 +81,10 @@ export class VMBuilder extends BaseBuilder {
         this._sshKeys = Array.isArray(keys) ? [...keys] : keys;
         return this;
     }
+    machine(type) {
+        this._machine = type;
+        return this;
+    }
     async deploy() {
         const dryRun = this.isDryRunActive();
         const existing = await this.discoveryPromise;
@@ -103,7 +107,7 @@ export class VMBuilder extends BaseBuilder {
             console.log(`   📝 [PLAN] Create VM "${this.name}"`);
             if (this._image)
                 console.log(`      └─ Image: ${this._image}`);
-            console.log(`      └─ Cores: ${this._cores}  Memory: ${this._memory} MB`);
+            console.log(`      └─ Cores: ${this._cores}  Memory: ${this._memory} MB  Machine: ${this._machine}`);
             if (this._vlan)
                 console.log(`      └─ VLAN: ${this._vlan}`);
             if (this._provision) {
@@ -133,8 +137,35 @@ export class VMBuilder extends BaseBuilder {
                     ? `Check that VMID ${this._image} exists and is marked as a template.`
                     : `Create a template whose name contains "${this._image}".`));
         }
-        // Resolve target node: explicit → configured nodes list → template's node → API discovery
+        // Resolve target node: explicit → cluster-aware (online & max free RAM) → configured nodes list → template's node → API discovery
         let node = this._node;
+        if (!node) {
+            try {
+                const nodesList = await pm.get("/nodes");
+                const configuredNodes = Config.get().providers.proxmox?.nodes;
+                const onlineNodes = (nodesList ?? []).filter((n) => {
+                    if (n.status !== "online")
+                        return false;
+                    if (configuredNodes && configuredNodes.length > 0) {
+                        return configuredNodes.includes(n.node);
+                    }
+                    return true;
+                });
+                if (onlineNodes.length > 0) {
+                    // Sort descending by free memory (maxmem - mem)
+                    onlineNodes.sort((a, b) => {
+                        const freeA = (a.maxmem ?? 0) - (a.mem ?? 0);
+                        const freeB = (b.maxmem ?? 0) - (b.mem ?? 0);
+                        return freeB - freeA;
+                    });
+                    node = onlineNodes[0].node;
+                    console.log(`   🧠 Cluster-aware node selection: picked "${node}" with the most free RAM (${Math.round((((onlineNodes[0].maxmem ?? 0) - (onlineNodes[0].mem ?? 0)) / 1024 / 1024 / 1024) * 10) / 10} GB free)`);
+                }
+            }
+            catch (err) {
+                // Fallback silently to configured nodes list or discovery
+            }
+        }
         if (!node) {
             const configuredNodes = Config.get().providers.proxmox?.nodes;
             node = configuredNodes?.[0] ?? template?.node;
@@ -192,7 +223,7 @@ export class VMBuilder extends BaseBuilder {
         const net0 = `virtio,bridge=vmbr1${this._vlan ? `,tag=${this._vlan}` : ""}`;
         const configPatch = {
             onboot: 1,
-            machine: "q35",
+            machine: this._machine,
             cores: this._cores,
             memory: this._memory,
             net0,
@@ -380,59 +411,14 @@ export class VMBuilder extends BaseBuilder {
     }
     runProvisioner(ip, script) {
         const ext = script.split(".").pop()?.toLowerCase();
-        if (ext === "sh")
-            return this.runShellScript(ip, script);
+        if (ext === "sh") {
+            throw new Error(`Shell script provisioning (.sh) is no longer supported. ` +
+                `Please migrate "${script}" to an Ansible playbook (.yaml/.yml).`);
+        }
         if (ext === "pp")
             return this.runPuppet(ip, script);
         return this.runAnsible(ip, script); // .yml / .yaml
     }
-    runShellScript(ip, script) {
-        console.log(`   🔧 Running shell script: ${script} → ${ip}`);
-        const keyPath = this.sshKeyPath();
-        const scriptDir = dirname(script); // e.g. 'config'
-        const sshArgs = [
-            "-i",
-            keyPath,
-            "-o",
-            "StrictHostKeyChecking=no",
-            "-o",
-            "ConnectTimeout=30",
-        ];
-        return new Promise((resolve, reject) => {
-            // Copy the script's directory to the same path on the remote (e.g. config/ → /config/)
-            console.log(`   📂 Copying ${scriptDir}/ → ${ip}:/${scriptDir}/`);
-            const scp = spawn("scp", [
-                "-i",
-                keyPath,
-                "-o",
-                "StrictHostKeyChecking=no",
-                "-r",
-                scriptDir,
-                `root@${ip}:/`,
-            ], { stdio: "inherit" });
-            scp.on("error", (err) => reject(new Error(`scp failed: ${err.message}`)));
-            scp.on("close", (scpCode) => {
-                if (scpCode !== 0) {
-                    reject(new Error(`scp exited with code ${scpCode}`));
-                    return;
-                }
-                const proc = spawn("ssh", [...sshArgs, `root@${ip}`, "bash -s"], {
-                    stdio: ["pipe", "inherit", "inherit"],
-                });
-                proc.stdin.write(readFileSync(script));
-                proc.stdin.end();
-                proc.on("close", (code) => {
-                    if (code === 0) {
-                        console.log(`   ✅ Provisioning complete`);
-                        resolve();
-                    }
-                    else
-                        reject(new Error(`Shell script exited with code ${code}`));
-                });
-                proc.on("error", (err) => reject(new Error(`ssh failed: ${err.message}`)));
-            });
-        });
-    }
     runPuppet(ip, manifest) {
         console.log(`   🔧 Applying Puppet manifest: ${manifest} → ${ip}`);
         const keyPath = this.sshKeyPath();

package/dist/providers/proxmox/vm.test.d.ts

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

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

@@ -0,0 +1,155 @@
+import { test, describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import { ProxmoxApiClient } from "./api.js";
+import { VMBuilder } from "./vm.js";
+import { Config } from "../../core/config.js";
+describe("Proxmox VMBuilder Unit Tests", () => {
+    let originalGet;
+    let originalPost;
+    let originalDelete;
+    let clientCalls = [];
+    let mockGetResponses = {};
+    let mockPostResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                proxmox: {
+                    url: "https://pve.example.com:8006",
+                    user: "root@pam",
+                    tokenName: "puls",
+                    tokenSecret: "secret-key",
+                    verifySsl: false,
+                    dnsDomain: "nolimit.int",
+                },
+            },
+        });
+        clientCalls = [];
+        mockGetResponses = {};
+        mockPostResponses = {};
+        originalGet = ProxmoxApiClient.prototype.get;
+        originalPost = ProxmoxApiClient.prototype.post;
+        originalDelete = ProxmoxApiClient.prototype.delete;
+        ProxmoxApiClient.prototype.get = async function (path) {
+            clientCalls.push({ method: "GET", path });
+            if (mockGetResponses[path] !== undefined) {
+                const handler = mockGetResponses[path];
+                if (typeof handler === "function")
+                    return handler();
+                return handler;
+            }
+            return [];
+        };
+        ProxmoxApiClient.prototype.post = async function (path, body) {
+            clientCalls.push({ method: "POST", path, body });
+            if (mockPostResponses[path] !== undefined) {
+                const handler = mockPostResponses[path];
+                if (typeof handler === "function")
+                    return handler(body);
+                return handler;
+            }
+            if (path.includes("/clone")) {
+                return "UPID:pve1:00000000:00000000:00000000:qemuclone:101:root@pam:";
+            }
+            return {};
+        };
+        ProxmoxApiClient.prototype.delete = async function (path) {
+            clientCalls.push({ method: "DELETE", path });
+        };
+    });
+    afterEach(() => {
+        ProxmoxApiClient.prototype.get = originalGet;
+        ProxmoxApiClient.prototype.post = originalPost;
+        ProxmoxApiClient.prototype.delete = originalDelete;
+    });
+    test("gracefully handles discovery when VM does not exist", async () => {
+        mockGetResponses["/cluster/resources?type=vm"] = [];
+        const builder = new VMBuilder("my-vm");
+        const discoveryResult = await builder.discoveryPromise;
+        assert.strictEqual(discoveryResult, null);
+        assert.ok(clientCalls.some((c) => c.path === "/cluster/resources?type=vm"));
+    });
+    test("discovers existing VM successfully", async () => {
+        mockGetResponses["/cluster/resources?type=vm"] = [
+            { name: "my-vm", vmid: 200, node: "pve2", template: 0, status: "running" },
+        ];
+        const builder = new VMBuilder("my-vm");
+        const discoveryResult = await builder.discoveryPromise;
+        assert.ok(discoveryResult);
+        assert.strictEqual(discoveryResult.vmid, 200);
+        assert.strictEqual(discoveryResult.node, "pve2");
+        const deployResult = await builder.deploy();
+        assert.strictEqual(deployResult.vmid, 200);
+        assert.strictEqual(builder.resolvedNode, "pve2");
+    });
+    test("performs clean dry-run planning without making API writes", async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                proxmox: {
+                    url: "https://pve.example.com:8006",
+                    user: "root@pam",
+                    tokenName: "puls",
+                    tokenSecret: "secret-key",
+                },
+            },
+        });
+        const builder = new VMBuilder("dryrun-vm")
+            .cores(4)
+            .memory(4096)
+            .machine("i440fx");
+        const deployResult = await builder.deploy();
+        assert.strictEqual(deployResult.vmid, "PENDING");
+        assert.ok(!clientCalls.some((c) => c.method === "POST"));
+    });
+    test("deploys new VM and performs cluster-aware node selection based on free RAM", async () => {
+        mockGetResponses["/cluster/resources?type=vm"] = [];
+        mockGetResponses["/cluster/nextid"] = 105;
+        // Simulate three nodes in the cluster with different RAM allocations and statuses
+        mockGetResponses["/nodes"] = [
+            { node: "pve-offline", status: "offline", maxmem: 64 * 1024 * 1024 * 1024, mem: 4 * 1024 * 1024 * 1024 }, // offline
+            { node: "pve-ram-low", status: "online", maxmem: 16 * 1024 * 1024 * 1024, mem: 14 * 1024 * 1024 * 1024 }, // 2GB free
+            { node: "pve-ram-high", status: "online", maxmem: 32 * 1024 * 1024 * 1024, mem: 12 * 1024 * 1024 * 1024 }, // 20GB free
+        ];
+        // Mock wait for task (normally waitForTask would poll the UPID, but in tests it mock-completes or we bypass it)
+        // In our test, since we don't have a template image configured, it creates a blank VM by POSTing to /nodes/{node}/qemu
+        const builder = new VMBuilder("my-new-vm")
+            .cores(2)
+            .memory(2048)
+            .ip("10.8.10.85")
+            .machine("i440fx");
+        const deployResult = await builder.deploy();
+        // Verify it resolved to the VMID and the most free RAM node ("pve-ram-high")
+        assert.strictEqual(deployResult.vmid, 105);
+        assert.strictEqual(builder.resolvedNode, "pve-ram-high");
+        // Verify the blank VM POST went to the correct node
+        const createCall = clientCalls.find((c) => c.method === "POST" && c.path.startsWith("/nodes/pve-ram-high/qemu"));
+        assert.ok(createCall);
+        assert.deepStrictEqual(createCall.body, {
+            vmid: 105,
+            name: "my-new-vm",
+            cores: 2,
+            memory: 2048,
+            net0: "virtio,bridge=vmbr1",
+            ostype: "l26",
+        });
+        // Verify config patch incorporates the custom machine override "i440fx"
+        const configCall = clientCalls.find((c) => c.method === "POST" && c.path === "/nodes/pve-ram-high/qemu/105/config");
+        assert.ok(configCall);
+        assert.strictEqual(configCall.body.machine, "i440fx");
+        assert.strictEqual(configCall.body.cores, 2);
+        assert.strictEqual(configCall.body.memory, 2048);
+    });
+    test("destroys an existing VM successfully", async () => {
+        mockGetResponses["/cluster/resources?type=vm"] = [
+            { name: "my-vm", vmid: 200, node: "pve1", template: 0 },
+        ];
+        const builder = new VMBuilder("my-vm");
+        await builder.discoveryPromise;
+        const destroyResult = await builder.destroy();
+        assert.deepStrictEqual(destroyResult, { destroyed: "my-vm" });
+        // In Proxmox, VM deletion is handled via BaseBuilder default or custom VMBuilder destroy.
+        // Let's verify we logged or called the delete path or returned safely.
+        assert.ok(destroyResult.destroyed);
+    });
+});

package/dist/types/aws.d.ts

@@ -53,3 +53,14 @@ export interface RegistrantContact {
     COUNTRY: string;
 }
 export declare const DOMAIN_REGISTER: RegistrantContact;
+export interface IAMPolicyStatement {
+    Effect: "Allow" | "Deny";
+    Action: string | string[];
+    Resource?: string | string[];
+    Principal?: Record<string, string | string[]>;
+    Condition?: Record<string, any>;
+}
+export interface IAMPolicyDocument {
+    Version?: string;
+    Statement: IAMPolicyStatement[];
+}

package/package.json

@@ -1,11 +1,33 @@
 {
   "name": "puls-dev",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "description": "Intent-driven infrastructure-as-code with eager discovery and no state files.",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./aws": {
+      "types": "./dist/providers/aws/index.d.ts",
+      "default": "./dist/providers/aws/index.js"
+    },
+    "./do": {
+      "types": "./dist/providers/do/index.d.ts",
+      "default": "./dist/providers/do/index.js"
+    },
+    "./proxmox": {
+      "types": "./dist/providers/proxmox/index.d.ts",
+      "default": "./dist/providers/proxmox/index.js"
+    },
+    "./firebase": {
+      "types": "./dist/providers/firebase/index.d.ts",
+      "default": "./dist/providers/firebase/index.js"
+    }
+  },
   "files": [
     "dist",
     "README.md",
@@ -14,7 +36,7 @@
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build",
-    "test": "tsx --test src/**/*.test.ts"
+    "test": "tsx --test \"src/**/*.test.ts\""
   },
   "keywords": [
     "iac",
@@ -28,15 +50,38 @@
   "author": "Bia",
   "license": "ISC",
   "devDependencies": {
+    "@aws-sdk/client-acm": "^3.1053.0",
+    "@aws-sdk/client-apigatewayv2": "^3.1053.0",
+    "@aws-sdk/client-cloudfront": "^3.1053.0",
+    "@aws-sdk/client-cloudwatch": "^3.1053.0",
+    "@aws-sdk/client-cloudwatch-logs": "^3.1053.0",
+    "@aws-sdk/client-ec2": "^3.1053.0",
+    "@aws-sdk/client-ecs": "^3.1053.0",
+    "@aws-sdk/client-iam": "^3.1053.0",
+    "@aws-sdk/client-lambda": "^3.1053.0",
+    "@aws-sdk/client-rds": "^3.1053.0",
+    "@aws-sdk/client-route-53": "^3.1053.0",
+    "@aws-sdk/client-route-53-domains": "^3.1053.0",
+    "@aws-sdk/client-s3": "^3.1053.0",
+    "@aws-sdk/client-secrets-manager": "^3.1053.0",
+    "@aws-sdk/client-sns": "^3.1053.0",
+    "@aws-sdk/client-sqs": "^3.1053.0",
     "@types/node": "^25.6.2",
+    "google-auth-library": "^10.6.2",
     "ts-node": "^10.9.2",
     "tsx": "^4.21.0",
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "undici": "^8.3.0"
   },
   "dependencies": {
+    "dotenv": "^17.4.2",
+    "reflect-metadata": "^0.2.2"
+  },
+  "peerDependencies": {
     "@aws-sdk/client-acm": "^3.1040.0",
     "@aws-sdk/client-apigatewayv2": "^3.1044.0",
     "@aws-sdk/client-cloudfront": "^3.1040.0",
+    "@aws-sdk/client-cloudwatch": "^3.1045.0",
     "@aws-sdk/client-cloudwatch-logs": "^3.1045.0",
     "@aws-sdk/client-ec2": "^3.1045.0",
     "@aws-sdk/client-ecs": "^3.1045.0",
@@ -47,11 +92,65 @@
     "@aws-sdk/client-route-53-domains": "^3.1041.0",
     "@aws-sdk/client-s3": "^3.1040.0",
     "@aws-sdk/client-secrets-manager": "^3.1045.0",
+    "@aws-sdk/client-sns": "^3.1045.0",
     "@aws-sdk/client-sqs": "^3.1045.0",
-    "dotenv": "^17.4.2",
     "google-auth-library": "^10.6.2",
-    "mkdocs": "^0.0.1",
-    "reflect-metadata": "^0.2.2",
     "undici": "^8.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@aws-sdk/client-acm": {
+      "optional": true
+    },
+    "@aws-sdk/client-apigatewayv2": {
+      "optional": true
+    },
+    "@aws-sdk/client-cloudfront": {
+      "optional": true
+    },
+    "@aws-sdk/client-cloudwatch": {
+      "optional": true
+    },
+    "@aws-sdk/client-cloudwatch-logs": {
+      "optional": true
+    },
+    "@aws-sdk/client-ec2": {
+      "optional": true
+    },
+    "@aws-sdk/client-ecs": {
+      "optional": true
+    },
+    "@aws-sdk/client-iam": {
+      "optional": true
+    },
+    "@aws-sdk/client-lambda": {
+      "optional": true
+    },
+    "@aws-sdk/client-rds": {
+      "optional": true
+    },
+    "@aws-sdk/client-route-53": {
+      "optional": true
+    },
+    "@aws-sdk/client-route-53-domains": {
+      "optional": true
+    },
+    "@aws-sdk/client-s3": {
+      "optional": true
+    },
+    "@aws-sdk/client-secrets-manager": {
+      "optional": true
+    },
+    "@aws-sdk/client-sns": {
+      "optional": true
+    },
+    "@aws-sdk/client-sqs": {
+      "optional": true
+    },
+    "google-auth-library": {
+      "optional": true
+    },
+    "undici": {
+      "optional": true
+    }
   }
 }