puls-dev 0.2.8 → 0.2.9

package/dist/providers/gcp/api.js

@@ -1,7 +1,10 @@
 import fs from 'node:fs';
 import { GoogleAuth } from 'google-auth-library';
 import { Config } from '../../core/config.js';
+import { withRetry } from '../../core/retry.js';
+import { resourceContextStorage } from '../../core/context.js';
 export function resolveGCPConfig() {
+    const isOffline = Config.isOfflineMode() || Config.isGlobalDryRun();
     // 1. Check Config.providers.gcp
     const gcpCfg = Config.get().providers.gcp;
     if (gcpCfg?.serviceAccountPath) {
@@ -72,6 +75,13 @@ export function resolveGCPConfig() {
             // Continue to next fallback
         }
     }
+    if (isOffline) {
+        return {
+            projectId: "mock-gcp-project",
+            serviceAccountPath: "/mock/sa.json",
+            region: gcpCfg?.region ?? "us-central1"
+        };
+    }
     throw new Error('GCP credentials not configured. Please set GCP_SA or FIREBASE_SA env var, or configure providers.gcp or providers.firebase in Config.');
 }
 export function getProjectId() {
@@ -82,6 +92,9 @@ export function getRegion() {
     return gcpCfg?.region ?? 'us-central1';
 }
 export async function getGCPToken(scopes) {
+    if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+        return "mock-gcp-token";
+    }
     const { serviceAccountPath } = resolveGCPConfig();
     const auth = new GoogleAuth({ keyFile: serviceAccountPath, scopes });
     const client = await auth.getClient();
@@ -91,21 +104,82 @@ export async function getGCPToken(scopes) {
     }
     return token.token;
 }
+function createGcpOfflineMock(base, path, opts) {
+    if (path.includes("/secrets/")) {
+        return {
+            payload: {
+                data: Buffer.from("mock-gcp-secret-value").toString("base64")
+            }
+        };
+    }
+    if (path.includes("/instances")) {
+        return {
+            status: "RUNNING",
+            id: "mock-gcp-instance-id",
+            networkInterfaces: [
+                {
+                    networkIP: "10.128.0.2",
+                    accessConfigs: [
+                        {
+                            natIP: "34.56.78.90"
+                        }
+                    ]
+                }
+            ]
+        };
+    }
+    if (path.includes("/global/networks")) {
+        return { status: "READY", name: "mock-network" };
+    }
+    if (path.includes("/subnetworks")) {
+        return { status: "READY", name: "mock-subnetwork" };
+    }
+    // Generic fallback proxy
+    return new Proxy({}, {
+        get(target, prop) {
+            if (prop === "then")
+                return undefined;
+            if (prop === "id")
+                return "mock-gcp-id-12345";
+            if (prop === "name")
+                return "mock-gcp-name";
+            if (prop === "status" || prop === "status")
+                return "RUNNING";
+            if (prop.endsWith("s"))
+                return [];
+            return `mock-gcp-${prop.toLowerCase()}`;
+        }
+    });
+}
 const CLOUD_SCOPE = 'https://www.googleapis.com/auth/cloud-platform';
 export async function gcpFetch(base, path, opts = {}) {
-    const token = await getGCPToken([CLOUD_SCOPE]);
-    const res = await fetch(`${base}${path}`, {
-        ...opts,
-        headers: {
-            'Authorization': `Bearer ${token}`,
-            'Content-Type': 'application/json',
-            ...(opts.headers ?? {}),
-        },
-    });
-    if (!res.ok) {
-        const body = await res.text();
-        throw new Error(`GCP API ${opts.method ?? 'GET'} ${path} → ${res.status}: ${body}`);
+    const context = resourceContextStorage.getStore();
+    const abortSignal = context?.abortSignal;
+    if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+        return Promise.resolve(createGcpOfflineMock(base, path, opts));
     }
-    const text = await res.text();
-    return text ? JSON.parse(text) : null;
+    const fetchOpts = abortSignal ? { ...opts, signal: abortSignal } : opts;
+    return withRetry(async () => {
+        const token = await getGCPToken([CLOUD_SCOPE]);
+        const res = await fetch(`${base}${path}`, {
+            ...fetchOpts,
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                ...(fetchOpts.headers ?? {}),
+            },
+        });
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`GCP API ${fetchOpts.method ?? 'GET'} ${path} → ${res.status}: ${body}`);
+        }
+        const text = await res.text();
+        return text ? JSON.parse(text) : 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");
+        }
+    });
 }

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

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

