puls-dev 0.2.7 → 0.2.9

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

@@ -0,0 +1,321 @@
+import { test, describe, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import fs from "node:fs";
+import { GoogleAuth } from "google-auth-library";
+import { GCPVMBuilder } from "./vm.js";
+import { Config } from "../../core/config.js";
+import { getFileHash } from "../proxmox/hash.js";
+describe("GCPVMBuilder Unit Tests", () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                gcp: {
+                    projectId: "my-gcp-project",
+                    serviceAccountPath: "/fake/sa.json",
+                    region: "us-central1",
+                },
+            },
+        });
+        originalFetch = globalThis.fetch;
+        fetchCalls = [];
+        mockResponses = {};
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? "GET";
+            let body;
+            if (init?.body) {
+                if (typeof init.body === "string") {
+                    try {
+                        body = JSON.parse(init.body);
+                    }
+                    catch {
+                        body = init.body;
+                    }
+                }
+                else {
+                    body = "[Binary/Buffer Body]";
+                }
+            }
+            const headers = init?.headers;
+            fetchCalls.push({ url, method, body, headers });
+            const matchKey = Object.keys(mockResponses)
+                .filter((key) => {
+                const [mMethod, mPath] = key.split(" ");
+                return method === mMethod && url.includes(mPath);
+            })
+                .sort((a, b) => b.split(" ")[1].length - a.split(" ")[1].length)[0];
+            if (matchKey) {
+                const resp = mockResponses[matchKey];
+                return {
+                    ok: resp.status >= 200 && resp.status < 300,
+                    status: resp.status,
+                    json: async () => resp.body,
+                    text: async () => JSON.stringify(resp.body),
+                };
+            }
+            return {
+                ok: false,
+                status: 404,
+                json: async () => ({ error: { message: `Endpoint not mocked: ${method} ${url}` } }),
+                text: async () => `Endpoint not mocked: ${method} ${url}`,
+            };
+        };
+        mock.method(GoogleAuth.prototype, "getClient", async () => {
+            return {
+                getAccessToken: async () => ({ token: "fake-gcp-token" }),
+            };
+        });
+        mock.method(fs, "readFileSync", () => {
+            return "ssh-rsa AAAA_FAKE_GCP_PUBLIC_KEY test@gcp.com";
+        });
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        mock.restoreAll();
+    });
+    test("handles discovery when VM does not exist", async () => {
+        mockResponses["GET /instances/my-gcp-vm"] = {
+            status: 404,
+            body: { error: { message: "Not Found" } },
+        };
+        const builder = new GCPVMBuilder("my-gcp-vm");
+        const existing = await builder.discoveryPromise;
+        assert.strictEqual(existing, null);
+        const getCall = fetchCalls.find((c) => c.method === "GET" && c.url.includes("/instances/my-gcp-vm"));
+        assert.ok(getCall);
+    });
+    test("discovers VM successfully when it exists", async () => {
+        mockResponses["GET /instances/my-gcp-vm"] = {
+            status: 200,
+            body: {
+                id: "vm-123456",
+                name: "my-gcp-vm",
+                status: "RUNNING",
+                networkInterfaces: [
+                    {
+                        accessConfigs: [{ natIP: "34.56.78.90" }],
+                    },
+                ],
+                metadata: {
+                    items: [{ key: "puls-provision", value: "nginx-yaml=abc123123123" }],
+                },
+            },
+        };
+        const builder = new GCPVMBuilder("my-gcp-vm");
+        const existing = await builder.discoveryPromise;
+        assert.ok(existing);
+        assert.strictEqual(existing.id, "vm-123456");
+        const resolvedId = await builder.out.id.get();
+        const resolvedIp = await builder.out.ip.get();
+        assert.strictEqual(resolvedId, "vm-123456");
+        assert.strictEqual(resolvedIp, "34.56.78.90");
+    });
+    test("runs in dry-run mode safely and logs plan", async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                gcp: { projectId: "my-gcp-project", serviceAccountPath: "/fake/sa.json" },
+            },
+        });
+        mockResponses["GET /instances/new-gcp-vm"] = {
+            status: 404,
+            body: { error: { message: "Not Found" } },
+        };
+        const builder = new GCPVMBuilder("new-gcp-vm")
+            .machineType("e2-medium")
+            .zone("europe-west1-b")
+            .provision("playbooks/nginx.yaml");
+        const res = await builder.deploy();
+        assert.deepStrictEqual(res, { name: "new-gcp-vm", id: "PENDING" });
+        const resolvedId = await builder.out.id.get();
+        const resolvedIp = await builder.out.ip.get();
+        assert.strictEqual(resolvedId, "PENDING");
+        assert.strictEqual(resolvedIp, "0.0.0.0");
+        // Ensure no writes were performed
+        const writeCalls = fetchCalls.filter((c) => c.method === "POST" || c.method === "DELETE");
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test("creates a new VM instance and runs playbooks successfully", async () => {
+        mockResponses["GET /instances/new-vm"] = {
+            status: 404,
+            body: { error: { message: "Not Found" } },
+        };
+        mockResponses["POST /instances"] = {
+            status: 200,
+            body: { id: "op-111", status: "DONE" },
+        };
+        // Subsequents GET during wait loop returns RUNNING
+        let getCount = 0;
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? "GET";
+            const body = init?.body ? JSON.parse(init.body) : undefined;
+            fetchCalls.push({ url, method, body });
+            if (method === "GET" && url.includes("/instances/new-vm")) {
+                const createCall = fetchCalls.find(c => c.method === "POST" && c.url.includes("/instances"));
+                if (!createCall) {
+                    return {
+                        ok: false,
+                        status: 404,
+                        json: async () => ({ error: { message: "Not Found" } }),
+                        text: async () => JSON.stringify({ error: { message: "Not Found" } }),
+                    };
+                }
+                getCount++;
+                const data = {
+                    id: "new-vm-uuid",
+                    name: "new-vm",
+                    status: getCount > 1 ? "RUNNING" : "PROVISIONING",
+                    networkInterfaces: [
+                        {
+                            accessConfigs: [{ natIP: "35.200.10.20" }],
+                        },
+                    ],
+                };
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => data,
+                    text: async () => JSON.stringify(data),
+                };
+            }
+            if (method === "POST" && url.includes("/instances")) {
+                const opData = { id: "op-111", status: "DONE" };
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => opData,
+                    text: async () => JSON.stringify(opData),
+                };
+            }
+            return { ok: false, status: 404 };
+        };
+        const builder = new GCPVMBuilder("new-vm")
+            .machineType("e2-medium")
+            .zone("us-central1-a")
+            .sshKey("~/.ssh/id_rsa.pub")
+            .provision("playbooks/nginx.yaml");
+        const provisionCalls = [];
+        builder.waitFor = async (label, condition) => {
+            return await condition();
+        };
+        builder.checkPort = async () => true;
+        builder.runProvisioner = async (ip, script) => {
+            provisionCalls.push(script);
+        };
+        const res = await builder.deploy();
+        assert.ok(res);
+        assert.strictEqual(res.id, "new-vm-uuid");
+        assert.strictEqual(res.ip, "35.200.10.20");
+        assert.strictEqual(provisionCalls.length, 1);
+        assert.strictEqual(provisionCalls[0], "playbooks/nginx.yaml");
+        const createCall = fetchCalls.find((c) => c.method === "POST" && c.url.includes("/instances"));
+        assert.ok(createCall);
+        assert.strictEqual(createCall.body.name, "new-vm");
+        assert.strictEqual(createCall.body.machineType, "zones/us-central1-a/machineTypes/e2-medium");
+        const sshMetadata = createCall.body.metadata.items.find((i) => i.key === "ssh-keys");
+        assert.strictEqual(sshMetadata.value, "root:ssh-rsa AAAA_FAKE_GCP_PUBLIC_KEY test@gcp.com");
+        const provMetadata = createCall.body.metadata.items.find((i) => i.key === "puls-provision");
+        assert.ok(provMetadata.value.startsWith("nginx-yaml="));
+    });
+    test("skips playbook execution on existing VM if hashes match", async () => {
+        const nginxHash = getFileHash("playbooks/nginx.yaml");
+        mockResponses["GET /instances/exist-vm"] = {
+            status: 200,
+            body: {
+                id: "exist-vm-id",
+                name: "exist-vm",
+                status: "RUNNING",
+                machineType: "zones/us-central1-a/machineTypes/e2-micro",
+                networkInterfaces: [
+                    {
+                        accessConfigs: [{ natIP: "35.200.10.30" }],
+                    },
+                ],
+                metadata: {
+                    items: [{ key: "puls-provision", value: `nginx-yaml=${nginxHash}` }],
+                },
+            },
+        };
+        const builder = new GCPVMBuilder("exist-vm")
+            .machineType("e2-micro")
+            .zone("us-central1-a")
+            .provision("playbooks/nginx.yaml");
+        const provisionCalls = [];
+        builder.runProvisioner = async (ip, script) => {
+            provisionCalls.push(script);
+        };
+        await builder.deploy();
+        // No playbooks should run
+        assert.strictEqual(provisionCalls.length, 0);
+        // No setMetadata call
+        const setMetaCall = fetchCalls.find((c) => c.method === "POST" && c.url.includes("/setMetadata"));
+        assert.strictEqual(setMetaCall, undefined);
+    });
+    test("executes playbooks on existing VM if hashes differ, updating metadata", async () => {
+        mockResponses["GET /instances/exist-diff-vm"] = {
+            status: 200,
+            body: {
+                id: "exist-diff-vm-id",
+                name: "exist-diff-vm",
+                status: "RUNNING",
+                machineType: "zones/us-central1-a/machineTypes/e2-micro",
+                networkInterfaces: [
+                    {
+                        accessConfigs: [{ natIP: "35.200.10.40" }],
+                    },
+                ],
+                metadata: {
+                    fingerprint: "old-fingerprint-123",
+                    items: [{ key: "puls-provision", value: "nginx-yaml=abc123123123" }],
+                },
+            },
+        };
+        mockResponses["POST /instances/exist-diff-vm/setMetadata"] = {
+            status: 200,
+            body: {},
+        };
+        const builder = new GCPVMBuilder("exist-diff-vm")
+            .machineType("e2-micro")
+            .zone("us-central1-a")
+            .provision("playbooks/nginx.yaml");
+        const provisionCalls = [];
+        builder.waitFor = async (label, condition) => {
+            return await condition();
+        };
+        builder.checkPort = async () => true;
+        builder.runProvisioner = async (ip, script) => {
+            provisionCalls.push(script);
+        };
+        await builder.deploy();
+        assert.strictEqual(provisionCalls.length, 1);
+        assert.strictEqual(provisionCalls[0], "playbooks/nginx.yaml");
+        // Verify setMetadata was dispatched with new hashes and correct fingerprint
+        const setMetaCall = fetchCalls.find((c) => c.method === "POST" && c.url.includes("/setMetadata"));
+        assert.ok(setMetaCall);
+        assert.strictEqual(setMetaCall.body.fingerprint, "old-fingerprint-123");
+        const provMetadata = setMetaCall.body.items.find((i) => i.key === "puls-provision");
+        const expectedHash = getFileHash("playbooks/nginx.yaml");
+        assert.strictEqual(provMetadata.value, `nginx-yaml=${expectedHash}`);
+    });
+    test("destroys VM successfully", async () => {
+        mockResponses["GET /instances/delete-vm"] = {
+            status: 200,
+            body: { id: "delete-vm-id", name: "delete-vm" },
+        };
+        mockResponses["DELETE /instances/delete-vm"] = {
+            status: 200,
+            body: {},
+        };
+        const builder = new GCPVMBuilder("delete-vm");
+        await builder.discoveryPromise;
+        const res = await builder.destroy();
+        assert.deepStrictEqual(res, { destroyed: "delete-vm" });
+        const deleteCall = fetchCalls.find((c) => c.method === "DELETE" && c.url.includes("/instances/delete-vm"));
+        assert.ok(deleteCall);
+    });
+});

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

