slskit-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Savinda Jayasekara
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE.md

@@ -0,0 +1,22 @@
+# NOTICE
+
+slskit is licensed under the MIT License. See [LICENSE](LICENSE).
+
+Copyright (c) 2026 Savinda Jayasekara.
+
+## Third-party runtime software
+
+Production dependencies and their licenses (also checked by `npm run licenses`):
+
+| Package | License |
+| --- | --- |
+| commander | MIT |
+| @inquirer/prompts | MIT |
+
+Each of those packages includes its own copyright and license notice. Those
+notices remain in force.
+
+## Reference material
+
+Architecture and CI practices were informed by publicly documented patterns from
+the Netlify CLI (MIT). No Netlify source code is included in this repository.

package/README.md

@@ -0,0 +1,168 @@
+# slskit
+
+[![CI](https://github.com/savindaJ/SLSKIT-CLI/actions/workflows/ci.yml/badge.svg)](https://github.com/savindaJ/SLSKIT-CLI/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/slskit-cli.svg)](https://www.npmjs.com/package/slskit-cli)
+[![node](https://img.shields.io/node/v/slskit-cli.svg)](https://www.npmjs.com/package/slskit-cli)
+[![license](https://img.shields.io/npm/l/slskit-cli.svg)](LICENSE)
+
+A CLI for scaffolding and growing multi-service AWS Lambda projects on AWS SAM.
+
+Starting a serverless project usually means a day of wiring: a template, a build
+setup, handlers, an API Gateway, environment variables that behave the same locally
+and in AWS, and a deploy that doesn't fight you. `slskit` gives you all of it in one
+command, then stays useful — adding functions, managing environments, running the
+project locally, and deploying a single function when that's all that changed.
+
+Two runtime dependencies. Everything that touches AWS goes through the official
+`sam` and `aws` CLIs.
+
+```bash
+npm install -g slskit-cli
+slskit init my-lambda-app
+cd my-lambda-app
+slskit run
+```
+
+In CI, install it locally and pin the version with a lockfile. A global install
+always pulls the latest release, including breaking changes.
+
+```bash
+npm install --save-dev slskit-cli
+npx slskit deploy --yes
+```
+
+That's a running API on `http://127.0.0.1:3000` with two services, four functions, a
+shared Lambda layer, and hot reload on save.
+
+## What you get
+
+```text
+my-lambda-app/
+├── src/
+│   ├── functions/        # handlers, one folder per service
+│   ├── services/         # business logic the handlers import
+│   └── shared/           # shared utilities, published as a Lambda layer
+├── templates/            # one CloudFormation stack per service
+├── template.yaml         # root stack, nests them
+├── .env.dev              # the dev environment's variables (gitignored)
+└── slskit.json           # the project graph every command reads
+```
+
+A root stack nesting one template per service, so the root file stays short as the
+project grows and services can be deployed one at a time. TypeScript, JavaScript or
+Python — and individual functions can differ from the rest of the project.
+
+## Highlights
+
+**Environments that don't leak into each other.** Every environment is its own deploy
+target: region, profile, CloudFormation stack, variables. `APP_ENVIRONMENT` is
+generated for each one, and every resource name is built from it — `shop-dev-login`
+and `shop-production-login` are different functions in different stacks.
+
+```bash
+slskit env add production --profile prod-admin --region eu-west-2
+slskit env set API_KEY=sk-live-xxx --secret --env production
+slskit deploy production
+```
+
+**Variables that reach your code the same way locally and in AWS.** Add one with
+`slskit env set`, or just type it into `.env.<environment>` — either way it becomes a
+CloudFormation parameter wired into every function, and `process.env.YOUR_KEY` works
+in both places. Secrets stay out of `slskit.json`, and `--ssm` keeps them out of the
+CLI entirely.
+
+**Run or deploy just the part you're working on.**
+
+```bash
+slskit run --service auth          # only auth's routes, so only those build
+slskit deploy dev --function login # code-only update of one function
+```
+
+Both commands ask if you don't tell them. A scoped run builds only the functions it
+serves; a scoped deploy uses `sam sync --code`, which is far faster than a full one.
+
+**Hot reload.** `slskit run` watches `src/` and rebuilds only the function you
+touched — the next request uses the new code, no restart. A broken file leaves the
+previous build serving and waits for the next save.
+
+**A deploy that tells you what it will do.** It stops before calling AWS if the
+region is missing, the credentials don't verify, or a declared secret has no value —
+so a failed deploy costs nothing. Then it prints the plan, asks, and reports the API
+Gateway URLs when it's done.
+
+**Credentials never enter your project.** `slskit configure` stores only the AWS
+profile *name* in `slskit.json`; access keys go to `~/.aws/credentials` via the AWS
+CLI. Secrets are never echoed, and override values are never logged.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `slskit init [name]` | Scaffold a new project |
+| `slskit run [environment]` | Run it locally on one API Gateway port |
+| `slskit function [name]` | Add a function to a new or existing service |
+| `slskit rm [name]` | Remove a function or a service, and everything that referenced it |
+| `slskit configure` | Set AWS credentials and the deploy target |
+| `slskit env` | Manage environments and their variables |
+| `slskit deploy [environment]` | Deploy to AWS |
+
+**[COMMAND.md](COMMAND.md) is the full reference** — every flag, every behaviour,
+and the reasoning behind the parts that aren't obvious.
+
+## Requirements
+
+| | |
+| --- | --- |
+| Node.js | 18 or newer |
+| [AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html) | to run and deploy — `slskit run` offers to install it |
+| [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) | to verify credentials and read stack outputs |
+| Docker | for `sam local`, which runs functions in Lambda-like containers |
+
+## First deploy
+
+```bash
+slskit configure --set-credentials   # asks for a key, writes ~/.aws/credentials
+slskit deploy dev
+```
+
+API Gateway, the functions, the layer and any tables are created in one pass —
+`--resolve-s3` provisions the artifact bucket, so there's no manual setup. It prints
+the URLs at the end:
+
+```text
+Deployed the whole project of "shop" to "dev".
+  stack:   shop-dev
+  region:  us-east-1
+
+Endpoints:
+  ApiUrl: https://6hjgplpky0.execute-api.us-east-1.amazonaws.com
+```
+
+## Development
+
+```bash
+git clone https://github.com/savindaJ/SLSKIT-CLI.git
+cd SLSKIT-CLI
+npm install
+npm test
+```
+
+```bash
+npm run build && npm link   # use your working copy as the real slskit command
+npm run dev                 # run from source via tsx
+npm run typecheck           # tsc --noEmit
+npm run docs                # regenerate docs/flags.md from Commander
+npm run licenses            # check the project and production dependency licenses
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) before opening a pull request. Bug reports and
+documentation fixes are just as welcome as code.
+
+## Security
+
+Report vulnerabilities privately — see [SECURITY.md](SECURITY.md), which also
+documents exactly how slskit handles your credentials.
+
+## License
+
+[MIT](LICENSE) © Savinda Jayasekara. Third-party notices are in [NOTICE.md](NOTICE.md).

package/bin/slskit.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../dist/cli.js");

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_js_1 = require("./core/errors.js");
+const logger_js_1 = require("./core/logger.js");
+const program_js_1 = require("./program.js");
+async function main() {
+    const program = (0, program_js_1.createProgram)();
+    const argv = process.argv.slice(2);
+    if (argv.length === 0) {
+        program.outputHelp();
+        return;
+    }
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (error) {
+        if (error instanceof errors_js_1.CliError) {
+            logger_js_1.logger.error(error.message);
+            process.exitCode = error.exitCode;
+            return;
+        }
+        throw error;
+    }
+}
+void main();

package/dist/commands/base-command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+export declare function addGlobalOptions(command: Command): Command;
+export declare class BaseCommand extends Command {
+    createCommand(name?: string): BaseCommand;
+}

package/dist/commands/base-command.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCommand = void 0;
+exports.addGlobalOptions = addGlobalOptions;
+const commander_1 = require("commander");
+const context_js_1 = require("../core/context.js");
+function addGlobalOptions(command) {
+    return command
+        .addOption(new commander_1.Option("--cwd <path>", "Run as if started from this directory"))
+        .addOption(new commander_1.Option("--debug", "Print stack traces when a command fails"))
+        .addOption(new commander_1.Option("--silent", "Silence informational output"))
+        .addOption(new commander_1.Option("--json", "JSON output where a command supports it"));
+}
+function attachGlobalHook(command) {
+    command.hook("preAction", (_parent, actionCommand) => {
+        (0, context_js_1.applyGlobalOptions)(actionCommand.optsWithGlobals());
+    });
+}
+// Every command created through program.command() inherits the global flags,
+// so `slskit deploy --debug` and `slskit --debug deploy` both work.
+class BaseCommand extends commander_1.Command {
+    createCommand(name) {
+        const command = new BaseCommand(name);
+        addGlobalOptions(command);
+        attachGlobalHook(command);
+        return command;
+    }
+}
+exports.BaseCommand = BaseCommand;

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

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

package/dist/commands/configure/action.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureAction = configureAction;
+const errors_js_1 = require("../../core/errors.js");
+const logger_js_1 = require("../../core/logger.js");
+const environments_js_1 = require("../../core/environments.js");
+const action_js_1 = require("../env/action.js");
+const aws_cli_js_1 = require("./aws-cli.js");
+const prompts_js_1 = require("./prompts.js");
+const ACCESS_KEY_PATTERN = /^[A-Z0-9]{16,128}$/;
+function credentialSource(profile) {
+    return profile ? `profile "${profile}"` : "the environment";
+}
+function fixHint(profile) {
+    return profile
+        ? `aws configure --profile ${profile}  (or "aws sso login --profile ${profile}" for an SSO profile)`
+        : "Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY, or pick a named profile instead.";
+}
+// Prompts for an access key and hands it to the AWS CLI, which stores it in
+// ~/.aws/credentials. The secret is never echoed, never logged, and never written
+// anywhere inside the project.
+async function promptForCredentials(answers) {
+    const { input, password, confirm } = await import("@inquirer/prompts");
+    const proceed = await confirm({
+        message: "Enter an AWS access key now and store it in ~/.aws/credentials?",
+        default: true,
+    });
+    if (!proceed) {
+        return undefined;
+    }
+    const profile = answers.profile ??
+        (await input({
+            message: "Profile name to store it under:",
+            default: "default",
+            required: true,
+        }));
+    const accessKeyId = (await input({
+        message: "AWS Access Key ID:",
+        required: true,
+    })).trim();
+    if (!ACCESS_KEY_PATTERN.test(accessKeyId)) {
+        throw new errors_js_1.CliError(`"${accessKeyId}" does not look like an AWS Access Key ID (expected something like AKIA... ).`);
+    }
+    const secretAccessKey = (await password({ message: "AWS Secret Access Key:", mask: true })).trim();
+    if (!secretAccessKey) {
+        throw new errors_js_1.CliError("A secret access key is required.");
+    }
+    const { ok, error } = (0, aws_cli_js_1.setProfileCredentials)(profile, accessKeyId, secretAccessKey, answers.region);
+    if (!ok) {
+        throw new errors_js_1.CliError(`Could not store the credentials: ${error ?? "aws configure set failed."}\nStore them yourself with: aws configure --profile ${profile}`);
+    }
+    logger_js_1.logger.info(`\nStored the key for profile "${profile}" in ${(0, aws_cli_js_1.credentialsFilePath)()}.`);
+    logger_js_1.logger.info("  the secret was not echoed and is not stored in this project");
+    return profile;
+}
+// Returns the profile actually used, which may change if credentials were entered
+// against a new profile name.
+async function verifyCredentials(answers, options) {
+    if (options.skipVerify) {
+        logger_js_1.logger.info("\nSkipped the credential check (--skip-verify).");
+        return { profile: answers.profile };
+    }
+    if (!(0, aws_cli_js_1.isAwsCliAvailable)()) {
+        logger_js_1.logger.info(`\nAWS CLI was not found on your PATH, so the credentials were not verified.\n  Install it: ${aws_cli_js_1.AWS_INSTALL_URL}\n  Then re-run "slskit configure" to check them.`);
+        return { profile: answers.profile };
+    }
+    let profile = answers.profile;
+    let { identity, error } = (0, aws_cli_js_1.getCallerIdentity)(profile, answers.region);
+    const wantsNewKey = options.setCredentials && process.stdin.isTTY;
+    if (!identity || wantsNewKey) {
+        if (!process.stdin.isTTY) {
+            throw new errors_js_1.CliError(`Could not verify AWS credentials for ${credentialSource(profile)} in ${answers.region}.\n  ${error ?? "sts get-caller-identity failed."}\n\nFix them with:\n  ${fixHint(profile)}\n\nThen re-run "slskit configure", or pass --skip-verify to save without checking.`);
+        }
+        if (!identity) {
+            logger_js_1.logger.info(`\nCould not verify AWS credentials for ${credentialSource(profile)} in ${answers.region}.`);
+            logger_js_1.logger.info(`  ${error ?? "sts get-caller-identity failed."}`);
+        }
+        const stored = await promptForCredentials(answers);
+        if (!stored) {
+            throw new errors_js_1.CliError(`AWS credentials are required to deploy.\n\nFix them with:\n  ${fixHint(profile)}\n\nThen re-run "slskit configure", or pass --skip-verify to save without checking.`);
+        }
+        profile = stored;
+        ({ identity, error } = (0, aws_cli_js_1.getCallerIdentity)(profile, answers.region));
+        if (!identity) {
+            throw new errors_js_1.CliError(`The key was stored for profile "${profile}", but AWS still rejected it in ${answers.region}.\n  ${error ?? "sts get-caller-identity failed."}\n\nCheck that the key is active and has permission to call sts:GetCallerIdentity.`);
+        }
+    }
+    logger_js_1.logger.info("\nVerified AWS credentials.");
+    logger_js_1.logger.info(`  account:   ${identity.account}`);
+    logger_js_1.logger.info(`  identity:  ${identity.arn}`);
+    return { profile, identity };
+}
+async function configureAction(options) {
+    const cwd = process.cwd();
+    const manifest = (0, environments_js_1.readManifest)(cwd, "slskit configure");
+    const answers = await (0, prompts_js_1.collectConfigureAnswers)(manifest, options);
+    const { profile } = await verifyCredentials(answers, options);
+    const existing = manifest.environments?.list?.[answers.environment];
+    const config = {
+        region: answers.region,
+        stackName: answers.stackName,
+    };
+    if (profile) {
+        config.profile = profile;
+    }
+    // Variables already recorded for this environment survive a re-configure.
+    if (existing?.variables) {
+        config.variables = existing.variables;
+    }
+    (0, environments_js_1.writeEnvironment)(cwd, manifest, answers.environment, config);
+    const dotenv = (0, action_js_1.seedDotenv)(cwd, answers.environment);
+    logger_js_1.logger.info(`\nConfigured environment "${answers.environment}" for "${manifest.name}".`);
+    logger_js_1.logger.info(`  ${environments_js_1.APP_ENVIRONMENT_KEY}: ${answers.environment}`);
+    logger_js_1.logger.info(`  credentials: ${credentialSource(profile)}`);
+    logger_js_1.logger.info(`  region:      ${answers.region}`);
+    logger_js_1.logger.info(`  stack:       ${answers.stackName}`);
+    logger_js_1.logger.info(`  written to:  ${environments_js_1.MANIFEST_FILE}, ${dotenv}`);
+    logger_js_1.logger.info("\nNo credential material is stored in this project — only the profile name, resolved at deploy time.");
+    logger_js_1.logger.info(`\nDeploy it with: slskit deploy ${answers.environment}`);
+}

package/dist/commands/configure/aws-cli.d.ts

@@ -0,0 +1,16 @@
+import type { IdentityResult } from "./types.js";
+export declare const AWS_INSTALL_URL = "https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html";
+export declare function isAwsCliAvailable(): boolean;
+export declare function awsConfigDir(): string;
+export declare function listAwsProfiles(): string[];
+export declare function hasEnvCredentials(): boolean;
+export declare function envProfile(): string | undefined;
+export declare function envRegion(): string | undefined;
+export declare function configuredRegion(profile?: string): string | undefined;
+export declare function getCallerIdentity(profile: string | undefined, region: string): IdentityResult;
+export interface CredentialWriteResult {
+    ok: boolean;
+    error?: string;
+}
+export declare function setProfileCredentials(profile: string, accessKeyId: string, secretAccessKey: string, region?: string): CredentialWriteResult;
+export declare function credentialsFilePath(): string;

package/dist/commands/configure/aws-cli.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AWS_INSTALL_URL = void 0;
+exports.isAwsCliAvailable = isAwsCliAvailable;
+exports.awsConfigDir = awsConfigDir;
+exports.listAwsProfiles = listAwsProfiles;
+exports.hasEnvCredentials = hasEnvCredentials;
+exports.envProfile = envProfile;
+exports.envRegion = envRegion;
+exports.configuredRegion = configuredRegion;
+exports.getCallerIdentity = getCallerIdentity;
+exports.setProfileCredentials = setProfileCredentials;
+exports.credentialsFilePath = credentialsFilePath;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const USE_SHELL = process.platform === "win32";
+exports.AWS_INSTALL_URL = "https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html";
+function isAwsCliAvailable() {
+    const result = (0, node_child_process_1.spawnSync)("aws", ["--version"], {
+        stdio: "ignore",
+        shell: USE_SHELL,
+    });
+    return !result.error && result.status === 0;
+}
+function readIfExists(file) {
+    try {
+        return node_fs_1.default.readFileSync(file, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function awsConfigDir() {
+    const configFile = process.env.AWS_CONFIG_FILE;
+    return configFile ? node_path_1.default.dirname(configFile) : node_path_1.default.join(node_os_1.default.homedir(), ".aws");
+}
+// Section headers are "[default]" and "[profile foo]" in ~/.aws/config, but plain
+// "[foo]" in ~/.aws/credentials, so the "profile " prefix is optional here.
+function parseProfileNames(contents) {
+    const names = [];
+    for (const line of contents.split("\n")) {
+        const match = /^\s*\[\s*(?:profile\s+)?([^\]\s]+)\s*\]/.exec(line);
+        if (match) {
+            names.push(match[1]);
+        }
+    }
+    return names;
+}
+function listAwsProfiles() {
+    const dir = awsConfigDir();
+    const names = [
+        ...parseProfileNames(readIfExists(node_path_1.default.join(dir, "config"))),
+        ...parseProfileNames(readIfExists(node_path_1.default.join(dir, "credentials"))),
+    ];
+    return [...new Set(names)].sort();
+}
+function hasEnvCredentials() {
+    return Boolean(process.env.AWS_ACCESS_KEY_ID || process.env.AWS_SESSION_TOKEN);
+}
+function envProfile() {
+    return process.env.AWS_PROFILE?.trim() || undefined;
+}
+function envRegion() {
+    const region = process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION;
+    return region?.trim() || undefined;
+}
+// Asking the AWS CLI lets it apply its own resolution rules (config file, SSO
+// session, env) instead of this command re-deriving them and getting them wrong.
+function configuredRegion(profile) {
+    const args = ["configure", "get", "region"];
+    if (profile) {
+        args.push("--profile", profile);
+    }
+    const result = (0, node_child_process_1.spawnSync)("aws", args, { encoding: "utf8", shell: USE_SHELL });
+    if (result.error || result.status !== 0) {
+        return undefined;
+    }
+    return result.stdout?.trim() || undefined;
+}
+function getCallerIdentity(profile, region) {
+    const args = ["sts", "get-caller-identity", "--output", "json", "--region", region];
+    if (profile) {
+        args.push("--profile", profile);
+    }
+    const result = (0, node_child_process_1.spawnSync)("aws", args, { encoding: "utf8", shell: USE_SHELL });
+    if (result.error) {
+        return { error: result.error.message };
+    }
+    if (result.status !== 0) {
+        return { error: result.stderr?.trim() || `aws exited with code ${result.status ?? 1}` };
+    }
+    try {
+        const parsed = JSON.parse(result.stdout);
+        if (!parsed.Account || !parsed.Arn) {
+            return { error: "sts get-caller-identity returned no account or ARN." };
+        }
+        return { identity: { account: parsed.Account, arn: parsed.Arn } };
+    }
+    catch {
+        return { error: "Could not parse the response from sts get-caller-identity." };
+    }
+}
+// Credentials are handed to the AWS CLI so they land in ~/.aws/credentials in the
+// format AWS expects — never in the project directory, and never in slskit.json.
+// Deliberately runs without a shell so the secret is not exposed to shell parsing.
+function setProfileCredentials(profile, accessKeyId, secretAccessKey, region) {
+    const entries = [
+        ["aws_access_key_id", accessKeyId],
+        ["aws_secret_access_key", secretAccessKey],
+    ];
+    if (region) {
+        entries.push(["region", region]);
+    }
+    for (const [key, value] of entries) {
+        const result = (0, node_child_process_1.spawnSync)("aws", ["configure", "set", key, value, "--profile", profile], { encoding: "utf8" });
+        if (result.error) {
+            return { ok: false, error: result.error.message };
+        }
+        if (result.status !== 0) {
+            return {
+                ok: false,
+                error: result.stderr?.trim() || `aws configure set ${key} exited with ${result.status}`,
+            };
+        }
+    }
+    return { ok: true };
+}
+function credentialsFilePath() {
+    return process.env.AWS_SHARED_CREDENTIALS_FILE ?? node_path_1.default.join(awsConfigDir(), "credentials");
+}

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

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

package/dist/commands/configure/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerConfigureCommand = registerConfigureCommand;
+const run_js_1 = require("../../core/run.js");
+const types_js_1 = require("./types.js");
+function registerConfigureCommand(program) {
+    program
+        .command("configure")
+        .description("Set up AWS credentials and the deploy target for an environment")
+        .option("-e, --env <name>", `Environment to configure (default: "${types_js_1.DEFAULT_ENVIRONMENT}")`)
+        .option("--profile <name>", "AWS named profile to resolve credentials from")
+        .option("--region <region>", "AWS region to deploy into (example: us-east-1)")
+        .option("--stack-name <name>", "CloudFormation stack name for this environment")
+        .option("--skip-verify", "Save without checking that the credentials work", false)
+        .option("--set-credentials", "Enter an AWS access key and store it in ~/.aws/credentials", false)
+        .action((options) => (0, run_js_1.runCommand)(async () => {
+        const { configureAction } = await import("./action.js");
+        await configureAction(options);
+    }));
+}

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

@@ -0,0 +1,8 @@
+import { parseEnvironmentName } from "../../core/environments.js";
+import type { ConfigurableManifest, ConfigureAnswers, ConfigureOptions } from "./types.js";
+export declare const ENVIRONMENT_PROFILE = "";
+export declare function parseRegion(value: string | undefined): string | undefined;
+export declare function parseStackName(value: string | undefined): string | undefined;
+export declare function defaultStackName(projectName: string, environment: string): string;
+export declare function collectConfigureAnswers(manifest: ConfigurableManifest, options: ConfigureOptions): Promise<ConfigureAnswers>;
+export { parseEnvironmentName };