puls-dev 0.2.8 → 0.3.0

package/dist/core/stack.js

@@ -1,24 +1,37 @@
 import "reflect-metadata";
 import { BaseBuilder } from "./resource.js";
+import { Config } from "./config.js";
+import { resourceContextStorage } from "./context.js";
+import { resolvedSecrets } from "./secret.js";
 const _registry = new Map();
-function formatEntry(val) {
+function formatEntry(val, parentKey) {
+    const isSensitiveKey = (k) => /password|secret|token|key/i.test(k);
+    if (parentKey && isSensitiveKey(parentKey)) {
+        return { primary: "********" };
+    }
     if (!val || typeof val !== "object")
         return { primary: String(val) };
+    const redactedVal = { ...val };
+    for (const k of Object.keys(redactedVal)) {
+        if (isSensitiveKey(k)) {
+            redactedVal[k] = "********";
+        }
+    }
     // Known shapes
-    if ("destroyed" in val)
-        return { primary: val.destroyed ? "🗑️  destroyed" : "─  not found" };
-    if (val.zone)
-        return { primary: val.zone };
-    if (val.name && val.id)
-        return { primary: `${val.name}  [${val.id}]` };
-    if (val.name)
-        return { primary: val.name };
-    if (val.arn)
-        return { primary: val.arn };
+    if ("destroyed" in redactedVal)
+        return { primary: redactedVal.destroyed ? "🗑️  destroyed" : "─  not found" };
+    if (redactedVal.zone)
+        return { primary: redactedVal.zone };
+    if (redactedVal.name && redactedVal.id)
+        return { primary: `${redactedVal.name}  [${redactedVal.id}]` };
+    if (redactedVal.name)
+        return { primary: redactedVal.name };
+    if (redactedVal.arn)
+        return { primary: redactedVal.arn };
     // Generic: pull all scalar values
-    const pairs = Object.entries(val).filter(([, v]) => typeof v === "string" || typeof v === "number");
+    const pairs = Object.entries(redactedVal).filter(([, v]) => typeof v === "string" || typeof v === "number");
     if (pairs.length === 0)
-        return { primary: JSON.stringify(val) };
+        return { primary: JSON.stringify(redactedVal) };
     // Try compact inline (values only, dot-separated)
     const inline = pairs.map(([, v]) => v).join("  ·  ");
     if (inline.length <= 52)
@@ -35,7 +48,7 @@ function printOutputs(stackName, outputs) {
     const keyWidth = Math.max(...Object.keys(outputs).map((k) => k.length));
     const rows = Object.entries(outputs).map(([key, val]) => ({
         key,
-        ...formatEntry(val),
+        ...formatEntry(val, key),
     }));
     // textWidth = width of row text content (without the 2-space padding on each side)
     const textWidth = Math.max(...rows.flatMap(({ key, primary, sub }) => [
@@ -87,75 +100,368 @@ export class Stack {
         return instance;
     }
     async deploy() {
-        console.log(`\n🏗️  Deploying Stack: ${this.constructor.name}`);
-        // Stack-level beforeDeploy hook
-        if (typeof this.beforeDeploy === "function") {
-            console.log(`   ⚡ Running Stack-level beforeDeploy hook...`);
-            await this.beforeDeploy();
-        }
-        const props = Object.getOwnPropertyNames(this);
-        const outputs = {};
-        for (const prop of props) {
-            const resource = this[prop];
-            if (resource instanceof BaseBuilder) {
-                const isProtected = Reflect.getMetadata("protected", this, prop);
-                const isDestroyed = Reflect.getMetadata("destroy", this, prop);
-                if (isProtected)
-                    resource.protect();
-                const forceConfigCheck = Reflect.getMetadata("forceConfigCheck", this, prop);
-                if (forceConfigCheck && typeof resource.forceConfigCheck === "function") {
-                    resource.forceConfigCheck();
+        const controller = new AbortController();
+        const hosts = [];
+        const context = {
+            abortSignal: controller.signal,
+            hosts,
+            stackName: this.constructor.name
+        };
+        return resourceContextStorage.run(context, async () => {
+            const originalLog = console.log;
+            console.log = (...args) => {
+                const redact = (message) => {
+                    if (typeof message !== "string")
+                        return message;
+                    let result = message;
+                    for (const secret of resolvedSecrets) {
+                        if (secret && secret.length >= 3) {
+                            const escaped = secret.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+                            const regex = new RegExp(escaped, 'g');
+                            result = result.replace(regex, '********');
+                        }
+                    }
+                    return result;
+                };
+                const redactedArgs = args.map(arg => {
+                    if (typeof arg === "string") {
+                        return redact(arg);
+                    }
+                    try {
+                        const str = String(arg);
+                        let hasSecret = false;
+                        for (const secret of resolvedSecrets) {
+                            if (secret && secret.length >= 3 && str.includes(secret)) {
+                                hasSecret = true;
+                                break;
+                            }
+                        }
+                        if (hasSecret) {
+                            return redact(str);
+                        }
+                    }
+                    catch { }
+                    return arg;
+                });
+                originalLog(...redactedArgs);
+            };
+            try {
+                console.log(`\n🏗️  Deploying Stack: ${this.constructor.name}`);
+                // Stack-level beforeDeploy hook
+                if (typeof this.beforeDeploy === "function") {
+                    console.log(`   ⚡ Running Stack-level beforeDeploy hook...`);
+                    await this.beforeDeploy();
+                }
+                const props = Object.getOwnPropertyNames(this);
+                const outputs = {};
+                const isParallel = Config.isParallelActive();
+                // 1. Gather all resources
+                const resources = [];
+                for (const prop of props) {
+                    const val = this[prop];
+                    if (val instanceof BaseBuilder) {
+                        resources.push({ prop, resource: val });
+                        // Apply metadata properties eagerly
+                        const isProtected = Reflect.getMetadata("protected", this, prop);
+                        if (isProtected)
+                            val.protect();
+                        const forceConfigCheck = Reflect.getMetadata("forceConfigCheck", this, prop);
+                        if (forceConfigCheck && typeof val.forceConfigCheck === "function") {
+                            val.forceConfigCheck();
+                        }
+                    }
+                    else if (Array.isArray(val)) {
+                        const isProtected = Reflect.getMetadata("protected", this, prop);
+                        const forceConfigCheck = Reflect.getMetadata("forceConfigCheck", this, prop);
+                        for (const item of val) {
+                            if (item instanceof BaseBuilder) {
+                                resources.push({ prop, resource: item });
+                                if (isProtected)
+                                    item.protect();
+                                if (forceConfigCheck && typeof item.forceConfigCheck === "function") {
+                                    item.forceConfigCheck();
+                                }
+                            }
+                        }
+                    }
                 }
-                let res;
-                if (isDestroyed) {
-                    await resource._runBeforeDestroy();
-                    res = await resource.destroy();
-                    await resource._runAfterDestroy(res);
+                // 2. Schedule execution
+                if (isParallel) {
+                    const startPromise = Promise.resolve();
+                    const promises = resources.map(({ prop, resource }) => {
+                        resource._deployPromise = (async () => {
+                            try {
+                                await startPromise;
+                                if (controller.signal.aborted) {
+                                    throw new Error("Deployment aborted due to previous failure");
+                                }
+                                // Wait for explicit dependencies
+                                for (const dep of resource._dependencies) {
+                                    if (dep._deployPromise) {
+                                        await dep._deployPromise;
+                                    }
+                                }
+                                if (controller.signal.aborted) {
+                                    throw new Error("Deployment aborted due to previous failure");
+                                }
+                                // Execute hooks and deploy
+                                const isDestroyed = Reflect.getMetadata("destroy", this, prop);
+                                let res;
+                                if (isDestroyed) {
+                                    await resource._runBeforeDestroy();
+                                    res = await resource.destroy();
+                                    await resource._runAfterDestroy(res);
+                                }
+                                else {
+                                    await resource._runBeforeDeploy();
+                                    res = await resource.deploy();
+                                    await resource._runAfterDeploy(res);
+                                }
+                                const propVal = this[prop];
+                                if (Array.isArray(propVal)) {
+                                    const idx = propVal.indexOf(resource);
+                                    if (idx !== -1) {
+                                        if (!outputs[prop]) {
+                                            outputs[prop] = [];
+                                        }
+                                        outputs[prop][idx] = res;
+                                    }
+                                }
+                                else {
+                                    outputs[prop] = res;
+                                }
+                                return res;
+                            }
+                            catch (err) {
+                                controller.abort();
+                                throw err;
+                            }
+                        })();
+                        return resource._deployPromise;
+                    });
+                    await Promise.all(promises);
                 }
                 else {
-                    await resource._runBeforeDeploy();
-                    res = await resource.deploy();
-                    await resource._runAfterDeploy(res);
+                    // Sequential mode
+                    for (const { prop, resource } of resources) {
+                        if (controller.signal.aborted) {
+                            throw new Error("Deployment aborted due to previous failure");
+                        }
+                        try {
+                            const isDestroyed = Reflect.getMetadata("destroy", this, prop);
+                            let res;
+                            if (isDestroyed) {
+                                await resource._runBeforeDestroy();
+                                res = await resource.destroy();
+                                await resource._runAfterDestroy(res);
+                            }
+                            else {
+                                await resource._runBeforeDeploy();
+                                res = await resource.deploy();
+                                await resource._runAfterDeploy(res);
+                            }
+                            const propVal = this[prop];
+                            if (Array.isArray(propVal)) {
+                                const idx = propVal.indexOf(resource);
+                                if (idx !== -1) {
+                                    if (!outputs[prop]) {
+                                        outputs[prop] = [];
+                                    }
+                                    outputs[prop][idx] = res;
+                                }
+                            }
+                            else {
+                                outputs[prop] = res;
+                            }
+                        }
+                        catch (err) {
+                            controller.abort();
+                            throw err;
+                        }
+                    }
                 }
-                outputs[prop] = res;
+                printOutputs(this.constructor.name, outputs);
+                // Stack-level afterDeploy hook
+                if (typeof this.afterDeploy === "function") {
+                    console.log(`   ⚡ Running Stack-level afterDeploy hook...`);
+                    await this.afterDeploy(outputs);
+                }
+                return outputs;
             }
-        }
-        printOutputs(this.constructor.name, outputs);
-        // Stack-level afterDeploy hook
-        if (typeof this.afterDeploy === "function") {
-            console.log(`   ⚡ Running Stack-level afterDeploy hook...`);
-            await this.afterDeploy(outputs);
-        }
-        return outputs;
+            finally {
+                console.log = originalLog;
+            }
+        });
     }
     async destroy() {
-        console.log(`\n💥 Tearing down Stack: ${this.constructor.name}`);
-        // Stack-level beforeDestroy hook
-        if (typeof this.beforeDestroy === "function") {
-            console.log(`   ⚡ Running Stack-level beforeDestroy hook...`);
-            await this.beforeDestroy();
-        }
-        const props = Object.getOwnPropertyNames(this).reverse();
-        const outputs = {};
-        for (const prop of props) {
-            const resource = this[prop];
-            if (resource instanceof BaseBuilder) {
-                if (Reflect.getMetadata("protected", this, prop)) {
-                    console.log(`   🔒 Skipping protected resource "${prop}"`);
-                    continue;
+        const controller = new AbortController();
+        const hosts = [];
+        const context = {
+            abortSignal: controller.signal,
+            hosts,
+            stackName: this.constructor.name
+        };
+        return resourceContextStorage.run(context, async () => {
+            const originalLog = console.log;
+            console.log = (...args) => {
+                const redact = (message) => {
+                    if (typeof message !== "string")
+                        return message;
+                    let result = message;
+                    for (const secret of resolvedSecrets) {
+                        if (secret && secret.length >= 3) {
+                            const escaped = secret.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+                            const regex = new RegExp(escaped, 'g');
+                            result = result.replace(regex, '********');
+                        }
+                    }
+                    return result;
+                };
+                const redactedArgs = args.map(arg => {
+                    if (typeof arg === "string") {
+                        return redact(arg);
+                    }
+                    try {
+                        const str = String(arg);
+                        let hasSecret = false;
+                        for (const secret of resolvedSecrets) {
+                            if (secret && secret.length >= 3 && str.includes(secret)) {
+                                hasSecret = true;
+                                break;
+                            }
+                        }
+                        if (hasSecret) {
+                            return redact(str);
+                        }
+                    }
+                    catch { }
+                    return arg;
+                });
+                originalLog(...redactedArgs);
+            };
+            try {
+                console.log(`\n💥 Tearing down Stack: ${this.constructor.name}`);
+                // Stack-level beforeDestroy hook
+                if (typeof this.beforeDestroy === "function") {
+                    console.log(`   ⚡ Running Stack-level beforeDestroy hook...`);
+                    await this.beforeDestroy();
+                }
+                const props = Object.getOwnPropertyNames(this).reverse();
+                const outputs = {};
+                const isParallel = Config.isParallelActive();
+                // 1. Gather all resources
+                const resources = [];
+                for (const prop of props) {
+                    const val = this[prop];
+                    if (val instanceof BaseBuilder) {
+                        if (Reflect.getMetadata("protected", this, prop)) {
+                            console.log(`   🔒 Skipping protected resource "${prop}"`);
+                            continue;
+                        }
+                        resources.push({ prop, resource: val });
+                    }
+                    else if (Array.isArray(val)) {
+                        if (Reflect.getMetadata("protected", this, prop)) {
+                            console.log(`   🔒 Skipping protected resource "${prop}"`);
+                            continue;
+                        }
+                        for (const item of val) {
+                            if (item instanceof BaseBuilder) {
+                                resources.push({ prop, resource: item });
+                            }
+                        }
+                    }
+                }
+                // 2. Schedule execution
+                if (isParallel) {
+                    const startPromise = Promise.resolve();
+                    // In parallel destroy, await all dependents (reverse dependencies) first
+                    const promises = resources.map(({ prop, resource }) => {
+                        resource._destroyPromise = (async () => {
+                            try {
+                                await startPromise;
+                                if (controller.signal.aborted) {
+                                    throw new Error("Teardown aborted due to previous failure");
+                                }
+                                // Wait for all resources that explicitly declare this one as a dependency
+                                const dependents = resources.filter(r => r.resource._dependencies.includes(resource));
+                                for (const dep of dependents) {
+                                    if (dep.resource._destroyPromise) {
+                                        await dep.resource._destroyPromise;
+                                    }
+                                }
+                                if (controller.signal.aborted) {
+                                    throw new Error("Teardown aborted due to previous failure");
+                                }
+                                // Execute teardown
+                                await resource._runBeforeDestroy();
+                                const res = await resource.destroy();
+                                await resource._runAfterDestroy(res);
+                                const propVal = this[prop];
+                                if (Array.isArray(propVal)) {
+                                    const idx = propVal.indexOf(resource);
+                                    if (idx !== -1) {
+                                        if (!outputs[prop]) {
+                                            outputs[prop] = [];
+                                        }
+                                        outputs[prop][idx] = res;
+                                    }
+                                }
+                                else {
+                                    outputs[prop] = res;
+                                }
+                                return res;
+                            }
+                            catch (err) {
+                                controller.abort();
+                                throw err;
+                            }
+                        })();
+                        return resource._destroyPromise;
+                    });
+                    await Promise.all(promises);
+                }
+                else {
+                    // Sequential mode
+                    for (const { prop, resource } of resources) {
+                        if (controller.signal.aborted) {
+                            throw new Error("Teardown aborted due to previous failure");
+                        }
+                        try {
+                            await resource._runBeforeDestroy();
+                            const res = await resource.destroy();
+                            await resource._runAfterDestroy(res);
+                            const propVal = this[prop];
+                            if (Array.isArray(propVal)) {
+                                const idx = propVal.indexOf(resource);
+                                if (idx !== -1) {
+                                    if (!outputs[prop]) {
+                                        outputs[prop] = [];
+                                    }
+                                    outputs[prop][idx] = res;
+                                }
+                            }
+                            else {
+                                outputs[prop] = res;
+                            }
+                        }
+                        catch (err) {
+                            controller.abort();
+                            throw err;
+                        }
+                    }
                 }
-                await resource._runBeforeDestroy();
-                const res = await resource.destroy();
-                await resource._runAfterDestroy(res);
-                outputs[prop] = res;
+                printOutputs(this.constructor.name, outputs);
+                // Stack-level afterDestroy hook
+                if (typeof this.afterDestroy === "function") {
+                    console.log(`   ⚡ Running Stack-level afterDestroy hook...`);
+                    await this.afterDestroy(outputs);
+                }
+                return outputs;
             }
-        }
-        printOutputs(this.constructor.name, outputs);
-        // Stack-level afterDestroy hook
-        if (typeof this.afterDestroy === "function") {
-            console.log(`   ⚡ Running Stack-level afterDestroy hook...`);
-            await this.afterDestroy(outputs);
-        }
-        return outputs;
+            finally {
+                console.log = originalLog;
+            }
+        });
     }
 }

package/dist/index.d.ts

@@ -3,5 +3,6 @@ export * from "./core/decorators.js";
 export * from "./core/checker.js";
 export * from "./core/resource.js";
 export { Secret } from "./core/secret.js";
+export { Output } from "./core/output.js";
 export * as INVENTORY_TYPES from "./types/inventory.js";
 export { SLACK, DISCORD } from "./core/hooks.js";

package/dist/index.js

@@ -3,5 +3,6 @@ export * from "./core/decorators.js";
 export * from "./core/checker.js";
 export * from "./core/resource.js";
 export { Secret } from "./core/secret.js";
+export { Output } from "./core/output.js";
 export * as INVENTORY_TYPES from "./types/inventory.js";
 export { SLACK, DISCORD } from "./core/hooks.js";

package/dist/providers/aws/api.js

@@ -15,26 +15,106 @@ import { SecretsManagerClient } from "@aws-sdk/client-secrets-manager";
 import { CloudWatchClient } from "@aws-sdk/client-cloudwatch";
 import { SNSClient } from "@aws-sdk/client-sns";
 import { Config } from "../../core/config.js";
+import { withRetry } from "../../core/retry.js";
+import { resourceContextStorage } from "../../core/context.js";
 function getRegion() {
     const region = Config.get().providers.aws?.region;
-    if (!region)
+    if (!region) {
+        if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+            return "us-east-1";
+        }
         throw new Error('AWS region not configured. Call AWS.init({ region: "..." })');
+    }
     return region;
 }
-export const getS3Client = (region) => new S3Client({ region: region ?? getRegion() });
+function createAwsOfflineMock(command) {
+    const name = command.constructor.name;
+    if (name.includes("RunInstances")) {
+        return {
+            Instances: [
+                {
+                    InstanceId: "i-mock1234567890abcdef0",
+                    State: { Name: "running" },
+                    PublicIpAddress: "54.210.12.34",
+                    PrivateIpAddress: "10.0.1.10",
+                }
+            ]
+        };
+    }
+    if (name.includes("CreateVpc")) {
+        return { Vpc: { VpcId: "vpc-mock123456" } };
+    }
+    if (name.includes("CreateSubnet")) {
+        return { Subnet: { SubnetId: "subnet-mock123456" } };
+    }
+    if (name.includes("CreateSecurityGroup")) {
+        return { GroupId: "sg-mock123456" };
+    }
+    if (name.includes("CreateBucket")) {
+        return { Location: "/mock-bucket" };
+    }
+    if (name.includes("CreateKeyPair")) {
+        return { KeyMaterial: "mock-private-key", KeyName: "mock-key" };
+    }
+    const mockProxy = new Proxy({}, {
+        get(target, prop) {
+            if (prop === "then")
+                return undefined;
+            if (prop === "CertificateArn")
+                return "arn:aws:acm:us-east-1:123456789012:certificate/mock-cert-uuid";
+            if (prop === "HostedZoneId")
+                return "Z2FDTNDATAQYW2";
+            if (prop === "Id" || prop === "id")
+                return "mock-id-12345";
+            if (prop === "Arn" || prop === "arn")
+                return `arn:aws:mock:::resource/mock-id`;
+            if (prop === "Status" || prop === "status")
+                return "Active";
+            if (prop === "DNSName")
+                return "mock.cloudfront.net";
+            if (prop.endsWith("s"))
+                return [];
+            return `mock-${prop.toLowerCase()}`;
+        }
+    });
+    return mockProxy;
+}
+function wrapClient(client) {
+    const originalSend = client.send;
+    client.send = function (command, options) {
+        const context = resourceContextStorage.getStore();
+        const abortSignal = context?.abortSignal;
+        if (Config.isOfflineMode() || Config.isGlobalDryRun()) {
+            return Promise.resolve(createAwsOfflineMock(command));
+        }
+        const opts = abortSignal ? { abortSignal, ...options } : options;
+        return withRetry(() => originalSend.call(client, command, opts), {
+            retryable: (err) => {
+                const code = err.name || err.code;
+                const status = err.$metadata?.httpStatusCode;
+                return (code === "ThrottlingException" ||
+                    code === "ProvisionedThroughputExceededException" ||
+                    code === "RequestLimitExceeded" ||
+                    (status && status >= 500));
+            }
+        });
+    };
+    return client;
+}
+export const getS3Client = (region) => wrapClient(new S3Client({ region: region ?? getRegion() }));
 // CloudFront, Route53, ACM, Route53 Domains, and IAM are all global - must use us-east-1
-export const getCFClient = () => new CloudFrontClient({ region: "us-east-1" });
-export const getR53Client = () => new Route53Client({ region: "us-east-1" });
-export const getR53DomainsClient = () => new Route53DomainsClient({ region: "us-east-1" });
-export const getACMClient = () => new ACMClient({ region: "us-east-1" });
-export const getIAMClient = () => new IAMClient({ region: "us-east-1" });
-export const getLambdaClient = (region) => new LambdaClient({ region: region ?? getRegion() });
-export const getAPIGWClient = (region) => new ApiGatewayV2Client({ region: region ?? getRegion() });
-export const getECSClient = (region) => new ECSClient({ region: region ?? getRegion() });
-export const getEC2Client = (region) => new EC2Client({ region: region ?? getRegion() });
-export const getCWLogsClient = (region) => new CloudWatchLogsClient({ region: region ?? getRegion() });
-export const getRDSClient = (region) => new RDSClient({ region: region ?? getRegion() });
-export const getSQSClient = (region) => new SQSClient({ region: region ?? getRegion() });
-export const getSecretsClient = (region) => new SecretsManagerClient({ region: region ?? getRegion() });
-export const getCWClient = (region) => new CloudWatchClient({ region: region ?? getRegion() });
-export const getSNSClient = (region) => new SNSClient({ region: region ?? getRegion() });
+export const getCFClient = () => wrapClient(new CloudFrontClient({ region: "us-east-1" }));
+export const getR53Client = () => wrapClient(new Route53Client({ region: "us-east-1" }));
+export const getR53DomainsClient = () => wrapClient(new Route53DomainsClient({ region: "us-east-1" }));
+export const getACMClient = () => wrapClient(new ACMClient({ region: "us-east-1" }));
+export const getIAMClient = () => wrapClient(new IAMClient({ region: "us-east-1" }));
+export const getLambdaClient = (region) => wrapClient(new LambdaClient({ region: region ?? getRegion() }));
+export const getAPIGWClient = (region) => wrapClient(new ApiGatewayV2Client({ region: region ?? getRegion() }));
+export const getECSClient = (region) => wrapClient(new ECSClient({ region: region ?? getRegion() }));
+export const getEC2Client = (region) => wrapClient(new EC2Client({ region: region ?? getRegion() }));
+export const getCWLogsClient = (region) => wrapClient(new CloudWatchLogsClient({ region: region ?? getRegion() }));
+export const getRDSClient = (region) => wrapClient(new RDSClient({ region: region ?? getRegion() }));
+export const getSQSClient = (region) => wrapClient(new SQSClient({ region: region ?? getRegion() }));
+export const getSecretsClient = (region) => wrapClient(new SecretsManagerClient({ region: region ?? getRegion() }));
+export const getCWClient = (region) => wrapClient(new CloudWatchClient({ region: region ?? getRegion() }));
+export const getSNSClient = (region) => wrapClient(new SNSClient({ region: region ?? getRegion() }));

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

@@ -1,5 +1,6 @@
 import { BaseBuilder } from "../../core/resource.js";
 import { Output } from "../../core/output.js";
+import { EC2TemplateBuilder } from "./template.js";
 export declare class EC2VMBuilder extends BaseBuilder {
     readonly out: {
         ip: Output<string>;
@@ -7,6 +8,7 @@ export declare class EC2VMBuilder extends BaseBuilder {
     };
     private _instanceType;
     private _ami;
+    private _templateSource?;
     private _keyName?;
     private _subnetId?;
     private _securityGroupIds?;
@@ -19,6 +21,7 @@ export declare class EC2VMBuilder extends BaseBuilder {
     constructor(name: string);
     instanceType(type: string): this;
     ami(amiId: string): this;
+    fromTemplate(template: EC2TemplateBuilder): this;
     keyName(name: string): this;
     subnetId(id: string): this;
     securityGroupIds(ids: string[]): this;