puls-dev 0.2.7 → 0.2.8

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

@@ -0,0 +1,321 @@
+import { test, describe, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import fs from "node:fs";
+import { GoogleAuth } from "google-auth-library";
+import { GCPVMBuilder } from "./vm.js";
+import { Config } from "../../core/config.js";
+import { getFileHash } from "../proxmox/hash.js";
+describe("GCPVMBuilder Unit Tests", () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                gcp: {
+                    projectId: "my-gcp-project",
+                    serviceAccountPath: "/fake/sa.json",
+                    region: "us-central1",
+                },
+            },
+        });
+        originalFetch = globalThis.fetch;
+        fetchCalls = [];
+        mockResponses = {};
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? "GET";
+            let body;
+            if (init?.body) {
+                if (typeof init.body === "string") {
+                    try {
+                        body = JSON.parse(init.body);
+                    }
+                    catch {
+                        body = init.body;
+                    }
+                }
+                else {
+                    body = "[Binary/Buffer Body]";
+                }
+            }
+            const headers = init?.headers;
+            fetchCalls.push({ url, method, body, headers });
+            const matchKey = Object.keys(mockResponses)
+                .filter((key) => {
+                const [mMethod, mPath] = key.split(" ");
+                return method === mMethod && url.includes(mPath);
+            })
+                .sort((a, b) => b.split(" ")[1].length - a.split(" ")[1].length)[0];
+            if (matchKey) {
+                const resp = mockResponses[matchKey];
+                return {
+                    ok: resp.status >= 200 && resp.status < 300,
+                    status: resp.status,
+                    json: async () => resp.body,
+                    text: async () => JSON.stringify(resp.body),
+                };
+            }
+            return {
+                ok: false,
+                status: 404,
+                json: async () => ({ error: { message: `Endpoint not mocked: ${method} ${url}` } }),
+                text: async () => `Endpoint not mocked: ${method} ${url}`,
+            };
+        };
+        mock.method(GoogleAuth.prototype, "getClient", async () => {
+            return {
+                getAccessToken: async () => ({ token: "fake-gcp-token" }),
+            };
+        });
+        mock.method(fs, "readFileSync", () => {
+            return "ssh-rsa AAAA_FAKE_GCP_PUBLIC_KEY test@gcp.com";
+        });
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        mock.restoreAll();
+    });
+    test("handles discovery when VM does not exist", async () => {
+        mockResponses["GET /instances/my-gcp-vm"] = {
+            status: 404,
+            body: { error: { message: "Not Found" } },
+        };
+        const builder = new GCPVMBuilder("my-gcp-vm");
+        const existing = await builder.discoveryPromise;
+        assert.strictEqual(existing, null);
+        const getCall = fetchCalls.find((c) => c.method === "GET" && c.url.includes("/instances/my-gcp-vm"));
+        assert.ok(getCall);
+    });
+    test("discovers VM successfully when it exists", async () => {
+        mockResponses["GET /instances/my-gcp-vm"] = {
+            status: 200,
+            body: {
+                id: "vm-123456",
+                name: "my-gcp-vm",
+                status: "RUNNING",
+                networkInterfaces: [
+                    {
+                        accessConfigs: [{ natIP: "34.56.78.90" }],
+                    },
+                ],
+                metadata: {
+                    items: [{ key: "puls-provision", value: "nginx-yaml=abc123123123" }],
+                },
+            },
+        };
+        const builder = new GCPVMBuilder("my-gcp-vm");
+        const existing = await builder.discoveryPromise;
+        assert.ok(existing);
+        assert.strictEqual(existing.id, "vm-123456");
+        const resolvedId = await builder.out.id.get();
+        const resolvedIp = await builder.out.ip.get();
+        assert.strictEqual(resolvedId, "vm-123456");
+        assert.strictEqual(resolvedIp, "34.56.78.90");
+    });
+    test("runs in dry-run mode safely and logs plan", async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                gcp: { projectId: "my-gcp-project", serviceAccountPath: "/fake/sa.json" },
+            },
+        });
+        mockResponses["GET /instances/new-gcp-vm"] = {
+            status: 404,
+            body: { error: { message: "Not Found" } },
+        };
+        const builder = new GCPVMBuilder("new-gcp-vm")
+            .machineType("e2-medium")
+            .zone("europe-west1-b")
+            .provision("playbooks/nginx.yaml");
+        const res = await builder.deploy();
+        assert.deepStrictEqual(res, { name: "new-gcp-vm", id: "PENDING" });
+        const resolvedId = await builder.out.id.get();
+        const resolvedIp = await builder.out.ip.get();
+        assert.strictEqual(resolvedId, "PENDING");
+        assert.strictEqual(resolvedIp, "0.0.0.0");
+        // Ensure no writes were performed
+        const writeCalls = fetchCalls.filter((c) => c.method === "POST" || c.method === "DELETE");
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test("creates a new VM instance and runs playbooks successfully", async () => {
+        mockResponses["GET /instances/new-vm"] = {
+            status: 404,
+            body: { error: { message: "Not Found" } },
+        };
+        mockResponses["POST /instances"] = {
+            status: 200,
+            body: { id: "op-111", status: "DONE" },
+        };
+        // Subsequents GET during wait loop returns RUNNING
+        let getCount = 0;
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? "GET";
+            const body = init?.body ? JSON.parse(init.body) : undefined;
+            fetchCalls.push({ url, method, body });
+            if (method === "GET" && url.includes("/instances/new-vm")) {
+                const createCall = fetchCalls.find(c => c.method === "POST" && c.url.includes("/instances"));
+                if (!createCall) {
+                    return {
+                        ok: false,
+                        status: 404,
+                        json: async () => ({ error: { message: "Not Found" } }),
+                        text: async () => JSON.stringify({ error: { message: "Not Found" } }),
+                    };
+                }
+                getCount++;
+                const data = {
+                    id: "new-vm-uuid",
+                    name: "new-vm",
+                    status: getCount > 1 ? "RUNNING" : "PROVISIONING",
+                    networkInterfaces: [
+                        {
+                            accessConfigs: [{ natIP: "35.200.10.20" }],
+                        },
+                    ],
+                };
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => data,
+                    text: async () => JSON.stringify(data),
+                };
+            }
+            if (method === "POST" && url.includes("/instances")) {
+                const opData = { id: "op-111", status: "DONE" };
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => opData,
+                    text: async () => JSON.stringify(opData),
+                };
+            }
+            return { ok: false, status: 404 };
+        };
+        const builder = new GCPVMBuilder("new-vm")
+            .machineType("e2-medium")
+            .zone("us-central1-a")
+            .sshKey("~/.ssh/id_rsa.pub")
+            .provision("playbooks/nginx.yaml");
+        const provisionCalls = [];
+        builder.waitFor = async (label, condition) => {
+            return await condition();
+        };
+        builder.checkPort = async () => true;
+        builder.runProvisioner = async (ip, script) => {
+            provisionCalls.push(script);
+        };
+        const res = await builder.deploy();
+        assert.ok(res);
+        assert.strictEqual(res.id, "new-vm-uuid");
+        assert.strictEqual(res.ip, "35.200.10.20");
+        assert.strictEqual(provisionCalls.length, 1);
+        assert.strictEqual(provisionCalls[0], "playbooks/nginx.yaml");
+        const createCall = fetchCalls.find((c) => c.method === "POST" && c.url.includes("/instances"));
+        assert.ok(createCall);
+        assert.strictEqual(createCall.body.name, "new-vm");
+        assert.strictEqual(createCall.body.machineType, "zones/us-central1-a/machineTypes/e2-medium");
+        const sshMetadata = createCall.body.metadata.items.find((i) => i.key === "ssh-keys");
+        assert.strictEqual(sshMetadata.value, "root:ssh-rsa AAAA_FAKE_GCP_PUBLIC_KEY test@gcp.com");
+        const provMetadata = createCall.body.metadata.items.find((i) => i.key === "puls-provision");
+        assert.ok(provMetadata.value.startsWith("nginx-yaml="));
+    });
+    test("skips playbook execution on existing VM if hashes match", async () => {
+        const nginxHash = getFileHash("playbooks/nginx.yaml");
+        mockResponses["GET /instances/exist-vm"] = {
+            status: 200,
+            body: {
+                id: "exist-vm-id",
+                name: "exist-vm",
+                status: "RUNNING",
+                machineType: "zones/us-central1-a/machineTypes/e2-micro",
+                networkInterfaces: [
+                    {
+                        accessConfigs: [{ natIP: "35.200.10.30" }],
+                    },
+                ],
+                metadata: {
+                    items: [{ key: "puls-provision", value: `nginx-yaml=${nginxHash}` }],
+                },
+            },
+        };
+        const builder = new GCPVMBuilder("exist-vm")
+            .machineType("e2-micro")
+            .zone("us-central1-a")
+            .provision("playbooks/nginx.yaml");
+        const provisionCalls = [];
+        builder.runProvisioner = async (ip, script) => {
+            provisionCalls.push(script);
+        };
+        await builder.deploy();
+        // No playbooks should run
+        assert.strictEqual(provisionCalls.length, 0);
+        // No setMetadata call
+        const setMetaCall = fetchCalls.find((c) => c.method === "POST" && c.url.includes("/setMetadata"));
+        assert.strictEqual(setMetaCall, undefined);
+    });
+    test("executes playbooks on existing VM if hashes differ, updating metadata", async () => {
+        mockResponses["GET /instances/exist-diff-vm"] = {
+            status: 200,
+            body: {
+                id: "exist-diff-vm-id",
+                name: "exist-diff-vm",
+                status: "RUNNING",
+                machineType: "zones/us-central1-a/machineTypes/e2-micro",
+                networkInterfaces: [
+                    {
+                        accessConfigs: [{ natIP: "35.200.10.40" }],
+                    },
+                ],
+                metadata: {
+                    fingerprint: "old-fingerprint-123",
+                    items: [{ key: "puls-provision", value: "nginx-yaml=abc123123123" }],
+                },
+            },
+        };
+        mockResponses["POST /instances/exist-diff-vm/setMetadata"] = {
+            status: 200,
+            body: {},
+        };
+        const builder = new GCPVMBuilder("exist-diff-vm")
+            .machineType("e2-micro")
+            .zone("us-central1-a")
+            .provision("playbooks/nginx.yaml");
+        const provisionCalls = [];
+        builder.waitFor = async (label, condition) => {
+            return await condition();
+        };
+        builder.checkPort = async () => true;
+        builder.runProvisioner = async (ip, script) => {
+            provisionCalls.push(script);
+        };
+        await builder.deploy();
+        assert.strictEqual(provisionCalls.length, 1);
+        assert.strictEqual(provisionCalls[0], "playbooks/nginx.yaml");
+        // Verify setMetadata was dispatched with new hashes and correct fingerprint
+        const setMetaCall = fetchCalls.find((c) => c.method === "POST" && c.url.includes("/setMetadata"));
+        assert.ok(setMetaCall);
+        assert.strictEqual(setMetaCall.body.fingerprint, "old-fingerprint-123");
+        const provMetadata = setMetaCall.body.items.find((i) => i.key === "puls-provision");
+        const expectedHash = getFileHash("playbooks/nginx.yaml");
+        assert.strictEqual(provMetadata.value, `nginx-yaml=${expectedHash}`);
+    });
+    test("destroys VM successfully", async () => {
+        mockResponses["GET /instances/delete-vm"] = {
+            status: 200,
+            body: { id: "delete-vm-id", name: "delete-vm" },
+        };
+        mockResponses["DELETE /instances/delete-vm"] = {
+            status: 200,
+            body: {},
+        };
+        const builder = new GCPVMBuilder("delete-vm");
+        await builder.discoveryPromise;
+        const res = await builder.destroy();
+        assert.deepStrictEqual(res, { destroyed: "delete-vm" });
+        const deleteCall = fetchCalls.find((c) => c.method === "DELETE" && c.url.includes("/instances/delete-vm"));
+        assert.ok(deleteCall);
+    });
+});

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