@@ -3,6 +3,7 @@ export declare class ProxmoxApiClient {
     private authToken;
     private dispatcher?;
     constructor(url: string, user: string, tokenName: string, tokenSecret: string, verifySsl?: boolean);
+    private createProxmoxOfflineMock;
     private request;
     get<T>(path: string): Promise<T>;
     post<T>(path: string, body?: unknown): Promise<T>;

package/dist/providers/proxmox/api.js

@@ -1,5 +1,7 @@
 import { Agent } from "undici";
 import { Config } from "../../core/config.js";
+import { withRetry } from "../../core/retry.js";
+import { resourceContextStorage } from "../../core/context.js";
 export class ProxmoxApiClient {
     baseUrl;
     authToken;
@@ -12,22 +14,72 @@ export class ProxmoxApiClient {
             this.dispatcher = new Agent({ connect: { rejectUnauthorized: false } });
         }
     }
+    createProxmoxOfflineMock(method, path, body) {
+        if (path.includes("/nodes") && !path.includes("/qemu")) {
+            return [{ node: "mock-node", status: "online" }];
+        }
+        if (path.includes("/cluster/resources")) {
+            return [
+                { type: "node", node: "mock-node", status: "online" },
+                { type: "storage", node: "mock-node", storage: "rbd_pool", shared: 1 }
+            ];
+        }
+        if (path.includes("/qemu")) {
+            if (path.includes("/status/current")) {
+                return { status: "running", qmpstatus: "running" };
+            }
+            if (path.includes("/config")) {
+                return { ipconfig0: "ip=10.8.10.50/24,gw=10.8.10.1" };
+            }
+            return { vmid: 100, upid: "UPID:mock-node:00001234:00005678:60000000:qmcreate:100:mock-user@pve:" };
+        }
+        return new Proxy({}, {
+            get(target, prop) {
+                if (prop === "then")
+                    return undefined;
+                if (prop === "node")
+                    return "mock-node";
+                if (prop === "vmid")
+                    return 100;
+                if (prop === "status")
+                    return "running";
+                if (prop.endsWith("s"))
+                    return [];
+                return `mock-pm-${prop.toLowerCase()}`;
+            }
+        });
+    }
     async request(method, path, body) {
-        const headers = {
-            Authorization: `PVEAPIToken=${this.authToken}`,
-        };
-        if (body !== undefined)
-            headers['Content-Type'] = 'application/json';
-        const opts = { method, headers };
-        if (body !== undefined)
-            opts.body = JSON.stringify(body);
-        if (this.dispatcher)
-            opts.dispatcher = this.dispatcher;
-        const res = await fetch(`${this.baseUrl}${path}`, opts);
-        if (!res.ok)
-            throw new Error(`Proxmox ${method} ${path}: ${res.status} ${await res.text()}`);
-        const json = (await res.json());
-        return json.data ?? null;
+        const context = resourceContextStorage.getStore();
+        const abortSignal = context?.abortSignal;
+        if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+            return Promise.resolve(this.createProxmoxOfflineMock(method, path, body));
+        }
+        return withRetry(async () => {
+            const headers = {
+                Authorization: `PVEAPIToken=${this.authToken}`,
+            };
+            if (body !== undefined)
+                headers['Content-Type'] = 'application/json';
+            const opts = { method, headers };
+            if (body !== undefined)
+                opts.body = JSON.stringify(body);
+            if (this.dispatcher)
+                opts.dispatcher = this.dispatcher;
+            if (abortSignal)
+                opts.signal = abortSignal;
+            const res = await fetch(`${this.baseUrl}${path}`, opts);
+            if (!res.ok)
+                throw new Error(`Proxmox ${method} ${path}: ${res.status} ${await res.text()}`);
+            const json = (await res.json());
+            return json.data ?? null;
+        }, {
+            retryable: (err) => {
+                const match = err.message.match(/: (\d+)/);
+                const status = match ? parseInt(match[1], 10) : null;
+                return status === 429 || (status && status >= 500) || err.message.includes("ETIMEDOUT");
+            }
+        });
     }
     async get(path) {
         return this.request("GET", path);
@@ -44,7 +96,11 @@ export class ProxmoxApiClient {
 }
 export function getPMClient() {
     const cfg = Config.get().providers.proxmox;
-    if (!cfg?.url || !cfg?.user || !cfg?.tokenName || !cfg?.tokenSecret)
+    if (!cfg?.url || !cfg?.user || !cfg?.tokenName || !cfg?.tokenSecret) {
+        if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+            return new ProxmoxApiClient("https://10.8.4.39:8006", "mock-user@pve", "mock-token-name", "mock-token-secret", false);
+        }
         throw new Error("Proxmox not configured. Set proxmox: { url, user, tokenName, tokenSecret } in @Deploy");
+    }
     return new ProxmoxApiClient(cfg.url, cfg.user, cfg.tokenName, cfg.tokenSecret, cfg.verifySsl ?? true);
 }

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

