puls-dev 0.3.4 → 0.3.6

package/dist/providers/firebase/functions.js

@@ -79,6 +79,34 @@ export class FirebaseFunctionsBuilder extends BaseBuilder {
         this._env = vars;
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        const liveRuntime = existing.buildConfig?.runtime;
+        if (liveRuntime !== undefined && liveRuntime !== this._runtime) {
+            diffs.push({ field: "runtime", declared: this._runtime, live: liveRuntime });
+        }
+        const liveEntryPoint = existing.buildConfig?.entryPoint;
+        if (liveEntryPoint !== undefined && liveEntryPoint !== this._entryPoint) {
+            diffs.push({ field: "entryPoint", declared: this._entryPoint, live: liveEntryPoint });
+        }
+        const liveMemory = existing.serviceConfig?.availableMemory;
+        if (liveMemory !== undefined && liveMemory !== this._memory) {
+            diffs.push({ field: "memory", declared: this._memory, live: liveMemory });
+        }
+        const liveTimeout = existing.serviceConfig?.timeoutSeconds;
+        if (liveTimeout !== undefined && liveTimeout !== this._timeout) {
+            diffs.push({ field: "timeout", declared: `${this._timeout}s`, live: `${liveTimeout}s` });
+        }
+        const liveMax = existing.serviceConfig?.maxInstanceCount;
+        if (liveMax !== undefined && liveMax !== this._maxInstances) {
+            diffs.push({ field: "maxInstances", declared: this._maxInstances, live: liveMax });
+        }
+        const liveMin = existing.serviceConfig?.minInstanceCount ?? 0;
+        if (liveMin !== this._minInstances) {
+            diffs.push({ field: "minInstances", declared: this._minInstances, live: liveMin });
+        }
+        return diffs;
+    }
     fnPath() {
         return `/projects/${getProjectId()}/locations/${this._region}/functions/${this.name}`;
     }

package/dist/providers/firebase/list.js