@@ -20,6 +20,7 @@ export declare class VMBuilder extends BaseBuilder {
     private _ip?;
     private _sshKeys?;
     private _machine;
+    private _forceConfigCheck;
     constructor(name: string);
     private discoverVm;
     image(os: OSImage): this;
@@ -33,6 +34,7 @@ export declare class VMBuilder extends BaseBuilder {
     ip(address: string): this;
     sshKey(keys: string | readonly string[]): this;
     machine(type: "q35" | "i440fx"): this;
+    forceConfigCheck(): this;
     deploy(): Promise<{
         name: string;
         vmid: number | null;
@@ -55,9 +57,7 @@ export declare class VMBuilder extends BaseBuilder {
     private destroyVmByName;
     private resolvePublicKeys;
     private checkCloudInit;
-    private checkPort;
+    protected checkPort(ip: string, port: number): Promise<boolean>;
+    protected runProvisioner(ip: string, script: string): Promise<void>;
     private sshKeyPath;
-    private runProvisioner;
-    private runPuppet;
-    private runAnsible;
 }

package/dist/providers/proxmox/vm.js

@@ -1,12 +1,12 @@
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
-import { createConnection } from "node:net";
 import { BaseBuilder } from "../../core/resource.js";
 import { Config } from "../../core/config.js";
 import { Output } from "../../core/output.js";
 import { getPMClient } from "./api.js";
 import { getFileHash, parseProvisionMetadata, mergeProvisionMetadata } from "./hash.js";
+import { checkPort, runProvisioner } from "../../core/provisioner.js";
 export class VMBuilder extends BaseBuilder {
     out = {
         ip: new Output(),
@@ -26,6 +26,7 @@ export class VMBuilder extends BaseBuilder {
     _ip;
     _sshKeys;
     _machine = "q35";
+    _forceConfigCheck = false;
     constructor(name) {
         super(name);
         this.discoveryPromise = this.discoverVm(name);
@@ -96,6 +97,10 @@ export class VMBuilder extends BaseBuilder {
         this._machine = type;
         return this;
     }
+    forceConfigCheck() {
+        this._forceConfigCheck = true;
+        return this;
+    }
     async deploy() {
         const dryRun = this.isDryRunActive();
         const existing = await this.discoveryPromise;
@@ -116,10 +121,12 @@ export class VMBuilder extends BaseBuilder {
                 const baseName = p.split("/").pop() ?? p;
                 return { path: p, baseName, hash: getFileHash(p) };
             });
-            const playbooksToRun = declaredPlaybooksWithHashes.filter((p) => {
-                const appliedHash = appliedHashes[p.baseName];
-                return !appliedHash || appliedHash !== p.hash;
-            });
+            const playbooksToRun = this._forceConfigCheck
+                ? declaredPlaybooksWithHashes
+                : declaredPlaybooksWithHashes.filter((p) => {
+                    const appliedHash = appliedHashes[p.baseName];
+                    return !appliedHash || appliedHash !== p.hash;
+                });
             if (playbooksToRun.length > 0) {
                 console.log(`\n🖥️  Finalizing Proxmox VM "${this.name}"...`);
                 console.log(`   ✅ VM "${this.name}" already exists (vmid=${existing.vmid}, node=${existing.node}, status=${existing.status})`);
@@ -480,19 +487,11 @@ export class VMBuilder extends BaseBuilder {
             proc.on("error", () => resolve(false));
         });
     }
-    checkPort(ip, port) {
-        return new Promise((resolve) => {
-            const socket = createConnection({ host: ip, port, timeout: 3_000 });
-            socket.on("connect", () => {
-                socket.destroy();
-                resolve(true);
-            });
-            socket.on("timeout", () => {
-                socket.destroy();
-                resolve(false);
-            });
-            socket.on("error", () => resolve(false));
-        });
+    async checkPort(ip, port) {
+        return checkPort(ip, port);
+    }
+    async runProvisioner(ip, script) {
+        return runProvisioner(ip, "root", this._sshKeys, script);
     }
     sshKeyPath() {
         const keyInput = Array.isArray(this._sshKeys)
@@ -505,79 +504,4 @@ export class VMBuilder extends BaseBuilder {
             ? keyInput.replace(/\.pub$/, "")
             : `${homedir()}/.ssh/id_ed25519`).replace(/^~/, homedir());
     }
-    runProvisioner(ip, script) {
-        const ext = script.split(".").pop()?.toLowerCase();
-        if (ext === "sh") {
-            throw new Error(`Shell script provisioning (.sh) is no longer supported. ` +
-                `Please migrate "${script}" to an Ansible playbook (.yaml/.yml).`);
-        }
-        if (ext === "pp")
-            return this.runPuppet(ip, script);
-        return this.runAnsible(ip, script); // .yml / .yaml
-    }
-    runPuppet(ip, manifest) {
-        console.log(`   🔧 Applying Puppet manifest: ${manifest} → ${ip}`);
-        const keyPath = this.sshKeyPath();
-        // Copy manifest then apply it
-        return new Promise((resolve, reject) => {
-            const scp = spawn("scp", [
-                "-i",
-                keyPath,
-                "-o",
-                "StrictHostKeyChecking=no",
-                manifest,
-                `root@${ip}:/tmp/manifest.pp`,
-            ], { stdio: "inherit" });
-            scp.on("close", (code) => {
-                if (code !== 0) {
-                    reject(new Error(`scp exited with code ${code}`));
-                    return;
-                }
-                const puppet = spawn("ssh", [
-                    "-i",
-                    keyPath,
-                    "-o",
-                    "StrictHostKeyChecking=no",
-                    `root@${ip}`,
-                    "puppet apply /tmp/manifest.pp",
-                ], { stdio: "inherit" });
-                puppet.on("close", (c) => {
-                    if (c === 0) {
-                        console.log(`   ✅ Provisioning complete`);
-                        resolve();
-                    }
-                    else
-                        reject(new Error(`puppet apply exited with code ${c}`));
-                });
-                puppet.on("error", (err) => reject(new Error(`Failed to run puppet: ${err.message}`)));
-            });
-            scp.on("error", (err) => reject(new Error(`Failed to run scp: ${err.message}`)));
-        });
-    }
-    runAnsible(ip, playbook) {
-        console.log(`   🔧 Running Ansible: ${playbook} → ${ip}`);
-        const keyPath = this.sshKeyPath();
-        return new Promise((resolve, reject) => {
-            const proc = spawn("ansible-playbook", [
-                playbook,
-                "-i",
-                `${ip},`,
-                "-u",
-                "root",
-                "--private-key",
-                keyPath,
-                "--ssh-extra-args",
-                "-o StrictHostKeyChecking=no -o ConnectTimeout=30",
-            ], { stdio: "inherit" });
-            proc.on("close", (code) => {
-                if (code === 0) {
-                    console.log(`   ✅ Provisioning complete`);
-                    resolve();
-                }
-                else
-                    reject(new Error(`ansible-playbook exited with code ${code}`));
-            });
-            proc.on("error", (err) => reject(new Error(`Failed to run ansible-playbook: ${err.message}`)));
-        });
-    }
 }

package/dist/providers/proxmox/vm.test.js

@@ -1,9 +1,20 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 import { test, describe, beforeEach, afterEach } from "node:test";
 import assert from "node:assert";
 import { ProxmoxApiClient } from "./api.js";
 import { VMBuilder } from "./vm.js";
 import { Config } from "../../core/config.js";
 import { getFileHash, parseProvisionMetadata, mergeProvisionMetadata } from "./hash.js";
+import { Stack } from "../../core/stack.js";
+import { ForceConfigCheck } from "../../core/decorators.js";
 describe("Proxmox VMBuilder Unit Tests", () => {
     let originalGet;
     let originalPost;
@@ -263,6 +274,72 @@ describe("Proxmox VMBuilder Unit Tests", () => {
         assert.strictEqual(updateConfigCall.body.description, expectedDescription);
         assert.ok(expectedDescription.startsWith("User notes preserved"));
     });
+    test("forceConfigCheck() builder method forces playbook execution even if hashes match", async () => {
+        const nginxHash = getFileHash("playbooks/nginx.yaml");
+        const descriptionNotes = mergeProvisionMetadata("User notes", {
+            "nginx.yaml": nginxHash,
+        });
+        mockGetResponses["/cluster/resources?type=vm"] = [
+            { name: "force-vm", vmid: 200, node: "pve1", template: 0, status: "running" },
+        ];
+        mockGetResponses["/nodes/pve1/qemu/200/config"] = {
+            description: descriptionNotes,
+        };
+        const builder = new VMBuilder("force-vm")
+            .ip("10.8.10.95")
+            .provision("playbooks/nginx.yaml")
+            .forceConfigCheck();
+        const provisionCalls = [];
+        // Overrides
+        builder.waitFor = async (label, condition) => {
+            return await condition();
+        };
+        builder.checkPort = async () => true;
+        builder.checkCloudInit = async () => true;
+        builder.runProvisioner = async (ip, script) => {
+            provisionCalls.push({ ip, script });
+        };
+        const deployResult = await builder.deploy();
+        assert.strictEqual(deployResult.vmid, 200);
+        // Verify playbook WAS executed because of forceConfigCheck()
+        assert.strictEqual(provisionCalls.length, 1);
+        assert.strictEqual(provisionCalls[0].script, "playbooks/nginx.yaml");
+    });
+    test("ForceConfigCheck decorator forces playbook execution even if hashes match", async () => {
+        const nginxHash = getFileHash("playbooks/nginx.yaml");
+        const descriptionNotes = mergeProvisionMetadata("User notes", {
+            "nginx.yaml": nginxHash,
+        });
+        mockGetResponses["/cluster/resources?type=vm"] = [
+            { name: "force-dec-vm", vmid: 200, node: "pve1", template: 0, status: "running" },
+        ];
+        mockGetResponses["/nodes/pve1/qemu/200/config"] = {
+            description: descriptionNotes,
+        };
+        const provisionCalls = [];
+        class TestStack extends Stack {
+            server = new VMBuilder("force-dec-vm")
+                .ip("10.8.10.95")
+                .provision("playbooks/nginx.yaml");
+        }
+        __decorate([
+            ForceConfigCheck,
+            __metadata("design:type", Object)
+        ], TestStack.prototype, "server", void 0);
+        const stack = new TestStack();
+        stack.server.waitFor = async (label, condition) => {
+            return await condition();
+        };
+        stack.server.checkPort = async () => true;
+        stack.server.checkCloudInit = async () => true;
+        stack.server.runProvisioner = async (ip, script) => {
+            provisionCalls.push({ ip, script });
+        };
+        await stack.deploy();
+        // Verify playbook WAS executed because of @ForceConfigCheck decorator
+        assert.strictEqual(provisionCalls.length, 1);
+        assert.strictEqual(provisionCalls[0].script, "playbooks/nginx.yaml");
+    });
 });
 describe("Proxmox Provision Hash & Metadata Utilities", () => {
     test("parseProvisionMetadata parses valid, invalid, and empty strings", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "puls-dev",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "Intent-driven infrastructure-as-code with eager discovery and no state files.",
   "type": "module",
   "main": "./dist/index.js",
@@ -70,6 +70,7 @@
     "@aws-sdk/client-secrets-manager": "^3.1053.0",
     "@aws-sdk/client-sns": "^3.1053.0",
     "@aws-sdk/client-sqs": "^3.1053.0",
+    "@aws-sdk/client-ssm": "^3.1053.0",
     "@types/node": "^25.6.2",
     "google-auth-library": "^10.6.2",
     "ts-node": "^10.9.2",
@@ -94,6 +95,7 @@
     "@aws-sdk/client-secrets-manager": "^3.1053.0",
     "@aws-sdk/client-sns": "^3.1053.0",
     "@aws-sdk/client-sqs": "^3.1053.0",
+    "@aws-sdk/client-ssm": "^3.1053.0",
     "dotenv": "^17.4.2",
     "google-auth-library": "^10.6.2",
     "reflect-metadata": "^0.2.2",