slskit-cli 1.0.0

package/dist/commands/configure/prompts.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnvironmentName = exports.ENVIRONMENT_PROFILE = void 0;
+exports.parseRegion = parseRegion;
+exports.parseStackName = parseStackName;
+exports.defaultStackName = defaultStackName;
+exports.collectConfigureAnswers = collectConfigureAnswers;
+const errors_js_1 = require("../../core/errors.js");
+const aws_cli_js_1 = require("./aws-cli.js");
+const environments_js_1 = require("../../core/environments.js");
+Object.defineProperty(exports, "parseEnvironmentName", { enumerable: true, get: function () { return environments_js_1.parseEnvironmentName; } });
+// CloudFormation stack names: letters, digits and hyphens, starting with a letter.
+const STACK_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9-]*$/;
+const STACK_NAME_MAX = 128;
+// us-east-1, eu-west-2, ap-southeast-3, us-gov-west-1, cn-north-1 ...
+const REGION_PATTERN = /^[a-z]{2}(-[a-z]+)?-[a-z]+-\d+$/;
+// Sentinel for "don't pin a profile, read credentials from the environment".
+exports.ENVIRONMENT_PROFILE = "";
+function parseRegion(value) {
+    if (value === undefined || value.trim() === "") {
+        return undefined;
+    }
+    const region = value.trim().toLowerCase();
+    if (!REGION_PATTERN.test(region)) {
+        throw new errors_js_1.CliError(`Invalid AWS region "${value}". Expected something like us-east-1 or eu-west-2.`);
+    }
+    return region;
+}
+function parseStackName(value) {
+    if (value === undefined || value.trim() === "") {
+        return undefined;
+    }
+    const name = value.trim();
+    if (!STACK_NAME_PATTERN.test(name) || name.length > STACK_NAME_MAX) {
+        throw new errors_js_1.CliError(`Invalid stack name "${value}". Use letters, digits and hyphens, starting with a letter (max ${STACK_NAME_MAX} characters).`);
+    }
+    return name;
+}
+function defaultStackName(projectName, environment) {
+    return (0, environments_js_1.stackNameFor)(projectName, environment).slice(0, STACK_NAME_MAX).replace(/-+$/, "");
+}
+async function collectConfigureAnswers(manifest, options) {
+    const environment = (0, environments_js_1.resolveEnvironmentName)(manifest, options.env);
+    const existing = manifest.environments?.list?.[environment];
+    let profile = options.profile?.trim() || undefined;
+    let region = parseRegion(options.region);
+    let stackName = parseStackName(options.stackName);
+    const envCredentials = (0, aws_cli_js_1.hasEnvCredentials)();
+    const profiles = (0, aws_cli_js_1.listAwsProfiles)();
+    const awsCli = (0, aws_cli_js_1.isAwsCliAvailable)();
+    // Resolution order for each field: explicit flag, then what this project already
+    // recorded for the environment, then the shell, then the AWS config file.
+    const profileDefault = profile ?? existing?.profile ?? (0, aws_cli_js_1.envProfile)() ?? (profiles.includes("default") ? "default" : undefined);
+    const regionDefault = region ??
+        existing?.region ??
+        (0, aws_cli_js_1.envRegion)() ??
+        (awsCli ? (0, aws_cli_js_1.configuredRegion)(profileDefault) : undefined);
+    const stackNameDefault = stackName ?? existing?.stackName ?? defaultStackName(manifest.name, environment);
+    if (!process.stdin.isTTY) {
+        if (!profileDefault && !envCredentials) {
+            throw new errors_js_1.CliError('Non-interactive configure needs "--profile <name>", or AWS credentials in the environment.');
+        }
+        if (!regionDefault) {
+            throw new errors_js_1.CliError('Non-interactive configure needs "--region <region>", AWS_REGION, or a region in your AWS config.');
+        }
+        return {
+            environment,
+            region: regionDefault,
+            profile: profileDefault,
+            stackName: stackNameDefault,
+        };
+    }
+    const { input, select } = await import("@inquirer/prompts");
+    if (profile === undefined) {
+        const choices = [
+            ...profiles.map((name) => ({
+                name: name === profileDefault ? `${name} (current)` : name,
+                value: name,
+            })),
+            {
+                name: envCredentials
+                    ? "Environment variables (detected)"
+                    : "Environment variables / instance role",
+                value: exports.ENVIRONMENT_PROFILE,
+            },
+        ];
+        if (profiles.length === 0) {
+            profile = exports.ENVIRONMENT_PROFILE;
+        }
+        else {
+            profile = await select({
+                message: "AWS credentials:",
+                choices,
+                default: profileDefault ?? exports.ENVIRONMENT_PROFILE,
+            });
+        }
+    }
+    const selectedProfile = profile === exports.ENVIRONMENT_PROFILE ? undefined : profile;
+    region ?? (region = parseRegion(await input({
+        message: "AWS region:",
+        default: regionDefault ??
+            (awsCli ? (0, aws_cli_js_1.configuredRegion)(selectedProfile) : undefined) ??
+            "us-east-1",
+        required: true,
+    })));
+    stackName ?? (stackName = parseStackName(await input({
+        message: "CloudFormation stack name:",
+        default: stackNameDefault,
+        required: true,
+    })));
+    return {
+        environment,
+        region: region,
+        profile: selectedProfile,
+        stackName: stackName,
+    };
+}

