puls-dev 0.3.4 → 0.3.5

package/dist/providers/aws/ec2.js

@@ -67,6 +67,13 @@ export class EC2VMBuilder extends BaseBuilder {
         this._forceConfigCheck = true;
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.InstanceType !== this._instanceType) {
+            diffs.push({ field: "instanceType", declared: this._instanceType, live: existing.InstanceType });
+        }
+        return diffs;
+    }
     async checkPort(ip, port) {
         return checkPort(ip, port);
     }

package/dist/providers/aws/lambda.d.ts

@@ -20,6 +20,11 @@ export declare class LambdaBuilder extends BaseBuilder {
     timeout(seconds: number): this;
     role(arnOrBuilder: string | IAMRoleBuilder): this;
     env(vars: Record<string, string | SecretsBuilder>): this;
+    getDiff(existing: any): {
+        field: string;
+        declared: string;
+        live: any;
+    }[];
     private ensureRole;
     private buildZip;
     deploy(): Promise<{

package/dist/providers/aws/lambda.js

@@ -78,6 +78,30 @@ export class LambdaBuilder extends BaseBuilder {
         this._env = { ...this._env, ...vars };
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.Runtime !== this._runtime) {
+            diffs.push({ field: "runtime", declared: this._runtime, live: existing.Runtime });
+        }
+        if (existing.Handler !== this._handler) {
+            diffs.push({ field: "handler", declared: this._handler, live: existing.Handler });
+        }
+        if (existing.MemorySize !== this._memory) {
+            diffs.push({ field: "memory", declared: `${this._memory} MB`, live: `${existing.MemorySize} MB` });
+        }
+        if (existing.Timeout !== this._timeout) {
+            diffs.push({ field: "timeout", declared: `${this._timeout}s`, live: `${existing.Timeout}s` });
+        }
+        const liveEnv = existing.Environment?.Variables ?? {};
+        const declaredKeys = Object.keys(this._env);
+        const liveKeys = Object.keys(liveEnv);
+        const allKeys = new Set([...declaredKeys, ...liveKeys]);
+        const envDrift = [...allKeys].filter((k) => String(this._env[k]) !== String(liveEnv[k]));
+        if (envDrift.length > 0) {
+            diffs.push({ field: "env", declared: `${declaredKeys.length} vars`, live: `${liveKeys.length} vars (${envDrift.length} changed)` });
+        }
+        return diffs;
+    }
     async ensureRole() {
         if (this._roleBuilder) {
             return await this._roleBuilder.out.arn.get();

package/dist/providers/aws/list.js

@@ -3,16 +3,18 @@ import { ListBucketsCommand } from '@aws-sdk/client-s3';
 import { ListFunctionsCommand } from '@aws-sdk/client-lambda';
 import { DescribeDBInstancesCommand } from '@aws-sdk/client-rds';
 import { ListHostedZonesCommand } from '@aws-sdk/client-route-53';
-import { getCFClient, getS3Client, getLambdaClient, getRDSClient, getR53Client } from './api.js';
+import { DescribeInstancesCommand } from '@aws-sdk/client-ec2';
+import { getCFClient, getS3Client, getLambdaClient, getRDSClient, getR53Client, getEC2Client } from './api.js';
 import { Config } from '../../core/config.js';
 export async function listAwsResources() {
     const region = Config.get().providers.aws.region;
-    const [cfResult, s3Result, lambdaResult, rdsResult, r53Result] = await Promise.all([
+    const [cfResult, s3Result, lambdaResult, rdsResult, r53Result, ec2Result] = await Promise.all([
         getCFClient().send(new ListDistributionsCommand({})),
         getS3Client().send(new ListBucketsCommand({})),
         getLambdaClient().send(new ListFunctionsCommand({ MaxItems: 50 })),
         getRDSClient().send(new DescribeDBInstancesCommand({})),
         getR53Client().send(new ListHostedZonesCommand({})),
+        getEC2Client().send(new DescribeInstancesCommand({ MaxResults: 200 })),
     ]);
     const distributions = (cfResult.DistributionList?.Items ?? []).map((d) => ({
         id: d.Id,
@@ -40,5 +42,15 @@ export async function listAwsResources() {
         id: z.Id.replace('/hostedzone/', ''),
         recordCount: z.ResourceRecordSetCount ?? 0,
     }));
-    return { region, distributions, buckets, lambdas, rdsInstances, hostedZones };
+    const ec2Instances = (ec2Result.Reservations ?? [])
+        .flatMap((r) => r.Instances ?? [])
+        .filter((i) => i.State?.Name !== 'terminated')
+        .map((i) => ({
+        id: i.InstanceId,
+        name: i.Tags?.find((t) => t.Key === 'Name')?.Value ?? i.InstanceId,
+        type: i.InstanceType ?? 'unknown',
+        state: i.State?.Name ?? 'unknown',
+        publicIp: i.PublicIpAddress,
+    }));
+    return { region, distributions, buckets, lambdas, rdsInstances, hostedZones, ec2Instances };
 }

package/dist/providers/aws/rds.d.ts

@@ -24,6 +24,15 @@ export declare class RDSBuilder extends BaseBuilder {
     subnets(ids: string[]): this;
     securityGroups(ids: string[]): this;
     publicAccess(enabled?: boolean): this;
+    getDiff(existing: any): ({
+        field: string;
+        declared: string;
+        live: any;
+    } | {
+        field: string;
+        declared: boolean;
+        live: any;
+    })[];
     database(name: string): this;
     credentials(username: string, password: string): this;
     private discoverInstance;

package/dist/providers/aws/rds.js

@@ -54,6 +54,25 @@ export class RDSBuilder extends BaseBuilder {
         this._publicAccess = enabled;
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.Engine !== this._engine) {
+            diffs.push({ field: "engine", declared: this._engine, live: existing.Engine });
+        }
+        if (existing.EngineVersion !== this._engineVersion) {
+            diffs.push({ field: "engineVersion", declared: this._engineVersion, live: existing.EngineVersion });
+        }
+        if (existing.DBInstanceClass !== this._instanceClass) {
+            diffs.push({ field: "instanceClass", declared: this._instanceClass, live: existing.DBInstanceClass });
+        }
+        if (existing.AllocatedStorage !== this._storage) {
+            diffs.push({ field: "storage", declared: `${this._storage} GB`, live: `${existing.AllocatedStorage} GB` });
+        }
+        if (existing.PubliclyAccessible !== this._publicAccess) {
+            diffs.push({ field: "publicAccess", declared: this._publicAccess, live: existing.PubliclyAccessible });
+        }
+        return diffs;
+    }
     database(name) {
         this._dbName = name;
         return this;

package/dist/providers/do/database.d.ts

@@ -26,6 +26,15 @@ export declare class DatabaseBuilder extends BaseBuilder {
     allowIp(cidr: string): this;
     allowDroplet(dropletId: string): this;
     allowTag(tagName: string): this;
+    getDiff(existing: any): ({
+        field: string;
+        declared: string;
+        live: any;
+    } | {
+        field: string;
+        declared: number;
+        live: any;
+    })[];
     private discoverCluster;
     deploy(): Promise<{
         name: string;

package/dist/providers/do/database.js

@@ -58,6 +58,25 @@ export class DatabaseBuilder extends BaseBuilder {
         this._firewallRules.push({ type: "tag", value: tagName });
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.engine !== this._engine) {
+            diffs.push({ field: "engine", declared: this._engine, live: existing.engine });
+        }
+        if (existing.version !== this._version) {
+            diffs.push({ field: "version", declared: this._version, live: existing.version });
+        }
+        if (existing.size !== this._size) {
+            diffs.push({ field: "size", declared: this._size, live: existing.size });
+        }
+        if (existing.region !== this._region) {
+            diffs.push({ field: "region", declared: this._region, live: existing.region });
+        }
+        if (existing.num_nodes !== this._nodes) {
+            diffs.push({ field: "nodes", declared: this._nodes, live: existing.num_nodes });
+        }
+        return diffs;
+    }
     async discoverCluster(name) {
         try {
             const api = getDoApi();

package/dist/providers/do/domain.js

@@ -104,7 +104,7 @@ export class DomainBuilder extends BaseBuilder {
         if (existing) {
             try {
                 const res = await api.get(`/domains/${this.domainName}/records?per_page=200`);
-                existingRecords = res.domain_records;
+                existingRecords = res.domain_records ?? [];
             }
             catch {
                 existingRecords = [];

package/dist/providers/do/droplet.d.ts

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

package/dist/providers/do/droplet.js

@@ -101,6 +101,16 @@ export class DropletBuilder extends BaseBuilder {
         this._forceConfigCheck = true;
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.size_slug !== this.config.size) {
+            diffs.push({ field: "size", declared: this.config.size, live: existing.size_slug });
+        }
+        if (existing.region?.slug !== this.config.region) {
+            diffs.push({ field: "region", declared: this.config.region, live: existing.region?.slug });
+        }
+        return diffs;
+    }
     async checkPort(ip, port) {
         return checkPort(ip, port);
     }

package/dist/providers/do/list.js

@@ -20,11 +20,14 @@ function priceForSlug(slug) {
 }
 export async function listDoResources() {
     const api = getDoApi();
-    const [dropletsData, firewallsData, lbData, domainsData] = await Promise.all([
+    const [dropletsData, firewallsData, lbData, domainsData, dbData, appsData, vpcsData] = await Promise.all([
         api.get('/droplets?per_page=200'),
         api.get('/firewalls?per_page=200'),
         api.get('/load_balancers?per_page=200'),
         api.get('/domains?per_page=200'),
+        api.get('/databases?per_page=200'),
+        api.get('/apps?per_page=200'),
+        api.get('/vpcs?per_page=200'),
     ]);
     const droplets = dropletsData.droplets.map((d) => {
         const pub = (d.networks?.v4 ?? []).find((n) => n.type === 'public');
@@ -54,6 +57,26 @@ export async function listDoResources() {
         name: d.name,
         ttl: d.ttl,
     }));
+    const databases = (dbData.databases ?? []).map((d) => ({
+        id: d.id,
+        name: d.name,
+        engine: `${d.engine} ${d.version ?? ''}`.trim(),
+        region: d.region ?? '',
+        status: d.status ?? '',
+        nodeCount: d.num_nodes ?? 1,
+    }));
+    const apps = (appsData.apps ?? []).map((a) => ({
+        id: a.id,
+        name: a.spec?.name ?? a.id,
+        liveUrl: a.live_url ?? '',
+        status: a.active_deployment?.phase ?? 'unknown',
+    }));
+    const vpcs = (vpcsData.vpcs ?? []).map((v) => ({
+        id: v.id,
+        name: v.name,
+        region: v.region ?? '',
+        ipRange: v.ip_range ?? '',
+    }));
     const totalMonthlyCost = droplets.reduce((sum, d) => sum + d.monthlyCost, 0);
-    return { droplets, firewalls, loadBalancers, domains, totalMonthlyCost };
+    return { droplets, firewalls, loadBalancers, domains, databases, apps, vpcs, totalMonthlyCost };
 }

package/dist/providers/do/load_balancer.d.ts

@@ -41,6 +41,11 @@ export declare class LoadBalancerBuilder extends BaseBuilder {
     stickySession(type: 'cookies' | 'none', cookieName?: string, cookieTtlSeconds?: number): this;
     private resolveDropletIds;
     private resolveCertificateId;
+    getDiff(existing: any): {
+        field: string;
+        declared: string;
+        live: any;
+    }[];
     deploy(): Promise<any>;
     destroy(): Promise<any>;
 }

package/dist/providers/do/load_balancer.js

@@ -96,6 +96,13 @@ export class LoadBalancerBuilder extends BaseBuilder {
         }
         return match.id;
     }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.region?.slug !== this._region) {
+            diffs.push({ field: "region", declared: this._region, live: existing.region?.slug });
+        }
+        return diffs;
+    }
     async deploy() {
         const dryRun = this.isDryRunActive();
         const existing = await this.discoveryPromise;

package/dist/providers/do/vpc.d.ts

@@ -12,6 +12,11 @@ export declare class VPCBuilder extends BaseBuilder {
     region(r: string): this;
     ipRange(cidr: string): this;
     description(text: string): this;
+    getDiff(existing: any): {
+        field: string;
+        declared: string;
+        live: any;
+    }[];
     private discoverVpc;
     deploy(): Promise<{
         name: string;

package/dist/providers/do/vpc.js

@@ -26,6 +26,14 @@ export class VPCBuilder extends BaseBuilder {
         this._description = text;
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        // region and ip_range are immutable after creation
+        if (this._description !== undefined && existing.description !== this._description) {
+            diffs.push({ field: "description", declared: this._description, live: existing.description });
+        }
+        return diffs;
+    }
     async discoverVpc(name) {
         try {
             const api = getDoApi();

package/dist/providers/firebase/functions.d.ts

@@ -29,6 +29,15 @@ export declare class FirebaseFunctionsBuilder extends BaseBuilder {
     maxInstances(n: number): this;
     minInstances(n: number): this;
     env(vars: Record<string, string>): this;
+    getDiff(existing: any): ({
+        field: string;
+        declared: string;
+        live: any;
+    } | {
+        field: string;
+        declared: number;
+        live: any;
+    })[];
     private fnPath;
     private getExisting;
     private zipSource;

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;