@@ -1,4 +1,5 @@
 import { VMBuilder } from "./vm.js";
+import { TemplateBuilder } from "./template.js";
 export declare const Proxmox: {
     init: (opts: {
         url: string;
@@ -12,5 +13,6 @@ export declare const Proxmox: {
         verifySsl?: boolean;
     }) => void;
     VM: (name: string) => VMBuilder;
+    Template: (name: string) => TemplateBuilder;
 };
 export * from "../../types/proxmox.js";

package/dist/providers/proxmox/index.js

@@ -1,5 +1,6 @@
 import { Config } from "../../core/config.js";
 import { VMBuilder } from "./vm.js";
+import { TemplateBuilder } from "./template.js";
 export const Proxmox = {
     init: (opts) => {
         Config.set({
@@ -7,5 +8,6 @@ export const Proxmox = {
         });
     },
     VM: (name) => new VMBuilder(name),
+    Template: (name) => new TemplateBuilder(name),
 };
 export * from "../../types/proxmox.js";

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

@@ -0,0 +1,44 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+import type { OSImage } from "../../types/proxmox.js";
+export declare class TemplateBuilder extends BaseBuilder {
+    readonly out: {
+        vmid: Output<number>;
+    };
+    resolvedVmid: number | null;
+    resolvedNode: string | null;
+    private _baseImage?;
+    private _cores;
+    private _memory;
+    private _provision;
+    private _storage?;
+    private _sshKeys?;
+    constructor(name: string);
+    private discoverTemplate;
+    baseImage(os: OSImage): this;
+    cores(n: number): this;
+    memory(mb: number): this;
+    storage(pool: string): this;
+    sshKey(keys: string | readonly string[]): this;
+    provision(...playbookPaths: (string | string[])[]): this;
+    deploy(): Promise<{
+        name: string;
+        vmid: number | null;
+        node: string | null;
+    } | {
+        name: string;
+        vmid: string;
+        node?: undefined;
+    }>;
+    destroy(): Promise<{
+        destroyed: boolean;
+    } | {
+        destroyed: string;
+    }>;
+    private waitForTask;
+    private resolvePublicKeys;
+    private checkCloudInit;
+    protected checkPort(ip: string, port: number): Promise<boolean>;
+    protected runProvisioner(ip: string, script: string): Promise<void>;
+    private sshKeyPath;
+}