puls-dev 0.2.7 → 0.2.8

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

@@ -1,5 +1,7 @@
 import { test, describe, beforeEach, afterEach, mock } from "node:test";
 import assert from "node:assert";
+import fs from "node:fs";
+import path from "node:path";
 import { GoogleAuth } from "google-auth-library";
 import { GCPCloudDNSZoneBuilder } from "./clouddns.js";
 import { Config } from "../../core/config.js";
@@ -256,4 +258,47 @@ describe("GCPCloudDNSZoneBuilder Unit Tests", () => {
         const deleteCall = fetchCalls.find((c) => c.method === "DELETE" && c.url.endsWith("/managedZones/to-delete-com"));
         assert.ok(deleteCall);
     });
+    test("loads records from a configuration file (YAML) successfully", async () => {
+        // 1. Zone exists
+        mockResponses["GET /managedZones/file-zone-com"] = {
+            status: 200,
+            body: { name: "file-zone-com" },
+        };
+        mockResponses["GET /managedZones/file-zone-com/rrsets"] = { status: 200, body: { rrsets: [] } };
+        mockResponses["POST /managedZones/file-zone-com/changes"] = { status: 200, body: {} };
+        // 2. Mock YAML file creation
+        const tempYamlPath = path.resolve(process.cwd(), "temp-dns-records.yaml");
+        const yamlContent = `
+- name: www
+  type: CNAME
+  value: lb.google.com
+- name: mail
+  type: A
+  value: 1.2.3.4
+  ttl: 600
+`;
+        fs.writeFileSync(tempYamlPath, yamlContent, "utf-8");
+        try {
+            const builder = new GCPCloudDNSZoneBuilder("file-zone.com")
+                .record("temp-dns-records.yaml")
+                .record("api", "A", "10.0.0.9", 120); // Hybrid programmatic record!
+            const result = await builder.deploy();
+            assert.strictEqual(result.records.length, 3);
+            const wwwRec = result.records.find((r) => r.name === "www.file-zone.com.");
+            assert.ok(wwwRec);
+            assert.strictEqual(wwwRec.type, "CNAME");
+            assert.deepStrictEqual(wwwRec.rrdatas, ["lb.google.com."]);
+            const mailRec = result.records.find((r) => r.name === "mail.file-zone.com.");
+            assert.ok(mailRec);
+            assert.strictEqual(mailRec.type, "A");
+            assert.strictEqual(mailRec.ttl, 600);
+            const apiRec = result.records.find((r) => r.name === "api.file-zone.com.");
+            assert.ok(apiRec);
+            assert.strictEqual(apiRec.ttl, 120);
+        }
+        finally {
+            if (fs.existsSync(tempYamlPath))
+                fs.unlinkSync(tempYamlPath);
+        }
+    });
 });

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

@@ -4,7 +4,8 @@ import { GCPSecretBuilder, resolveGCPEnvVars } from './secrets.js';
 import { GCPPubSubTopicBuilder, GCPPubSubSubscriptionBuilder } from './pubsub.js';
 import { GCPCloudDNSZoneBuilder } from './clouddns.js';
 import { GCPServiceAccountBuilder, GCPIAMBindingBuilder } from './iam.js';
-export { GCPSecretBuilder, resolveGCPEnvVars, GCPPubSubTopicBuilder, GCPPubSubSubscriptionBuilder, GCPCloudDNSZoneBuilder, GCPServiceAccountBuilder, GCPIAMBindingBuilder };
+import { GCPVMBuilder } from './vm.js';
+export { GCPSecretBuilder, resolveGCPEnvVars, GCPPubSubTopicBuilder, GCPPubSubSubscriptionBuilder, GCPCloudDNSZoneBuilder, GCPServiceAccountBuilder, GCPIAMBindingBuilder, GCPVMBuilder };
 export declare const GCP: {
     CloudRun: (serviceId: string) => GCPCloudRunBuilder;
     CloudSQL: (instanceId: string) => GCPCloudSQLBuilder;
@@ -16,4 +17,5 @@ export declare const GCP: {
         Topic: (topicId: string) => GCPPubSubTopicBuilder;
         Subscription: (subscriptionId: string) => GCPPubSubSubscriptionBuilder;
     };
+    VM: (instanceId: string) => GCPVMBuilder;
 };