package/dist/commands/configure/types.d.ts

@@ -0,0 +1,24 @@
+export type { EnvVarDef, EnvVarSource, EnvironmentConfig, ProjectManifest as ConfigurableManifest, } from "../../core/environments.js";
+export { DEFAULT_ENVIRONMENT, MANIFEST_FILE, } from "../../core/environments.js";
+export interface ConfigureOptions {
+    env?: string;
+    profile?: string;
+    region?: string;
+    stackName?: string;
+    skipVerify?: boolean;
+    setCredentials?: boolean;
+}
+export interface ConfigureAnswers {
+    environment: string;
+    region: string;
+    profile?: string;
+    stackName: string;
+}
+export interface AwsIdentity {
+    account: string;
+    arn: string;
+}
+export interface IdentityResult {
+    identity?: AwsIdentity;
+    error?: string;
+}

package/dist/commands/configure/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MANIFEST_FILE = exports.DEFAULT_ENVIRONMENT = void 0;
+var environments_js_1 = require("../../core/environments.js");
+Object.defineProperty(exports, "DEFAULT_ENVIRONMENT", { enumerable: true, get: function () { return environments_js_1.DEFAULT_ENVIRONMENT; } });
+Object.defineProperty(exports, "MANIFEST_FILE", { enumerable: true, get: function () { return environments_js_1.MANIFEST_FILE; } });

package/dist/commands/deploy/action.d.ts

@@ -0,0 +1,2 @@
+import type { DeployOptions } from "./types.js";
+export declare function deployAction(options: DeployOptions): Promise<void>;

