puls-dev 0.2.7 → 0.2.9

package/dist/providers/firebase/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';
 function resolveFirebaseConfig() {
+    const isOffline = Config.isOfflineMode() || Config.isGlobalDryRun();
     const cfg = Config.get().providers.firebase;
     if (cfg?.serviceAccountPath)
         return cfg;
@@ -11,12 +14,18 @@ function resolveFirebaseConfig() {
         const sa = JSON.parse(fs.readFileSync(saPath, 'utf8'));
         return { projectId: sa.project_id, serviceAccountPath: saPath };
     }
+    if (isOffline) {
+        return { projectId: "mock-firebase-project", serviceAccountPath: "/mock/sa.json" };
+    }
     throw new Error('Firebase not configured. Set FIREBASE_SA=/path/to/sa.json or use @Deploy({ firebase: "..." })');
 }
 export function getProjectId() {
     return resolveFirebaseConfig().projectId;
 }
 export async function getFirebaseToken(scopes) {
+    if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+        return "mock-firebase-token";
+    }
     const { serviceAccountPath } = resolveFirebaseConfig();
     const auth = new GoogleAuth({ keyFile: serviceAccountPath, scopes });
     const client = await auth.getClient();
@@ -25,38 +34,92 @@ export async function getFirebaseToken(scopes) {
 }
 const HOSTING_SCOPE = 'https://www.googleapis.com/auth/firebase.hosting';
 const CLOUD_SCOPE = 'https://www.googleapis.com/auth/cloud-platform';
-export async function hostingFetch(path, opts = {}) {
-    const token = await getFirebaseToken([HOSTING_SCOPE]);
-    const base = 'https://firebasehosting.googleapis.com/v1beta1';
-    const res = await fetch(`${base}${path}`, {
-        ...opts,
-        headers: {
-            'Authorization': `Bearer ${token}`,
-            'Content-Type': 'application/json',
-            ...(opts.headers ?? {}),
-        },
+function createFirebaseOfflineMock(path, opts) {
+    if (path.includes("/versions")) {
+        return { name: `${path}/versions/mock-version-id`, status: "FINALIZED" };
+    }
+    if (path.includes("/releases")) {
+        return { name: `${path}/releases/mock-release-id` };
+    }
+    if (path.includes("/sites/")) {
+        return { name: "mock-site-name", defaultUrl: "https://mock-project.web.app" };
+    }
+    return new Proxy({}, {
+        get(target, prop) {
+            if (prop === "then")
+                return undefined;
+            if (prop === "name")
+                return "mock-firebase-name";
+            if (prop === "status")
+                return "FINALIZED";
+            if (prop === "id")
+                return "mock-firebase-id";
+            if (prop.endsWith("s"))
+                return [];
+            return `mock-fb-${prop.toLowerCase()}`;
+        }
     });
-    if (!res.ok) {
-        const body = await res.text();
-        throw new Error(`Firebase Hosting API ${opts.method ?? 'GET'} ${path} → ${res.status}: ${body}`);
+}
+export async function hostingFetch(path, opts = {}) {
+    const context = resourceContextStorage.getStore();
+    const abortSignal = context?.abortSignal;
+    if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+        return Promise.resolve(createFirebaseOfflineMock(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 getFirebaseToken([HOSTING_SCOPE]);
+        const base = 'https://firebasehosting.googleapis.com/v1beta1';
+        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(`Firebase Hosting 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");
+        }
+    });
 }
 export async function cloudFetch(base, path, opts = {}) {
-    const token = await getFirebaseToken([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(createFirebaseOfflineMock(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 getFirebaseToken([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/firebase/list.d.ts

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

package/dist/providers/firebase/list.js

@@ -0,0 +1,25 @@
+import { getProjectId, hostingFetch, cloudFetch } from "./api.js";
+export async function listFirebaseResources() {
+    const project = getProjectId();
+    const [hostRes, fnRes] = await Promise.all([
+        hostingFetch(`/projects/${project}/sites`).catch(() => ({})),
+        cloudFetch("https://cloudfunctions.googleapis.com/v2", `/projects/${project}/locations/-/functions`).catch(() => ({})),
+    ]);
+    // 1. Map Hosting Sites
+    const hostingSites = (hostRes.sites ?? []).map((s) => ({
+        site: s.name.split("/").pop() ?? "unknown",
+    }));
+    // 2. Map Cloud Functions
+    const functions = (fnRes.functions ?? []).map((f) => {
+        const parts = f.name.split("/");
+        const name = parts.pop() ?? "unknown";
+        const region = parts[parts.indexOf("locations") + 1] ?? "unknown";
+        return {
+            name,
+            region,
+            entryPoint: f.buildConfig?.entryPoint ?? "unknown",
+            runtime: f.buildConfig?.runtime ?? "unknown",
+        };
+    });
+    return { hostingSites, functions };
+}

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/clouddns.d.ts

@@ -19,6 +19,7 @@ export declare class GCPCloudDNSZoneBuilder extends BaseBuilder {
     private records;
     constructor(zoneName: string);
     private discoverZone;
+    record(filePath: string): this;
     record(name: string, type: "A" | "AAAA" | "CNAME" | "MX" | "TXT" | "NS" | "PTR" | "SRV" | "CAA" | "SPF", value: string, ttl?: number): this;
     pointer(name: string, target: BaseBuilder | Output<string> | string): this;
     deploy(): Promise<{

package/dist/providers/gcp/clouddns.js

@@ -1,6 +1,7 @@
 import { BaseBuilder } from "../../core/resource.js";
 import { Output } from "../../core/output.js";
 import { gcpFetch, getProjectId } from "./api.js";
+import { loadRecordsFromFile } from "../../core/parser.js";
 const DNS_BASE = "https://dns.googleapis.com";
 function cleanZoneId(domain) {
     return domain
@@ -57,8 +58,20 @@ export class GCPCloudDNSZoneBuilder extends BaseBuilder {
             throw e;
         }
     }
-    record(name, type, value, ttl = 300) {
-        this.records.push({ name, type, value, ttl });
+    record(nameOrPath, type, value, ttl = 300) {
+        if (arguments.length === 1 && typeof nameOrPath === "string" && (nameOrPath.endsWith(".yaml") || nameOrPath.endsWith(".yml") || nameOrPath.endsWith(".json"))) {
+            const loaded = loadRecordsFromFile(nameOrPath);
+            for (const r of loaded) {
+                this.records.push({
+                    name: r.name,
+                    type: r.type,
+                    value: r.value,
+                    ttl: r.ttl ?? 300,
+                });
+            }
+            return this;
+        }
+        this.records.push({ name: nameOrPath, type: type, value: value, ttl });
         return this;
     }
     pointer(name, target) {

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,9 @@ 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';
+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;
@@ -16,4 +18,6 @@ export declare const GCP: {
         Topic: (topicId: string) => GCPPubSubTopicBuilder;
         Subscription: (subscriptionId: string) => GCPPubSubSubscriptionBuilder;
     };
+    VM: (instanceId: string) => GCPVMBuilder;
+    Template: (instanceId: string) => GCPTemplateBuilder;
 };

package/dist/providers/gcp/index.js

@@ -4,7 +4,9 @@ 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';
+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),
@@ -16,4 +18,6 @@ export const GCP = {
         Topic: (topicId) => new GCPPubSubTopicBuilder(topicId),
         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;
+    }>;
+}