package/dist/providers/gcp/index.js

@@ -4,7 +4,8 @@ import { GCPSecretBuilder, resolveGCPEnvVars } from './secrets.js';
 import { GCPPubSubTopicBuilder, GCPPubSubSubscriptionBuilder } from './pubsub.js';
 import { GCPCloudDNSZoneBuilder } from './clouddns.js';
 import { GCPServiceAccountBuilder, GCPIAMBindingBuilder } from './iam.js';
-export { GCPSecretBuilder, resolveGCPEnvVars, GCPPubSubTopicBuilder, GCPPubSubSubscriptionBuilder, GCPCloudDNSZoneBuilder, GCPServiceAccountBuilder, GCPIAMBindingBuilder };
+import { GCPVMBuilder } from './vm.js';
+export { GCPSecretBuilder, resolveGCPEnvVars, GCPPubSubTopicBuilder, GCPPubSubSubscriptionBuilder, GCPCloudDNSZoneBuilder, GCPServiceAccountBuilder, GCPIAMBindingBuilder, GCPVMBuilder };
 export const GCP = {
     CloudRun: (serviceId) => new GCPCloudRunBuilder(serviceId),
     CloudSQL: (instanceId) => new GCPCloudSQLBuilder(instanceId),
@@ -16,4 +17,5 @@ export const GCP = {
         Topic: (topicId) => new GCPPubSubTopicBuilder(topicId),
         Subscription: (subscriptionId) => new GCPPubSubSubscriptionBuilder(subscriptionId),
     },
+    VM: (instanceId) => new GCPVMBuilder(instanceId),
 };

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