package/dist/commands/deploy/action.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployAction = deployAction;
+const credentials_js_1 = require("../../core/credentials.js");
+const errors_js_1 = require("../../core/errors.js");
+const is_ci_js_1 = require("../../core/is-ci.js");
+const logger_js_1 = require("../../core/logger.js");
+const environments_js_1 = require("../../core/environments.js");
+const aws_cli_js_1 = require("../configure/aws-cli.js");
+const parameters_js_1 = require("../env/parameters.js");
+const templates_js_1 = require("../env/templates.js");
+const sam_cli_js_1 = require("../run/sam-cli.js");
+const sam_deploy_js_1 = require("./sam-deploy.js");
+const scope_js_1 = require("./scope.js");
+// The physical Lambda names the deploy will touch, so the plan names real AWS
+// resources rather than template logical ids.
+function plannedFunctionNames(manifest, environment, scope) {
+    return (0, scope_js_1.applicationsOf)(manifest)
+        .filter((app) => scope.kind === "all" || app.name === scope.service)
+        .flatMap((app) => app.functions ?? [])
+        .filter((fn) => scope.kind !== "function" || fn.name === scope.functionName)
+        .map((fn) => (0, environments_js_1.functionNameFor)(manifest.name, environment, fn.name));
+}
+async function confirmDeploy(manifest, environment, stackName, region, functionNames, scope) {
+    logger_js_1.logger.info(`\nAbout to deploy ${scope.label} of "${manifest.name}" to AWS.`);
+    logger_js_1.logger.info(`  ${environments_js_1.APP_ENVIRONMENT_KEY}: ${environment}`);
+    logger_js_1.logger.info(`  stack:       ${stackName}`);
+    logger_js_1.logger.info(`  region:      ${region}`);
+    logger_js_1.logger.info(`  functions:   ${functionNames.length}`);
+    for (const name of functionNames) {
+        logger_js_1.logger.info(`    ${name}`);
+    }
+    logger_js_1.logger.info(scope.kind === "all"
+        ? "\nThis creates real AWS resources in your account and they cost money."
+        : "\nThis updates the code of those functions in the stack that is already deployed.");
+    const { confirm } = await import("@inquirer/prompts");
+    return confirm({ message: `Deploy to "${environment}"?`, default: false });
+}
+async function deployAction(options) {
+    const cwd = process.cwd();
+    const manifest = (0, environments_js_1.readManifest)(cwd, "slskit deploy");
+    const environment = (0, environments_js_1.resolveEnvironmentName)(manifest, options.env);
+    const config = (0, environments_js_1.requireEnvironment)(manifest, environment);
+    if (!config.region) {
+        throw new errors_js_1.CliError(`Environment "${environment}" has no AWS region yet.\nRun: slskit configure --env ${environment}`);
+    }
+    const { profile } = (0, credentials_js_1.resolveAwsProfile)({
+        flag: options.profile,
+        stored: config.profile,
+    });
+    const target = {
+        stackName: config.stackName,
+        region: config.region,
+        profile,
+    };
+    // A variable can appear just by being typed into a .env file, so the templates are
+    // brought back in step before anything is uploaded.
+    const rewritten = (0, templates_js_1.syncTemplates)(cwd, manifest);
+    if (rewritten.length > 0) {
+        logger_js_1.logger.info(`Updated ${rewritten.length} template(s) for the current variables.`);
+    }
+    // Resolved before anything runs so a missing secret fails here, not mid-deploy.
+    const overrides = (0, parameters_js_1.toCliArguments)((0, parameters_js_1.parameterOverrides)(cwd, manifest, environment));
+    // Checked before anything slower: without --yes a non-interactive deploy can
+    // never proceed, so that is the most useful thing to say first.
+    if (!options.yes && !(0, is_ci_js_1.isInteractive)()) {
+        throw new errors_js_1.CliError(`Deploying creates real AWS resources. Re-run with --yes to deploy "${environment}" non-interactively.`);
+    }
+    const scope = await (0, scope_js_1.resolveDeployScope)(manifest, options);
+    const functionNames = plannedFunctionNames(manifest, environment, scope);
+    if (!options.skipVerify) {
+        if (!(0, aws_cli_js_1.isAwsCliAvailable)()) {
+            throw new errors_js_1.CliError('The AWS CLI is required to verify credentials before deploying.\nInstall it, or pass --skip-verify to deploy without checking.');
+        }
+        const { identity, error } = (0, aws_cli_js_1.getCallerIdentity)(target.profile, target.region);
+        if (!identity) {
+            throw new errors_js_1.CliError(`Could not verify AWS credentials for ${target.profile ? `profile "${target.profile}"` : "the environment"} in ${target.region}.\n  ${error ?? "sts get-caller-identity failed."}\n\nFix them with: slskit configure --env ${environment} --set-credentials`);
+        }
+        logger_js_1.logger.info(`\nDeploying as ${identity.arn}`);
+        logger_js_1.logger.info(`  account: ${identity.account}`);
+    }
+    // A code sync updates functions inside an existing stack; it cannot create one,
+    // and the error sam gives for a missing stack does not say so.
+    if (scope.kind !== "all" && !options.skipVerify && !(0, sam_deploy_js_1.stackExists)(target)) {
+        throw new errors_js_1.CliError(`Stack "${target.stackName}" does not exist yet, so there is nothing to update.\nDeploy the whole project first: slskit deploy ${environment} --all`);
+    }
+    if (!options.yes) {
+        const proceed = await confirmDeploy(manifest, environment, target.stackName, target.region, functionNames, scope);
+        if (!proceed) {
+            logger_js_1.logger.info("\nNothing was deployed.");
+            return;
+        }
+    }
+    await (0, sam_cli_js_1.ensureSamCliInstalled)();
+    // sam sync builds what it needs itself, so a separate build would only be repeated work.
+    if (scope.kind === "all") {
+        if (options.build !== false) {
+            (0, sam_cli_js_1.samBuild)(cwd);
+        }
+        (0, sam_deploy_js_1.samDeploy)(cwd, target, overrides, Boolean(options.guided));
+    }
+    else {
+        (0, sam_deploy_js_1.samSyncCode)(cwd, target, (0, scope_js_1.resourceIdsFor)(manifest, scope), overrides);
+    }
+    logger_js_1.logger.info(`\nDeployed ${scope.label} of "${manifest.name}" to "${environment}".`);
+    logger_js_1.logger.info(`  stack:   ${target.stackName}`);
+    logger_js_1.logger.info(`  region:  ${target.region}`);
+    const outputs = (0, sam_deploy_js_1.stackOutputs)(target);
+    if (outputs.length > 0) {
+        logger_js_1.logger.info("\nEndpoints:");
+        for (const output of outputs) {
+            logger_js_1.logger.info(`  ${output.key}: ${output.value}`);
+        }
+    }
+}