package/dist/providers/gcp/index.js

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

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

@@ -0,0 +1,2 @@
+import type { GcpInventory } from "../../types/inventory.js";
+export declare function listGcpResources(): Promise<GcpInventory>;

package/dist/providers/gcp/list.js

@@ -0,0 +1,55 @@
+import { gcpFetch, getProjectId } from "./api.js";
+export async function listGcpResources() {
+    const project = getProjectId();
+    const [vmRes, sqlRes, runRes, dnsRes] = await Promise.all([
+        gcpFetch("https://compute.googleapis.com", `/compute/v1/projects/${project}/aggregated/instances`).catch(() => ({})),
+        gcpFetch("https://sqladmin.googleapis.com", `/v1/projects/${project}/instances`).catch(() => ({})),
+        gcpFetch("https://run.googleapis.com", `/v2/projects/${project}/locations/-/services`).catch(() => ({})),
+        gcpFetch("https://dns.googleapis.com", `/dns/v1/projects/${project}/managedZones`).catch(() => ({})),
+    ]);
+    // 1. Map VM Instances
+    const vms = [];
+    if (vmRes.items) {
+        for (const [zoneKey, zoneData] of Object.entries(vmRes.items)) {
+            const data = zoneData;
+            if (data.instances) {
+                const zone = zoneKey.split("/").pop() ?? zoneKey;
+                for (const inst of data.instances) {
+                    const machineType = inst.machineType?.split("/").pop() ?? "unknown";
+                    const ip = inst.networkInterfaces?.[0]?.accessConfigs?.[0]?.natIP ?? "no-ip";
+                    vms.push({
+                        name: inst.name,
+                        zone,
+                        machineType,
+                        status: inst.status ?? "unknown",
+                        ip,
+                    });
+                }
+            }
+        }
+    }
+    // 2. Map Cloud SQL Instances
+    const rdsInstances = (sqlRes.items ?? []).map((i) => ({
+        name: i.name,
+        engine: i.databaseVersion ?? "unknown",
+        tier: i.settings?.tier ?? "unknown",
+        status: i.state ?? "unknown",
+    }));
+    // 3. Map Cloud Run Services
+    const distributions = (runRes.services ?? []).map((s) => {
+        const parts = s.name.split("/");
+        const name = parts.pop() ?? "unknown";
+        const region = parts[parts.indexOf("locations") + 1] ?? "unknown";
+        return {
+            name,
+            region,
+            url: s.uri ?? "no-url",
+        };
+    });
+    // 4. Map Cloud DNS Zones
+    const hostedZones = (dnsRes.managedZones ?? []).map((z) => ({
+        name: z.name,
+        dnsName: z.dnsName ?? "",
+    }));
+    return { vms, rdsInstances, distributions, hostedZones };
+}

package/dist/providers/gcp/secrets.js

@@ -23,7 +23,7 @@ export class GCPSecretBuilder extends BaseBuilder {
                 }
             }
             catch (err) {
-                // If version access fails (e.g. no versions created yet), keep resolvedValue as null
+                console.warn(`   ⚠️  Could not fetch latest version of secret "${secretId}": ${err.message}`);
             }
             return secret;
         }

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

@@ -0,0 +1,32 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+export declare class GCPTemplateBuilder extends BaseBuilder {
+    readonly out: {
+        imageId: Output<string>;
+    };
+    private _baseImage;
+    private _machineType;
+    private _zone;
+    private _network;
+    private _sshKeys;
+    private _provision;
+    constructor(name: string);
+    baseImage(img: string): this;
+    machineType(type: string): this;
+    zone(z: string): this;
+    network(netPath: string): this;
+    sshKey(keys: string | string[]): this;
+    provision(...playbookPaths: (string | string[])[]): this;
+    private discoverImage;
+    protected checkPort(ip: string, port: number): Promise<boolean>;
+    protected runProvisioner(ip: string, script: string): Promise<void>;
+    deploy(): Promise<{
+        name: string;
+        imageId: string;
+    }>;
+    destroy(): Promise<{
+        destroyed: boolean;
+    } | {
+        destroyed: string;
+    }>;
+}

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 {};