@@ -0,0 +1,45 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+export declare class GCPVMBuilder extends BaseBuilder {
+    readonly out: {
+        ip: Output<string>;
+        id: Output<string>;
+    };
+    private _machineType;
+    private _image;
+    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;
+    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;

package/dist/providers/gcp/vm.js

@@ -0,0 +1,332 @@
+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";
+export class GCPVMBuilder extends BaseBuilder {
+    out = {
+        ip: new Output(),
+        id: new Output(),
+    };
+    _machineType = "e2-micro";
+    _image = "projects/ubuntu-os-cloud/global/images/family/ubuntu-2204-lts";
+    _zone = "us-central1-a";
+    _network = "global/networks/default";
+    _sshKeys = [];
+    _provision = [];
+    _forceConfigCheck = false;
+    resolvedInstanceId;
+    resolvedIp;
+    constructor(name) {
+        super(name);
+        this.discoveryPromise = this.discoverVM();
+    }
+    machineType(type) {
+        this._machineType = type;
+        return this;
+    }
+    image(img) {
+        this._image = img;
+        return this;
+    }
+    zone(z) {
+        this._zone = z;
+        this.discoveryPromise = this.discoverVM();
+        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;
+    }
+    forceConfigCheck() {
+        this._forceConfigCheck = true;
+        return this;
+    }
+    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 discoverVM() {
+        try {
+            const project = getProjectId();
+            const zone = this._zone;
+            const res = await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/zones/${zone}/instances/${this.name}`);
+            if (res) {
+                this.resolvedInstanceId = res.id;
+                const netInterface = (res.networkInterfaces ?? [])[0];
+                const extIp = (netInterface?.accessConfigs ?? [])[0]?.natIP;
+                this.resolvedIp = extIp;
+                if (res.id)
+                    this.out.id.resolve(res.id);
+                if (extIp)
+                    this.out.ip.resolve(extIp);
+            }
+            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 deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const project = getProjectId();
+        const zone = this._zone;
+        // Check if machine resizing is needed
+        const hasChanges = existing
+            ? existing.machineType?.split("/").pop() !== this._machineType
+            : true;
+        if (await this.checkProtection(hasChanges))
+            return null;
+        // Parse applied playbooks metadata from GCP metadata items
+        const metadataItem = (existing?.metadata?.items ?? []).find((i) => i.key === "puls-provision");
+        const appliedHashes = parseGcpMetadataForProvision(metadataItem?.value);
+        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) };
+        });
+        const playbooksToRun = this._forceConfigCheck
+            ? declaredPlaybooksWithHashes
+            : declaredPlaybooksWithHashes.filter((p) => {
+                const appliedHash = appliedHashes[p.slug];
+                return !appliedHash || appliedHash !== p.hash;
+            });
+        const playbookRunRequired = playbooksToRun.length > 0;
+        if (dryRun) {
+            console.log(`\n🔍 [DRY RUN] GCP VM "${this.name}"...`);
+            if (!existing) {
+                console.log(`   📝 Plan: Create GCP VM Instance "${this.name}" (${this._machineType} in zone ${this._zone})`);
+                if (this._provision.length > 0) {
+                    console.log(`      └─ Provision: ${this._provision.join(", ")}`);
+                }
+                this.out.id.resolve("PENDING");
+                this.out.ip.resolve("0.0.0.0");
+            }
+            else if (hasChanges || playbookRunRequired) {
+                if (hasChanges) {
+                    console.log(`   📝 Plan: Stop and Resize VM ${this.name} → ${this._machineType}`);
+                }
+                if (playbookRunRequired) {
+                    console.log(`   📝 [PLAN] Run ${playbooksToRun.length} playbook changes on existing GCP VM:`);
+                    for (const p of playbooksToRun) {
+                        console.log(`      └─ Playbook: ${p.path} (hash: ${p.hash})`);
+                    }
+                }
+            }
+            else {
+                console.log(`   ✅ GCP VM "${this.name}" is up to date.`);
+            }
+            return { name: this.name, id: "PENDING" };
+        }
+        console.log(`\n⏳ Finalizing GCP VM "${this.name}"...`);
+        if (!existing) {
+            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");
+            // Compute initial playbooks metadata tag
+            const initialHashes = {};
+            for (const p of declaredPlaybooksWithHashes) {
+                initialHashes[p.slug] = p.hash;
+            }
+            const initialMetadataVal = mergeGcpMetadataForProvision(initialHashes);
+            const body = {
+                name: this.name,
+                machineType: `zones/${zone}/machineTypes/${this._machineType}`,
+                disks: [
+                    {
+                        boot: true,
+                        autoDelete: true,
+                        initializeParams: {
+                            sourceImage: this._image,
+                        },
+                    },
+                ],
+                networkInterfaces: [
+                    {
+                        network: this._network,
+                        accessConfigs: [
+                            {
+                                name: "External NAT",
+                                type: "ONE_TO_ONE_NAT",
+                            },
+                        ],
+                    },
+                ],
+                metadata: {
+                    items: [
+                        ...(sshKeysValue ? [{ key: "ssh-keys", value: sshKeysValue }] : []),
+                        ...(initialMetadataVal ? [{ key: "puls-provision", value: initialMetadataVal }] : []),
+                    ],
+                },
+            };
+            console.log(`🚀 Creating GCP Compute VM Instance "${this.name}"...`);
+            await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/zones/${zone}/instances`, {
+                method: "POST",
+                body: JSON.stringify(body),
+            });
+            // Poll until instance is RUNNING
+            await this.waitFor(`GCP VM "${this.name}" to start running`, async () => {
+                const current = await this.discoverVM();
+                return current && current.status === "RUNNING";
+            }, { intervalMs: 10_000, timeoutMs: 300_000 });
+            console.log(`🚀 GCP VM "${this.name}" is now running.`);
+            if (this._provision.length > 0) {
+                const activeIp = this.resolvedIp ?? "0.0.0.0";
+                if (activeIp === "0.0.0.0") {
+                    throw new Error(`Failed to resolve IP for new GCP VM "${this.name}" to run playbooks`);
+                }
+                await this.waitFor(`SSH on ${activeIp} to be ready`, () => this.checkPort(activeIp, 22), { intervalMs: 10_000, timeoutMs: 300_000 });
+                for (const playbook of this._provision) {
+                    await this.runProvisioner(activeIp, playbook);
+                }
+            }
+        }
+        else {
+            if (hasChanges) {
+                console.log(`✨ Resizing GCP VM ${this.name} → ${this._machineType}...`);
+                // GCP requires instance to be stopped to resize machineType
+                console.log(`   🔄 Stopping VM to perform resize...`);
+                await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/zones/${zone}/instances/${this.name}/stop`, { method: "POST" });
+                await this.waitFor(`VM "${this.name}" to stop`, async () => {
+                    const current = await this.discoverVM();
+                    return current && current.status === "TERMINATED";
+                }, { intervalMs: 10_000, timeoutMs: 300_000 });
+                // Perform resize
+                await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/zones/${zone}/instances/${this.name}/setSize`, {
+                    method: "POST",
+                    body: JSON.stringify({
+                        machineType: `zones/${zone}/machineTypes/${this._machineType}`,
+                    }),
+                });
+                // Restart VM
+                console.log(`   🔄 Restarting VM...`);
+                await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/zones/${zone}/instances/${this.name}/start`, { method: "POST" });
+                await this.waitFor(`VM "${this.name}" to restart`, async () => {
+                    const current = await this.discoverVM();
+                    return current && current.status === "RUNNING";
+                }, { intervalMs: 10_000, timeoutMs: 300_000 });
+                console.log(`   ✅ GCP VM resized and restarted successfully.`);
+            }
+            if (playbookRunRequired) {
+                console.log(`   🔄 Running ${playbooksToRun.length} playbook changes on GCP VM...`);
+                const activeIp = this.resolvedIp ?? "0.0.0.0";
+                if (activeIp === "0.0.0.0") {
+                    throw new Error(`Failed to resolve IP for GCP VM "${this.name}" to run playbooks`);
+                }
+                await this.waitFor(`SSH on ${activeIp} to be ready`, () => this.checkPort(activeIp, 22), { intervalMs: 10_000, timeoutMs: 300_000 });
+                for (const p of playbooksToRun) {
+                    await this.runProvisioner(activeIp, p.path);
+                    appliedHashes[p.slug] = p.hash;
+                }
+                // Re-discover to get fresh metadata fingerprint
+                const fresh = await this.discoverVM();
+                await this.updateGcpMetadata(fresh, appliedHashes);
+                console.log(`   ✅ Playbooks applied successfully and metadata updated.`);
+            }
+            if (!hasChanges && !playbookRunRequired) {
+                console.log(`✅ GCP VM "${this.name}" is up to date.`);
+            }
+        }
+        return {
+            name: this.name,
+            id: this.resolvedInstanceId,
+            ip: this.resolvedIp,
+        };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const project = getProjectId();
+        const zone = this._zone;
+        console.log(`\n🗑️  Destroying GCP Compute VM "${this.name}"...`);
+        if (!existing) {
+            console.log(`   ─  GCP VM "${this.name}" not found`);
+            return { destroyed: false };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete GCP VM "${this.name}"`);
+            return { destroyed: this.name };
+        }
+        console.log(`   🔄 Deleting GCP VM "${this.name}"...`);
+        await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/zones/${zone}/instances/${this.name}`, {
+            method: "DELETE",
+        });
+        console.log(`   🗑️  Removed GCP VM "${this.name}"`);
+        return { destroyed: this.name };
+    }
+    async updateGcpMetadata(existing, newHashes) {
+        const project = getProjectId();
+        const zone = this._zone;
+        const currentItems = [...(existing.metadata?.items ?? [])];
+        const newValue = mergeGcpMetadataForProvision(newHashes);
+        const provIdx = currentItems.findIndex((i) => i.key === "puls-provision");
+        if (provIdx >= 0) {
+            currentItems[provIdx].value = newValue;
+        }
+        else {
+            currentItems.push({ key: "puls-provision", value: newValue });
+        }
+        await gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/zones/${zone}/instances/${this.name}/setMetadata`, {
+            method: "POST",
+            body: JSON.stringify({
+                fingerprint: existing.metadata?.fingerprint,
+                items: currentItems,
+            }),
+        });
+    }
+}
+export function parseGcpMetadataForProvision(value) {
+    if (!value)
+        return {};
+    const record = {};
+    const entries = value.split(",");
+    for (const entry of entries) {
+        const parts = entry.trim().split("=");
+        if (parts.length === 2) {
+            const [name, hash] = parts;
+            if (name && hash) {
+                record[name.trim()] = hash.trim();
+            }
+        }
+    }
+    return record;
+}
+export function mergeGcpMetadataForProvision(metadata) {
+    return Object.entries(metadata)
+        .map(([name, hash]) => `${name}=${hash}`)
+        .join(",");
+}

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

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