package/dist/commands/deploy/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerDeployCommand(program: Command): void;

package/dist/commands/deploy/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDeployCommand = registerDeployCommand;
+const run_js_1 = require("../../core/run.js");
+function registerDeployCommand(program) {
+    program
+        .command("deploy")
+        .description("Deploy to AWS — the whole project, one service, or a single function")
+        .argument("[environment]", "Environment to deploy (example: dev, production) — defaults to the default environment")
+        .option("-e, --env <name>", "Environment to deploy")
+        .option("-s, --service <name>", "Deploy every function in one service")
+        .option("--function <name>", "Deploy one function on its own")
+        .option("--all", "Deploy the whole project without asking what to deploy", false)
+        .option("--profile <name>", "AWS named profile (overrides slskit.json for this run)")
+        .option("--no-build", 'Skip "sam build" before deploying')
+        .option("-y, --yes", "Skip the confirmation prompt", false)
+        .option("--skip-verify", "Deploy without checking the credentials first", false)
+        .option("--guided", 'Run "sam deploy --guided" instead of the managed defaults', false)
+        .action((environment, options) => (0, run_js_1.runCommand)(async () => {
+        const { deployAction } = await import("./action.js");
+        await deployAction({ ...options, env: environment ?? options.env });
+    }));
+}

package/dist/commands/deploy/sam-deploy.d.ts

@@ -0,0 +1,10 @@
+import type { StackOutput } from "./types.js";
+export interface DeployTarget {
+    stackName: string;
+    region: string;
+    profile?: string;
+}
+export declare function samDeploy(cwd: string, target: DeployTarget, parameterOverrides: string[], guided: boolean): void;
+export declare function samSyncCode(cwd: string, target: DeployTarget, resourceIds: string[], parameterOverrides: string[]): void;
+export declare function stackExists(target: DeployTarget): boolean;
+export declare function stackOutputs(target: DeployTarget): StackOutput[];