@@ -1,9 +1,13 @@
 import { getProjectId, hostingFetch, cloudFetch } from "./api.js";
 export async function listFirebaseResources() {
     const project = getProjectId();
-    const [hostRes, fnRes] = await Promise.all([
+    const [hostRes, fnRes, firestoreRes, storageRes, authRes, rcRes] = await Promise.all([
         hostingFetch(`/projects/${project}/sites`).catch(() => ({})),
         cloudFetch("https://cloudfunctions.googleapis.com/v2", `/projects/${project}/locations/-/functions`).catch(() => ({})),
+        cloudFetch("https://firestore.googleapis.com/v1", `/projects/${project}/databases`).catch(() => ({})),
+        cloudFetch("https://storage.googleapis.com/storage/v1", `/b?project=${project}`).catch(() => ({})),
+        cloudFetch("https://identitytoolkit.googleapis.com/admin/v2", `/projects/${project}/config`).catch(() => ({})),
+        cloudFetch("https://firebaseremoteconfig.googleapis.com/v1", `/projects/${project}/remoteConfig`).catch(() => ({})),
     ]);
     // 1. Map Hosting Sites
     const hostingSites = (hostRes.sites ?? []).map((s) => ({
@@ -21,5 +25,33 @@ export async function listFirebaseResources() {
             runtime: f.buildConfig?.runtime ?? "unknown",
         };
     });
-    return { hostingSites, functions };
+    // 3. Map Firestore Databases
+    const firestoreDbs = (firestoreRes.databases ?? []).map((d) => ({
+        name: d.name.split("/").pop() ?? d.name,
+        type: d.type ?? "FIRESTORE_NATIVE",
+        state: d.state ?? "unknown",
+    }));
+    // 4. Map Storage Buckets (filter to project-owned buckets)
+    const storageBuckets = (storageRes.items ?? [])
+        .filter((b) => b.name?.includes(project))
+        .map((b) => ({
+        name: b.name,
+        location: b.location ?? "unknown",
+    }));
+    // 5. Map Auth Sign-in Providers from Identity Toolkit config
+    const signIn = authRes.signIn ?? {};
+    const authProviders = [
+        ...(signIn.email?.enabled ? [{ providerId: "email/password" }] : []),
+        ...(signIn.phoneNumber?.enabled ? [{ providerId: "phone" }] : []),
+        ...(signIn.anonymous?.enabled ? [{ providerId: "anonymous" }] : []),
+    ];
+    // 6. Map RemoteConfig
+    let remoteConfig;
+    if (rcRes.parameters !== undefined || rcRes.version) {
+        remoteConfig = {
+            parameterCount: Object.keys(rcRes.parameters ?? {}).length,
+            version: rcRes.version?.versionNumber ?? "unknown",
+        };
+    }
+    return { hostingSites, functions, firestoreDbs, storageBuckets, authProviders, remoteConfig };
 }

package/dist/providers/gcp/api.js

@@ -113,6 +113,12 @@ function createGcpOfflineMock(base, path, opts) {
         };
     }
     if (path.includes("/instances")) {
+        // Specific instance GET (discovery path: /instances/{name}) - return not-found so
+        // builders plan creation rather than treating the mock VM as already existing
+        const afterInstances = path.split("/instances")[1] ?? "";
+        if (afterInstances.startsWith("/") && afterInstances.length > 1) {
+            throw new Error(`GCP API GET ${path} → 404: Not Found`);
+        }
         return {
             status: "RUNNING",
             id: "mock-gcp-instance-id",

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

@@ -20,6 +20,19 @@ export declare class GCPCloudRunBuilder extends BaseBuilder {
     env(vars: Record<string, string | GCPSecretBuilder>): this;
     region(reg: string): this;
     public(enabled?: boolean): this;
+    getDiff(existing: any): ({
+        field: string;
+        declared: string | undefined;
+        live: any;
+    } | {
+        field: string;
+        declared: number;
+        live: any;
+    } | {
+        field: string;
+        declared: boolean;
+        live: boolean;
+    })[];
     private discoverService;
     deploy(): Promise<{
         serviceId: string;

package/dist/providers/gcp/cloudrun.js

@@ -60,6 +60,36 @@ export class GCPCloudRunBuilder extends BaseBuilder {
         this._public = enabled;
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        const container = existing.template?.containers?.[0];
+        const scaling = existing.template?.scaling ?? {};
+        const targetIngress = this._public ? "INGRESS_TRAFFIC_ALL" : "INGRESS_TRAFFIC_INTERNAL_ONLY";
+        if (container?.image !== this._image) {
+            diffs.push({ field: "image", declared: this._image, live: container?.image });
+        }
+        if (container?.ports?.[0]?.containerPort !== this._port) {
+            diffs.push({ field: "port", declared: this._port, live: container?.ports?.[0]?.containerPort });
+        }
+        if (container?.resources?.limits?.cpu !== formatCpu(this._cpu)) {
+            diffs.push({ field: "cpu", declared: formatCpu(this._cpu), live: container?.resources?.limits?.cpu });
+        }
+        if (container?.resources?.limits?.memory !== formatMemory(this._memory)) {
+            diffs.push({ field: "memory", declared: formatMemory(this._memory), live: container?.resources?.limits?.memory });
+        }
+        const minDeclared = this._minInstances ?? 0;
+        const maxDeclared = this._maxInstances ?? 100;
+        if ((scaling.minInstanceCount ?? 0) !== minDeclared) {
+            diffs.push({ field: "minInstances", declared: minDeclared, live: scaling.minInstanceCount ?? 0 });
+        }
+        if ((scaling.maxInstanceCount ?? 100) !== maxDeclared) {
+            diffs.push({ field: "maxInstances", declared: maxDeclared, live: scaling.maxInstanceCount ?? 100 });
+        }
+        if (existing.ingress !== targetIngress) {
+            diffs.push({ field: "public", declared: this._public, live: existing.ingress === "INGRESS_TRAFFIC_ALL" });
+        }
+        return diffs;
+    }
     async discoverService() {
         try {
             const project = getProjectId();

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

@@ -23,6 +23,15 @@ export declare class GCPCloudSQLBuilder extends BaseBuilder {
     database(name: string): this;
     publicAccess(enabled?: boolean): this;
     region(reg: string): this;
+    getDiff(existing: any): ({
+        field: string;
+        declared: string;
+        live: any;
+    } | {
+        field: string;
+        declared: boolean;
+        live: boolean;
+    })[];
     private discoverInstance;
     private waitForOperation;
     deploy(): Promise<{

package/dist/providers/gcp/cloudsql.js

@@ -64,6 +64,26 @@ export class GCPCloudSQLBuilder extends BaseBuilder {
         this.discoveryPromise = this.discoverInstance();
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        const declaredDbVersion = `${this._engine.toUpperCase()}_${this._engineVersion}`;
+        if (existing.databaseVersion !== declaredDbVersion) {
+            diffs.push({ field: "databaseVersion", declared: declaredDbVersion, live: existing.databaseVersion });
+        }
+        const liveTier = existing.settings?.tier;
+        if (liveTier !== undefined && liveTier !== this._tier) {
+            diffs.push({ field: "tier", declared: this._tier, live: liveTier });
+        }
+        const liveDiskSize = existing.settings?.dataDiskSizeGb;
+        if (liveDiskSize !== undefined && Number(liveDiskSize) !== this._storage) {
+            diffs.push({ field: "storage", declared: `${this._storage} GB`, live: `${liveDiskSize} GB` });
+        }
+        const isPublic = (existing.settings?.ipConfiguration?.authorizedNetworks ?? []).length > 0;
+        if (isPublic !== this._publicAccess) {
+            diffs.push({ field: "publicAccess", declared: this._publicAccess, live: isPublic });
+        }
+        return diffs;
+    }
     async discoverInstance() {
         try {
             const project = getProjectId();

package/dist/providers/gcp/list.js

@@ -1,11 +1,13 @@
 import { gcpFetch, getProjectId } from "./api.js";
 export async function listGcpResources() {
     const project = getProjectId();
-    const [vmRes, sqlRes, runRes, dnsRes] = await Promise.all([
+    const [vmRes, sqlRes, runRes, dnsRes, pubsubRes, secretsRes] = 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(() => ({})),
+        gcpFetch("https://pubsub.googleapis.com", `/v1/projects/${project}/topics`).catch(() => ({})),
+        gcpFetch("https://secretmanager.googleapis.com", `/v1/projects/${project}/secrets`).catch(() => ({})),
     ]);
     // 1. Map VM Instances
     const vms = [];
@@ -51,5 +53,13 @@ export async function listGcpResources() {
         name: z.name,
         dnsName: z.dnsName ?? "",
     }));
-    return { vms, rdsInstances, distributions, hostedZones };
+    // 5. Map Pub/Sub Topics
+    const pubSubTopics = (pubsubRes.topics ?? []).map((t) => ({
+        name: t.name.split("/").pop() ?? t.name,
+    }));
+    // 6. Map Secret Manager Secrets
+    const secrets = (secretsRes.secrets ?? []).map((s) => ({
+        name: s.name.split("/").pop() ?? s.name,
+    }));
+    return { vms, rdsInstances, distributions, hostedZones, pubSubTopics, secrets };
 }

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

@@ -28,6 +28,11 @@ export declare class GCPVMBuilder extends BaseBuilder {
     private resolveUser;
     provision(...playbookPaths: (string | string[])[]): this;
     forceConfigCheck(): this;
+    getDiff(existing: any): {
+        field: string;
+        declared: string;
+        live: any;
+    }[];
     protected checkPort(ip: string, port: number): Promise<boolean>;
     protected runProvisioner(ip: string, script: string): Promise<void>;
     private discoverVM;

package/dist/providers/gcp/vm.js

@@ -71,6 +71,14 @@ export class GCPVMBuilder extends BaseBuilder {
         this._forceConfigCheck = true;
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        const liveMachineType = existing.machineType?.split("/").pop();
+        if (liveMachineType !== undefined && liveMachineType !== this._machineType) {
+            diffs.push({ field: "machineType", declared: this._machineType, live: liveMachineType });
+        }
+        return diffs;
+    }
     async checkPort(ip, port) {
         return checkPort(ip, port);
     }

package/dist/providers/proxmox/list.js

@@ -11,5 +11,12 @@ export async function listProxmoxVMs() {
         maxmem: r.maxmem ?? 0,
         maxdisk: r.maxdisk ?? 0,
     }));
-    return { vms };
+    const templates = (resources ?? [])
+        .filter((r) => r.template === 1)
+        .map((r) => ({
+        name: r.name,
+        vmid: r.vmid,
+        node: r.node,
+    }));
+    return { vms, templates };
 }

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

@@ -38,6 +38,19 @@ export declare class VMBuilder extends ProxmoxBaseBuilder {
     gateway(gw: string): this;
     machine(type: "q35" | "i440fx"): this;
     forceConfigCheck(): this;
+    getDiff(existing: any): ({
+        field: string;
+        declared: number;
+        live: any;
+    } | {
+        field: string;
+        declared: string;
+        live: string;
+    } | {
+        field: string;
+        declared: "q35" | "i440fx";
+        live: any;
+    })[];
     deploy(): Promise<{
         name: string;
         vmid: number | null;

package/dist/providers/proxmox/vm.js

@@ -38,6 +38,9 @@ export class VMBuilder extends ProxmoxBaseBuilder {
                 try {
                     const config = await pm.get(`/nodes/${match.node}/qemu/${match.vmid}/config`);
                     match.description = config.description ?? "";
+                    match.cfgCores = config.cores;
+                    match.cfgMemory = config.memory;
+                    match.cfgMachine = config.machine ?? "q35";
                 }
                 catch (err) {
                     console.warn(`   ⚠️  Could not fetch VM config for ${match.vmid}: ${err.message}`);
@@ -105,6 +108,19 @@ export class VMBuilder extends ProxmoxBaseBuilder {
         this._forceConfigCheck = true;
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.cfgCores !== undefined && existing.cfgCores !== this._cores) {
+            diffs.push({ field: "cores", declared: this._cores, live: existing.cfgCores });
+        }
+        if (existing.cfgMemory !== undefined && existing.cfgMemory !== this._memory) {
+            diffs.push({ field: "memory", declared: `${this._memory} MB`, live: `${existing.cfgMemory} MB` });
+        }
+        if (existing.cfgMachine !== undefined && this._machine !== existing.cfgMachine) {
+            diffs.push({ field: "machine", declared: this._machine, live: existing.cfgMachine });
+        }
+        return diffs;
+    }
     async deploy() {
         try {
             return await this._deploy();

package/dist/types/diff.d.ts

@@ -0,0 +1,17 @@
+export interface FieldDiff {
+    field: string;
+    declared: any;
+    live: any;
+}
+export type ResourceStatus = "missing" | "in-sync" | "drift" | "adopted";
+export interface ResourceDiff {
+    prop: string;
+    resource: string;
+    status: ResourceStatus;
+    changes: FieldDiff[];
+}
+export interface StackDiff {
+    stackName: string;
+    resources: ResourceDiff[];
+    hasDrift: boolean;
+}

package/dist/types/diff.js

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

package/dist/types/inventory.d.ts

@@ -6,8 +6,14 @@ export interface ProxmoxVm {
     maxmem: number;
     maxdisk: number;
 }
+export interface ProxmoxTemplate {
+    name: string;
+    vmid: number;
+    node: string;
+}
 export interface ProxmoxInventory {
     vms: ProxmoxVm[];
+    templates: ProxmoxTemplate[];
 }
 export interface DoDroplet {
     id: number;
@@ -34,11 +40,34 @@ export interface DoDomain {
     name: string;
     ttl: number;
 }
+export interface DoDatabase {
+    id: string;
+    name: string;
+    engine: string;
+    region: string;
+    status: string;
+    nodeCount: number;
+}
+export interface DoApp {
+    id: string;
+    name: string;
+    liveUrl: string;
+    status: string;
+}
+export interface DoVpc {
+    id: string;
+    name: string;
+    region: string;
+    ipRange: string;
+}
 export interface DoInventory {
     droplets: DoDroplet[];
     firewalls: DoFirewall[];
     loadBalancers: DoLoadBalancer[];
     domains: DoDomain[];
+    databases: DoDatabase[];
+    apps: DoApp[];
+    vpcs: DoVpc[];
     totalMonthlyCost: number;
 }
 export interface AwsDistribution {
@@ -67,6 +96,13 @@ export interface AwsHostedZone {
     id: string;
     recordCount: number;
 }
+export interface AwsEc2Instance {
+    id: string;
+    name: string;
+    type: string;
+    state: string;
+    publicIp?: string;
+}
 export interface AwsInventory {
     region: string;
     distributions: AwsDistribution[];
@@ -74,6 +110,7 @@ export interface AwsInventory {
     lambdas: AwsLambdaFn[];
     rdsInstances: AwsRdsInstance[];
     hostedZones: AwsHostedZone[];
+    ec2Instances: AwsEc2Instance[];
 }
 export interface GcpVM {
     name: string;
@@ -97,11 +134,19 @@ export interface GcpCloudDNS {
     name: string;
     dnsName: string;
 }
+export interface GcpPubSubTopic {
+    name: string;
+}
+export interface GcpSecret {
+    name: string;
+}
 export interface GcpInventory {
     vms: GcpVM[];
     rdsInstances: GcpCloudSQL[];
     distributions: GcpCloudRun[];
     hostedZones: GcpCloudDNS[];
+    pubSubTopics: GcpPubSubTopic[];
+    secrets: GcpSecret[];
 }
 export interface FirebaseHosting {
     site: string;
@@ -112,9 +157,29 @@ export interface FirebaseFunction {
     entryPoint: string;
     runtime: string;
 }
+export interface FirebaseFirestoreDb {
+    name: string;
+    type: string;
+    state: string;
+}
+export interface FirebaseStorageBucket {
+    name: string;
+    location: string;
+}
+export interface FirebaseAuthProvider {
+    providerId: string;
+}
+export interface FirebaseRemoteConfig {
+    parameterCount: number;
+    version: string;
+}
 export interface FirebaseInventory {
     hostingSites: FirebaseHosting[];
     functions: FirebaseFunction[];
+    firestoreDbs: FirebaseFirestoreDb[];
+    storageBuckets: FirebaseStorageBucket[];
+    authProviders: FirebaseAuthProvider[];
+    remoteConfig?: FirebaseRemoteConfig;
 }
 export interface InventoryError {
     provider: "proxmox" | "do" | "aws" | "gcp" | "firebase";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "puls-dev",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Intent-driven infrastructure-as-code with eager discovery and no state files.",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,7 +60,7 @@
   "devDependencies": {
     "@types/node": "^25.6.2",
     "ts-node": "^10.9.2",
-    "tsx": "^4.21.0",
+    "tsx": "^4.22.4",
     "typescript": "^6.0.3"
   },
   "dependencies": {