puls-dev 0.2.7 → 0.2.9

package/dist/providers/gcp/template.js

@@ -0,0 +1,252 @@
+import fs from "node:fs";
+import { homedir } from "node:os";
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+import { gcpFetch, getProjectId } from "./api.js";
+import { checkPort, runProvisioner } from "../../core/provisioner.js";
+import { getFileHash } from "../proxmox/hash.js";
+import { parseGcpMetadataForProvision, mergeGcpMetadataForProvision } from "./vm.js";
+export class GCPTemplateBuilder extends BaseBuilder {
+    out = {
+        imageId: new Output(),
+    };
+    _baseImage = "projects/ubuntu-os-cloud/global/images/family/ubuntu-2204-lts";
+    _machineType = "e2-micro";
+    _zone = "us-central1-a";
+    _network = "global/networks/default";
+    _sshKeys = [];
+    _provision = [];
+    constructor(name) {
+        super(name);
+        this.discoveryPromise = this.discoverImage();
+    }
+    baseImage(img) {
+        this._baseImage = img;
+        return this;
+    }
+    machineType(type) {
+        this._machineType = type;
+        return this;
+    }
+    zone(z) {
+        this._zone = z;
+        this.discoveryPromise = this.discoverImage();
+        return this;
+    }
+    network(netPath) {
+        this._network = netPath;
+        return this;
+    }
+    sshKey(keys) {
+        this._sshKeys = keys;
+        return this;
+    }
+    provision(...playbookPaths) {
+        this._provision.push(...playbookPaths.flat());
+        return this;
+    }
+    async discoverImage() {
+        try {
+            const project = getProjectId();
+            const res = await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/global/images/${this.name}`);
+            return res ?? null;
+        }
+        catch (e) {
+            if (e.message?.includes("404") ||
+                e.message?.includes("403") ||
+                e.message?.includes("credentials not configured")) {
+                return null;
+            }
+            throw e;
+        }
+    }
+    async checkPort(ip, port) {
+        return checkPort(ip, port);
+    }
+    async runProvisioner(ip, script) {
+        const keysArray = Array.isArray(this._sshKeys) ? this._sshKeys : [this._sshKeys];
+        const keyPath = keysArray.find(k => !k.startsWith('ssh-') && !k.startsWith('ecdsa-') && !k.startsWith('sk-'));
+        return runProvisioner(ip, "root", keyPath, script);
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const project = getProjectId();
+        const declaredPlaybooksWithHashes = this._provision.map((p) => {
+            const baseName = p.split("/").pop() ?? p;
+            const slug = baseName.toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+            return { path: p, slug, hash: getFileHash(p) };
+        });
+        if (existing) {
+            const finalImageId = `projects/${project}/global/images/${this.name}`;
+            this.out.imageId.resolve(finalImageId);
+            // Check if playbook hashes differ
+            const appliedHashes = parseGcpMetadataForProvision(existing.description);
+            const hasChanges = declaredPlaybooksWithHashes.some((p) => {
+                const appliedHash = appliedHashes[p.slug];
+                return !appliedHash || appliedHash !== p.hash;
+            });
+            if (!hasChanges) {
+                console.log(`\n🔍 GCP Image Template "${this.name}"...`);
+                console.log(`   ✅ Custom GCP Image "${this.name}" already exists and matches defined state.`);
+                return { name: this.name, imageId: finalImageId };
+            }
+            console.log(`\n⏳ Finalizing GCP Image Template "${this.name}"...`);
+            console.log(`   🔄 Template playbook hashes changed. Deleting old custom Image...`);
+            if (dryRun) {
+                console.log(`   📝 [PLAN] Would delete GCP Image "${this.name}" and rebuild.`);
+                return { name: this.name, imageId: "PENDING" };
+            }
+            else {
+                await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/global/images/${this.name}`, { method: "DELETE" });
+            }
+        }
+        console.log(`\n⏳ Finalizing GCP Image Template "${this.name}"...`);
+        const hashes = {};
+        for (const p of declaredPlaybooksWithHashes) {
+            hashes[p.slug] = p.hash;
+        }
+        const metadataVal = mergeGcpMetadataForProvision(hashes);
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Bake GCP Image Template "${this.name}"`);
+            console.log(`      └─ Base Image: ${this._baseImage}  Machine Type: ${this._machineType}`);
+            if (this._provision.length > 0) {
+                console.log(`      └─ Provision: ${this._provision.join(", ")}`);
+            }
+            this.out.imageId.resolve("PENDING");
+            return { name: this.name, imageId: "PENDING" };
+        }
+        // Spawn temporary instance
+        const keysArray = Array.isArray(this._sshKeys) ? this._sshKeys : [this._sshKeys];
+        const sshKeysValue = keysArray
+            .map((k) => {
+            if (k.startsWith("ssh-") || k.startsWith("ecdsa-") || k.startsWith("sk-")) {
+                return `root:${k.trim()}`;
+            }
+            try {
+                const path = k.replace(/^~/, homedir());
+                const pubPath = path.replace(/\.pub$/, "") + ".pub";
+                const keyData = fs.readFileSync(pubPath, "utf-8").trim();
+                return `root:${keyData}`;
+            }
+            catch {
+                return `root:${k.trim()}`;
+            }
+        })
+            .join("\n");
+        const tempInstanceName = `puls-bake-temp-${this.name}`;
+        const body = {
+            name: tempInstanceName,
+            machineType: `zones/${this._zone}/machineTypes/${this._machineType}`,
+            disks: [
+                {
+                    boot: true,
+                    autoDelete: true,
+                    initializeParams: {
+                        sourceImage: this._baseImage,
+                    },
+                },
+            ],
+            networkInterfaces: [
+                {
+                    network: this._network,
+                    accessConfigs: [
+                        {
+                            name: "External NAT",
+                            type: "ONE_TO_ONE_NAT",
+                        },
+                    ],
+                },
+            ],
+            metadata: {
+                items: [
+                    ...(sshKeysValue ? [{ key: "ssh-keys", value: sshKeysValue }] : []),
+                ],
+            },
+        };
+        console.log(`🚀 Spawning temporary VM "${tempInstanceName}" to bake custom image...`);
+        await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/zones/${this._zone}/instances`, {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+        // Wait until running and IP resolved
+        let resolvedIp;
+        await this.waitFor(`temporary instance "${tempInstanceName}" to start running`, async () => {
+            try {
+                const res = await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/zones/${this._zone}/instances/${tempInstanceName}`);
+                if (res && res.status === "RUNNING") {
+                    const netInterface = (res.networkInterfaces ?? [])[0];
+                    resolvedIp = (netInterface?.accessConfigs ?? [])[0]?.natIP;
+                    return !!resolvedIp;
+                }
+            }
+            catch {
+                // Ignore
+            }
+            return false;
+        }, { intervalMs: 10_000, timeoutMs: 300_000 });
+        if (!resolvedIp) {
+            throw new Error(`Failed to resolve IP for temporary instance "${tempInstanceName}"`);
+        }
+        // Provision the instance
+        if (this._provision.length > 0) {
+            await this.waitFor(`SSH on ${resolvedIp} to be ready`, () => this.checkPort(resolvedIp, 22), { intervalMs: 10_000, timeoutMs: 300_000 });
+            for (const playbook of this._provision) {
+                await this.runProvisioner(resolvedIp, playbook);
+            }
+        }
+        // Stop temporary instance
+        console.log(`   🛑 Stopping temporary instance "${tempInstanceName}"...`);
+        await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/zones/${this._zone}/instances/${tempInstanceName}/stop`, { method: "POST" });
+        await this.waitFor(`temporary instance to stop`, async () => {
+            try {
+                const res = await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/zones/${this._zone}/instances/${tempInstanceName}`);
+                return res && res.status === "TERMINATED";
+            }
+            catch {
+                return false;
+            }
+        }, { intervalMs: 10_000, timeoutMs: 300_000 });
+        // Bake Image
+        console.log(`   💾 Baking custom GCP Image "${this.name}" from instance disk...`);
+        const imageBody = {
+            name: this.name,
+            sourceDisk: `zones/${this._zone}/disks/${tempInstanceName}`,
+            description: metadataVal,
+        };
+        await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/global/images`, {
+            method: "POST",
+            body: JSON.stringify(imageBody),
+        });
+        // Wait until image is ready
+        await this.waitFor(`custom image "${this.name}" to become ready`, async () => {
+            const img = await this.discoverImage();
+            return img && img.status === "READY";
+        }, { intervalMs: 10_000, timeoutMs: 300_000 });
+        console.log(`   ✅ Custom GCP Image "${this.name}" baked successfully.`);
+        // Clean up temporary instance
+        console.log(`   🧹 Terminating temporary provisioning instance...`);
+        await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/zones/${this._zone}/instances/${tempInstanceName}`, { method: "DELETE" });
+        const finalImageId = `projects/${project}/global/images/${this.name}`;
+        this.out.imageId.resolve(finalImageId);
+        return { name: this.name, imageId: finalImageId };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const project = getProjectId();
+        console.log(`\n🗑️  Destroying GCP Image Template "${this.name}"...`);
+        if (!existing) {
+            console.log(`   ─  GCP Image Template "${this.name}" not found`);
+            return { destroyed: false };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete GCP Image "${this.name}"`);
+            return { destroyed: this.name };
+        }
+        console.log(`   🔄 Deleting GCP Image "${this.name}"...`);
+        await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/global/images/${this.name}`, { method: "DELETE" });
+        console.log(`   🗑️  Removed GCP Image Template "${this.name}"`);
+        return { destroyed: this.name };
+    }
+}

package/dist/providers/gcp/template.test.d.ts

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

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

@@ -0,0 +1,227 @@
+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 { GCPTemplateBuilder } from "./template.js";
+import { GCPVMBuilder } from "./vm.js";
+import { Config } from "../../core/config.js";
+import { getFileHash } from "../proxmox/hash.js";
+import { Stack } from "../../core/stack.js";
+describe("GCPTemplateBuilder 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("gracefully handles discovery when Template does not exist", async () => {
+        mockResponses["GET /global/images/my-golden-image"] = {
+            status: 404,
+            body: { error: { message: "Not Found" } },
+        };
+        const builder = new GCPTemplateBuilder("my-golden-image");
+        const existing = await builder.discoveryPromise;
+        assert.strictEqual(existing, null);
+    });
+    test("discovers existing Template and skips deployment if hashes match (Idempotence)", async () => {
+        const nginxHash = getFileHash("playbooks/nginx.yaml");
+        mockResponses["GET /global/images/my-docker-base"] = {
+            status: 200,
+            body: {
+                name: "my-docker-base",
+                status: "READY",
+                description: `nginx-yaml=${nginxHash}`,
+            },
+        };
+        const builder = new GCPTemplateBuilder("my-docker-base")
+            .provision("playbooks/nginx.yaml");
+        const result = await builder.deploy();
+        assert.strictEqual(result.imageId, "projects/my-gcp-project/global/images/my-docker-base");
+        // No POST/DELETE calls since it already matches
+        const writes = fetchCalls.filter(c => c.method === "POST" || c.method === "DELETE");
+        assert.strictEqual(writes.length, 0);
+    });
+    test("purges and rebuilds template if playbooks differ", async () => {
+        // 1. Initial image discovery finds outdated hash
+        mockResponses["GET /global/images/my-docker-base"] = {
+            status: 200,
+            body: {
+                name: "my-docker-base",
+                status: "READY",
+                description: "nginx-yaml=outdated-hash",
+            },
+        };
+        // 2. Temp instance discovery transition: first 404, then RUNNING, then stopped (TERMINATED), then 404 after delete
+        let tempQueryCount = 0;
+        mockResponses["GET /instances/puls-bake-temp-my-docker-base"] = {
+            status: 200,
+            get body() {
+                tempQueryCount++;
+                if (tempQueryCount === 1) {
+                    return {
+                        name: "puls-bake-temp-my-docker-base",
+                        status: "RUNNING",
+                        networkInterfaces: [
+                            {
+                                accessConfigs: [{ natIP: "35.200.12.34" }],
+                            },
+                        ],
+                    };
+                }
+                return {
+                    name: "puls-bake-temp-my-docker-base",
+                    status: "TERMINATED",
+                };
+            },
+        };
+        // 3. Mock image ready after bake
+        mockResponses["GET /global/images/my-docker-base"] = {
+            status: 200,
+            body: {
+                name: "my-docker-base",
+                status: "READY",
+            },
+        };
+        // 4. Operations and deletes
+        mockResponses["DELETE /global/images/my-docker-base"] = { status: 200, body: {} };
+        mockResponses["POST /instances"] = { status: 200, body: {} };
+        mockResponses["POST /instances/puls-bake-temp-my-docker-base/stop"] = { status: 200, body: {} };
+        mockResponses["POST /global/images"] = { status: 200, body: {} };
+        mockResponses["DELETE /instances/puls-bake-temp-my-docker-base"] = { status: 200, body: {} };
+        const builder = new GCPTemplateBuilder("my-docker-base")
+            .provision("playbooks/nginx.yaml");
+        builder.waitFor = async (label, condition) => {
+            return await condition();
+        };
+        builder.checkPort = async () => true;
+        const provisionSpy = mock.method(builder, "runProvisioner", async () => { });
+        const result = await builder.deploy();
+        assert.strictEqual(result.imageId, "projects/my-gcp-project/global/images/my-docker-base");
+        // Verify delete old image called
+        assert.ok(fetchCalls.some(c => c.method === "DELETE" && c.url.includes("/global/images/my-docker-base")));
+        // Verify temp instance POST, stop POST, image bake POST, and temp instance DELETE
+        assert.ok(fetchCalls.some(c => c.method === "POST" && c.url.includes("/instances")));
+        assert.ok(fetchCalls.some(c => c.method === "POST" && c.url.includes("/stop")));
+        assert.ok(fetchCalls.some(c => c.method === "POST" && c.url.includes("/global/images")));
+        assert.ok(fetchCalls.some(c => c.method === "DELETE" && c.url.includes("/instances/puls-bake-temp-my-docker-base")));
+        // Verify provision playbook ran
+        assert.strictEqual(provisionSpy.mock.callCount(), 1);
+        assert.strictEqual(provisionSpy.mock.calls[0].arguments[0], "35.200.12.34");
+        assert.strictEqual(provisionSpy.mock.calls[0].arguments[1], "playbooks/nginx.yaml");
+    });
+    test("GCPVMBuilder clones from GCP custom image template successfully", async () => {
+        const nginxHash = getFileHash("playbooks/nginx.yaml");
+        mockResponses["GET /global/images/my-golden-gcp-image"] = {
+            status: 200,
+            body: {
+                name: "my-golden-gcp-image",
+                status: "READY",
+                description: `nginx-yaml=${nginxHash}`,
+            },
+        };
+        let vmQueryCount = 0;
+        mockResponses["GET /instances/prod-server-01"] = {
+            status: 200,
+            get body() {
+                vmQueryCount++;
+                if (vmQueryCount === 1)
+                    return null; // VM absent initially
+                return {
+                    name: "prod-server-01",
+                    status: "RUNNING",
+                    networkInterfaces: [
+                        {
+                            accessConfigs: [{ natIP: "35.240.10.88" }],
+                        },
+                    ],
+                };
+            },
+        };
+        mockResponses["POST /instances"] = { status: 200, body: {} };
+        class GCPStack extends Stack {
+            gcpTemplate = new GCPTemplateBuilder("my-golden-gcp-image")
+                .provision("playbooks/nginx.yaml");
+            server = new GCPVMBuilder("prod-server-01")
+                .fromTemplate(this.gcpTemplate)
+                .machineType("e2-standard-4");
+        }
+        const stack = new GCPStack();
+        stack.server.waitFor = async (label, condition) => {
+            return await condition();
+        };
+        stack.server.checkPort = async () => true;
+        const result = await stack.deploy();
+        assert.strictEqual(result.gcpTemplate.imageId, "projects/my-gcp-project/global/images/my-golden-gcp-image");
+        assert.strictEqual(result.server.ip, "35.240.10.88");
+        // Verify instance creation POST has the dynamically resolved custom image path
+        const createCall = fetchCalls.find(c => c.method === "POST" && c.url.includes("/instances") && c.body?.disks);
+        assert.ok(createCall);
+        assert.strictEqual(createCall.body.disks[0].initializeParams.sourceImage, "projects/my-gcp-project/global/images/my-golden-gcp-image");
+        assert.strictEqual(createCall.body.machineType, "zones/us-central1-a/machineTypes/e2-standard-4");
+    });
+});

package/dist/providers/gcp/vm.d.ts

@@ -0,0 +1,48 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+import { GCPTemplateBuilder } from "./template.js";
+export declare class GCPVMBuilder extends BaseBuilder {
+    readonly out: {
+        ip: Output<string>;
+        id: Output<string>;
+    };
+    private _machineType;
+    private _image;
+    private _templateSource?;
+    private _zone;
+    private _network;
+    private _sshKeys;
+    private _provision;
+    private _forceConfigCheck;
+    private resolvedInstanceId?;
+    private resolvedIp?;
+    constructor(name: string);
+    machineType(type: string): this;
+    image(img: string): this;
+    fromTemplate(template: GCPTemplateBuilder): this;
+    zone(z: string): this;
+    network(netPath: string): this;
+    sshKey(keys: string | string[]): this;
+    provision(...playbookPaths: (string | string[])[]): this;
+    forceConfigCheck(): this;
+    protected checkPort(ip: string, port: number): Promise<boolean>;
+    protected runProvisioner(ip: string, script: string): Promise<void>;
+    private discoverVM;
+    deploy(): Promise<{
+        name: string;
+        id: string;
+        ip?: undefined;
+    } | {
+        name: string;
+        id: string | undefined;
+        ip: string | undefined;
+    } | null>;
+    destroy(): Promise<{
+        destroyed: boolean;
+    } | {
+        destroyed: string;
+    }>;
+    private updateGcpMetadata;
+}
+export declare function parseGcpMetadataForProvision(value?: string): Record<string, string>;
+export declare function mergeGcpMetadataForProvision(metadata: Record<string, string>): string;