package/dist/commands/deploy/sam-deploy.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.samDeploy = samDeploy;
+exports.samSyncCode = samSyncCode;
+exports.stackExists = stackExists;
+exports.stackOutputs = stackOutputs;
+const node_child_process_1 = require("node:child_process");
+const errors_js_1 = require("../../core/errors.js");
+const logger_js_1 = require("../../core/logger.js");
+const USE_SHELL = process.platform === "win32";
+// Nested stacks are AWS::Serverless::Application, which CloudFormation will only
+// expand when this capability is granted; without it the deploy fails outright.
+const CAPABILITIES = ["CAPABILITY_IAM", "CAPABILITY_AUTO_EXPAND"];
+function targetArgs(target) {
+    const args = ["--stack-name", target.stackName, "--region", target.region];
+    if (target.profile) {
+        args.push("--profile", target.profile);
+    }
+    return args;
+}
+function samDeploy(cwd, target, parameterOverrides, guided) {
+    const args = ["deploy", ...targetArgs(target), "--capabilities", ...CAPABILITIES];
+    if (guided) {
+        args.push("--guided");
+    }
+    else {
+        // Creates and reuses a managed bucket so a first deploy needs no manual setup,
+        // and an unchanged stack is a success rather than an error.
+        args.push("--resolve-s3", "--no-confirm-changeset", "--no-fail-on-empty-changeset");
+    }
+    if (parameterOverrides.length > 0) {
+        args.push("--parameter-overrides", ...parameterOverrides);
+    }
+    // Values are deliberately not logged: overrides carry secrets.
+    const overrideNote = parameterOverrides.length > 0
+        ? ` --parameter-overrides (${parameterOverrides.length} value${parameterOverrides.length === 1 ? "" : "s"})`
+        : "";
+    logger_js_1.logger.info(`\n> sam deploy --stack-name ${target.stackName} --region ${target.region}${target.profile ? ` --profile ${target.profile}` : ""}${overrideNote}\n`);
+    const result = (0, node_child_process_1.spawnSync)("sam", args, { cwd, stdio: "inherit", shell: USE_SHELL });
+    if (result.error) {
+        throw new errors_js_1.CliError(`Failed to run sam deploy: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new errors_js_1.CliError(`sam deploy exited with code ${result.status ?? 1}`);
+    }
+}
+// A code-only update of the functions already in a deployed stack. Much faster than
+// a full deploy, but it can only change code: routes, memory and variables live in
+// the template, so those still need a whole-project deploy.
+function samSyncCode(cwd, target, resourceIds, parameterOverrides) {
+    const args = ["sync", "--code", ...targetArgs(target)];
+    for (const resourceId of resourceIds) {
+        args.push("--resource-id", resourceId);
+    }
+    if (parameterOverrides.length > 0) {
+        args.push("--parameter-overrides", ...parameterOverrides);
+    }
+    logger_js_1.logger.info(`\n> sam sync --code --stack-name ${target.stackName} ${resourceIds
+        .map((id) => `--resource-id ${id}`)
+        .join(" ")}\n`);
+    const result = (0, node_child_process_1.spawnSync)("sam", args, { cwd, stdio: "inherit", shell: USE_SHELL });
+    if (result.error) {
+        throw new errors_js_1.CliError(`Failed to run sam sync: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new errors_js_1.CliError(`sam sync exited with code ${result.status ?? 1}`);
+    }
+}
+// A code sync updates functions in place, so there has to be a stack holding them.
+function stackExists(target) {
+    const args = [
+        "cloudformation",
+        "describe-stacks",
+        "--stack-name",
+        target.stackName,
+        "--region",
+        target.region,
+        "--query",
+        "Stacks[0].StackStatus",
+        "--output",
+        "text",
+    ];
+    if (target.profile) {
+        args.push("--profile", target.profile);
+    }
+    const result = (0, node_child_process_1.spawnSync)("aws", args, { encoding: "utf8", shell: USE_SHELL });
+    return !result.error && result.status === 0;
+}
+// Read back through the AWS CLI rather than parsing sam's output, which changes
+// shape between versions.
+function stackOutputs(target) {
+    const args = [
+        "cloudformation",
+        "describe-stacks",
+        "--stack-name",
+        target.stackName,
+        "--region",
+        target.region,
+        "--query",
+        "Stacks[0].Outputs",
+        "--output",
+        "json",
+    ];
+    if (target.profile) {
+        args.push("--profile", target.profile);
+    }
+    const result = (0, node_child_process_1.spawnSync)("aws", args, { encoding: "utf8", shell: USE_SHELL });
+    if (result.error || result.status !== 0) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(result.stdout);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed
+            .filter((entry) => entry.OutputKey && entry.OutputValue)
+            .map((entry) => ({
+            key: entry.OutputKey,
+            value: entry.OutputValue,
+            description: entry.Description,
+        }));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/commands/deploy/scope.d.ts

@@ -0,0 +1,9 @@
+import { allScope, applicationsOf, functionScope, serviceScope } from "../../core/scope.js";
+import type { Scope, ScopeOptions } from "../../core/scope.js";
+import type { ProjectManifest } from "../../core/environments.js";
+export { allScope, applicationsOf, functionScope, serviceScope };
+export type { Scope as DeployScope };
+export declare function resourceIdsFor(manifest: ProjectManifest, scope: Scope): string[];
+export declare function resolveDeployScope(manifest: ProjectManifest, options: ScopeOptions & {
+    yes?: boolean;
+}): Promise<Scope>;

package/dist/commands/deploy/scope.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceScope = exports.functionScope = exports.applicationsOf = exports.allScope = void 0;
+exports.resourceIdsFor = resourceIdsFor;
+exports.resolveDeployScope = resolveDeployScope;
+const resources_js_1 = require("../run/resources.js");
+const scope_js_1 = require("../../core/scope.js");
+Object.defineProperty(exports, "allScope", { enumerable: true, get: function () { return scope_js_1.allScope; } });
+Object.defineProperty(exports, "applicationsOf", { enumerable: true, get: function () { return scope_js_1.applicationsOf; } });
+Object.defineProperty(exports, "functionScope", { enumerable: true, get: function () { return scope_js_1.functionScope; } });
+Object.defineProperty(exports, "serviceScope", { enumerable: true, get: function () { return scope_js_1.serviceScope; } });
+// Which template resources a scoped deploy syncs. Deploys always go through the
+// nested service stacks, so every id is qualified by its stack.
+function resourceIdsFor(manifest, scope) {
+    if (scope.kind === "all") {
+        return [];
+    }
+    return (0, scope_js_1.applicationsOf)(manifest)
+        .filter((app) => app.name === scope.service)
+        .flatMap((app) => app.functions ?? [])
+        .filter((fn) => scope.kind !== "function" || fn.name === scope.functionName)
+        .map((fn) => (0, resources_js_1.resourceIdFor)(scope.service, fn.name));
+}
+async function resolveDeployScope(manifest, options) {
+    const fromFlags = (0, scope_js_1.scopeFromFlags)(manifest, options);
+    if (fromFlags) {
+        return fromFlags;
+    }
+    // Without a TTY there is nobody to ask, and --yes already means "no questions".
+    if (options.yes || !process.stdin.isTTY) {
+        return scope_js_1.allScope;
+    }
+    return (0, scope_js_1.promptForScope)(manifest, "deploy", "Everything — the whole project");
+}

package/dist/commands/deploy/types.d.ts

@@ -0,0 +1,20 @@
+export interface DeployOptions {
+    /** Deploy every function in one service. */
+    service?: string;
+    /** Deploy one function on its own. */
+    function?: string;
+    /** Skip the scope prompt and deploy the whole project. */
+    all?: boolean;
+    env?: string;
+    /** Overrides the profile stored in slskit.json for this run only. */
+    profile?: string;
+    build?: boolean;
+    yes?: boolean;
+    skipVerify?: boolean;
+    guided?: boolean;
+}
+export interface StackOutput {
+    key: string;
+    value: string;
+    description?: string;
+}

package/dist/commands/deploy/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commands/env/action.d.ts

@@ -0,0 +1,11 @@
+import { stackNameFor } from "../../core/environments.js";
+import type { EnvAddOptions, EnvRemoveOptions, EnvSetOptions, EnvUnsetOptions, EnvVarsOptions } from "./types.js";
+export declare function envListAction(): Promise<void>;
+export declare function envAddAction(name: string, options: EnvAddOptions): Promise<void>;
+export declare function envUseAction(name: string): Promise<void>;
+export declare function envRemoveAction(name: string, options: EnvRemoveOptions): Promise<void>;
+export declare function envSetAction(assignment: string, options: EnvSetOptions): Promise<void>;
+export declare function envUnsetAction(key: string, options: EnvUnsetOptions): Promise<void>;
+export declare function envVarsAction(options: EnvVarsOptions): Promise<void>;
+export declare function seedDotenv(cwd: string, environment: string): string;
+export { stackNameFor };