docs(aws): migrate infrastructure-as-code guides from wrapper scripts to lstk

Replace awslocal/tflocal/samlocal/cdklocal instructions in the Terraform, AWS SAM,
and AWS CDK guides (plus stray awslocal mentions in Crossplane, Cloud Custodian,
Former2, Pulumi, Serverless Framework, and Chalice) with the equivalent lstk
subcommands. Add a new Deprecated Wrapper Scripts reference page documenting the
old scripts for anyone still relying on them, linked from each migrated page.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: peter-smith-phd

src/content/docs/aws/connecting/aws-cli.md

@@ -17,6 +17,10 @@ You can use the AWS CLI with LocalStack using one or more of the following appro
 - [LocalStack AWS CLI](#localstack-aws-cli-lstk-aws) - Use the `lstk aws` command to set the configuration options for you.
 - [Using AWS CLI from a pre-built container](#using-aws-cli-from-a-pre-built-container) - Use Amazon's pre-built AWS CLI container image instead of installing `aws` locally.
 
+:::note
+`lstk aws` supersedes the older [`awslocal` wrapper script](/aws/connecting/infrastructure-as-code/deprecated-wrapper-scripts#awslocal), which is deprecated but still available if you need it.
+:::
+
 ## AWS CLI
 
 If you don't already have `aws` (version 2) installed, follow the [official AWS CLI installation instructions](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

src/content/docs/aws/connecting/infrastructure-as-code/aws-cdk.md

@@ -14,40 +14,43 @@ The AWS Cloud Development Kit (CDK) is an Infrastructure-as-Code (IaC) tool usin
 
 ## AWS CDK CLI for LocalStack
 
-`cdklocal` is a thin wrapper script for using the [AWS CDK](https://github.com/aws/aws-cdk) library against local APIs provided by LocalStack.
+[`lstk cdk`](/aws/developer-tools/running-localstack/lstk/#cdk) proxies the [AWS CDK](https://github.com/aws/aws-cdk) library against local APIs provided by LocalStack. It requires the AWS CDK CLI version `2.177.0` or newer on your `PATH`.
+
+:::note
+`lstk cdk` supersedes the older [`cdklocal` wrapper script](/aws/connecting/infrastructure-as-code/deprecated-wrapper-scripts#cdklocal), which is deprecated but still available if you need it.
+:::
 
 ### Installation
 
-The `cdklocal` command line is published as an [npm library](https://www.npmjs.com/package/aws-cdk-local):
+Install `lstk` by following the [`lstk` installation instructions](/aws/developer-tools/running-localstack/lstk/#installation).
+You'll also need the AWS CDK CLI installed separately:
 
 ```bash
 # Install globally
-npm install -g aws-cdk-local aws-cdk
+npm install -g aws-cdk
 
 # Verify it installed correctly
-cdklocal --version
-# e.g. 1.65.5
+cdk --version
 ```
 
-:::note
-
-Using `cdklocal` locally (e.g. within the `node_modules` of your repo instead of globally installed) does not work at the moment for some setups, so make sure you install both `aws-cdk` and `aws-cdk-local` with the `-G` flag.
-:::
-
 ### Usage
 
-`cdklocal` can be used as a drop-in replacement of where you would otherwise use `cdk` when targeting the AWS Cloud.
+`lstk cdk` can be used as a drop-in replacement of where you would otherwise use `cdk` when targeting the AWS Cloud.
 
 ```bash
-cdklocal --help
+lstk cdk --help
 ```
 
 ### Configuration
 
+`lstk cdk`'s only lstk-specific flag (before the CDK action) is `--region <region>` (default `us-east-1`); CDK always targets the default LocalStack account `000000000000`, so there is no `--account` flag.
+
 The following environment variables can be configured:
 
 - `AWS_ENDPOINT_URL`: The endpoint URL (i.e., protocol, host, and port) to connect to LocalStack (default: `http://localhost.localstack.cloud:4566`)
-- `LAMBDA_MOUNT_CODE`: Whether to use local Lambda code mounting (via setting `hot-reload` S3 bucket name)
+- `AWS_ENDPOINT_URL_S3`: The S3-specific endpoint URL, required alongside `AWS_ENDPOINT_URL` and must include `.s3.` to correctly identify S3 API calls
+- `LSTK_CDK_CMD`: Binary to invoke (default `cdk`)
+- `AWS_REGION`: Fallback for `--region`
 
 ### Example
 
@@ -62,20 +65,20 @@ The CDK command line ships with a sample app generator to run a quick test for g
 ```bash
 # create sample app
 mkdir /tmp/test; cd /tmp/test
-cdklocal init sample-app --language=javascript
+lstk cdk init sample-app --language=javascript
 
 # bootstrap localstack environment
-cdklocal bootstrap
+lstk cdk bootstrap
 
 # deploy the sample app
-cdklocal deploy
+lstk cdk deploy
 > Do you wish to deploy these changes (y/n)? y
 ```
 
-Once the deployment is done, you can inspect the created resources via the [`awslocal`](https://github.com/localstack/awscli-local) command line
+Once the deployment is done, you can inspect the created resources via the [`lstk aws`](/aws/developer-tools/running-localstack/lstk/#aws) command line
 
 ```bash
-awslocal sns list-topics
+lstk aws sns list-topics
  {
      "Topics": [
          {
@@ -107,21 +110,5 @@ When this lambda is executed locally from the `/tmp` folder, the package can not
 
 ## CDK Version Compatibility
 
-`cdklocal` works with all installed versions of the Node.js `aws-cdk` package.
-However, issues exist for `aws-cdk >= 2.177.0`.
-
-For these versions:
-
-- We unset AWS-related environment variables like `AWS_PROFILE` before calling `cdk`.
-- We explicitly set `AWS_ENDPOINT_URL` and `AWS_ENDPOINT_URL_S3` to point to LocalStack.
-
-Some environment variables may cause conflicting config, such as wrong region or accidental deploys to real AWS.
-To allow specific variables (e.g., `AWS_REGION`), use `AWS_ENVAR_ALLOWLIST`:
-
-```bash
-AWS_ENVAR_ALLOWLIST=AWS_REGION,AWS_DEFAULT_REGION AWS_DEFAULT_REGION=eu-central-1 AWS_REGION=eu-central-1 cdklocal ...
-```
-
-If you manually set `AWS_ENDPOINT_URL`, it will be used.
-You must also set `AWS_ENDPOINT_URL_S3`, and it must include `.s3.` to correctly identify S3 API calls.
-See full configuration details [on our configuration docs](https://github.com/localstack/aws-cdk-local?tab=readme-ov-file#configurations).
+`lstk cdk` requires AWS CDK CLI `2.177.0` or newer, as noted in [Installation](#installation).
+If you're using an older `aws-cdk` version, or the legacy `cdklocal` wrapper script, see [CDK Version Compatibility](/aws/connecting/infrastructure-as-code/deprecated-wrapper-scripts#cdklocal) on the deprecated wrapper scripts page for the relevant environment-variable workarounds.

src/content/docs/aws/connecting/infrastructure-as-code/aws-chalice.mdx

@@ -20,7 +20,7 @@ Using LocalStack, you can kick-start your development process, create a new Chal
 Start LocalStack inside a Docker container by running:
 
 ```bash
-localstack start -d
+lstk start
 ```
 
 Install the `chalice-local` package by running:

src/content/docs/aws/connecting/infrastructure-as-code/aws-sam.md

@@ -12,29 +12,29 @@ The AWS Serverless Application Model (SAM) is an open-source framework for devel
 It uses a simplified syntax to define functions, APIs, databases, and event source mappings.
 When you deploy, SAM converts its syntax into AWS CloudFormation syntax, helping you create serverless applications more quickly.
 
-LocalStack can work with SAM using the AWS SAM CLI for LocalStack.
-This CLI comes in the form of a `samlocal` wrapper script, which lets you deploy SAM applications on LocalStack.
-This guide explains how to set up local AWS resources using the `samlocal` wrapper script.
+LocalStack can work with SAM using [`lstk sam`](/aws/developer-tools/running-localstack/lstk/#sam), which lets you deploy SAM applications on LocalStack.
+This guide explains how to set up local AWS resources using `lstk sam`.
 
-## `samlocal` wrapper script
+## `lstk sam`
 
-`samlocal` is a wrapper for the `sam` command line interface, facilitating the use of SAM framework with LocalStack.
-When executing deployment commands like `samlocal ["build", "deploy", "validate", "package"]`, the script configures the SAM settings for LocalStack and runs the specified SAM command.
+`lstk sam` proxies the `sam` command line interface, facilitating the use of the SAM framework with LocalStack.
+When executing deployment commands like `lstk sam [ build | deploy | validate | package ]`, it configures the SAM settings for LocalStack and runs the specified SAM command.
 
-### Install the `samlocal` wrapper script
+:::note
+`lstk sam` supersedes the older [`samlocal` wrapper script](/aws/connecting/infrastructure-as-code/deprecated-wrapper-scripts#samlocal), which is deprecated but still available if you need it.
+:::
 
-You can install the `samlocal` wrapper script by running the following command:
+### Install lstk
 
-```bash
-pip install aws-sam-cli-local
-```
+To use `lstk sam`, install `lstk` by following the [`lstk` installation instructions](/aws/developer-tools/running-localstack/lstk/#installation).
+You'll also need the [AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html) (version `1.95.0` or newer) installed and on your `PATH`.
 
 ### Create a new SAM project
 
 You can initialize a new SAM project using the following command:
 
 ```bash
-samlocal init
+lstk sam init
 ```
 
 Select `1` to create a new SAM application using an AWS Quick Start template.
@@ -50,19 +50,29 @@ Then, enter the project name and press `Enter`.
 After initializing the SAM project, enter the project directory and deploy the application using the following command:
 
 ```bash
-samlocal deploy --guided
+lstk sam deploy --guided
 ```
 
 Enter the default values for the deployment, such as the stack name, region, and confirm the changes.
-The `samlocal` wrapper will package and deploy the application to LocalStack.
+`lstk sam` will package and deploy the application to LocalStack.
 
 ### Configuration
 
-| Environment Variable   | Default value                                    | Description                                                             |
-|------------------------|--------------------------------------------------|-------------------------------------------------------------------------|
-| AWS_ENDPOINT_URL       | `http://localhost.localstack.cloud:4566`        | URL at which the `boto3` client can reach LocalStack                   |
-| EDGE_PORT (Deprecated)              | `4566`                              | Port number under which the LocalStack edge service is available        |
-| LOCALSTACK_HOSTNAME (Deprecated)     | `localhost`                         | Host under which the LocalStack edge service is available
+The `lstk sam` command supports several options and environment variables beyond what is available with the standard `sam` command. 
+| Option              | Default         | Description |
+|----------------------|-----------------|--------------|
+| `--region <region>`  | `us-east-1`     | Deployment region |
+| `--account <id>`     | `000000000000`  | Target AWS account id (12 digits) |
+
+`lstk sam`-specific flags must appear **before** the SAM action (for example, `lstk sam --region us-west-2 build`)
+
+| Environment Variable   | Default value | Description |
+|-------------------------|----------------|--------------|
+| `AWS_ENDPOINT_URL`      | -              | Override the auto-resolved LocalStack endpoint |
+| `AWS_ENDPOINT_URL_S3`   | -              | Override the auto-resolved LocalStack S3 endpoint |
+| `LSTK_SAM_CMD`          | `sam`          | Binary to invoke |
+| `AWS_REGION`            | -              | Fallback for `--region` |
+| `AWS_ACCESS_KEY_ID`     | -              | Fallback for `--account` |
 
 ## Debugging on VS Code
 

src/content/docs/aws/connecting/infrastructure-as-code/cloud-custodian.md

@@ -16,7 +16,7 @@ You can use Cloud Custodian with LocalStack by just specifying the Cloud Custodi
 
 ## Getting started
 
-This guide is designed for users who are new to Cloud Custodian and assumes basic knowledge of the AWS CLI and our [`awslocal`](https://github.com/localstack/awscli-local) wrapper script.
+This guide is designed for users who are new to Cloud Custodian and assumes basic knowledge of the AWS CLI and our [`lstk aws`](/aws/developer-tools/running-localstack/lstk/#aws) command.
 
 Start your LocalStack container using your preferred method.
 We will demonstrate how you can spin up an EC2 instance and tag it with the key `Custodian`, and then use Cloud Custodian to stop the instance.
@@ -33,12 +33,12 @@ After installing Cloud Custodian, you can configure a [custom LocalStack profile
 
 ### Create an EC2 instance
 
-You can create an EC2 instance using the `awslocal` wrapper script.
+You can create an EC2 instance using `lstk aws`.
 You can use the [`RunInstances`](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html) API to create an EC2 instance.
 The following example creates an EC2 instance with the tag `Custodian` (any value):
 
 ```bash
-awslocal ec2 run-instances \
+lstk aws ec2 run-instances \
     --image-id ami-ff0fea8310f3 \
     --count 1 \
     --instance-type t3.nano \

src/content/docs/aws/connecting/infrastructure-as-code/crossplane.md

@@ -194,10 +194,10 @@ crossplane-test-bucket   True    True     crossplane-test-bucket   30s
 ```
 
 ...
-and the bucket it should also be visible when querying the local S3 buckets in LocalStack via [`awslocal`](https://github.com/localstack/awscli-local):
+and the bucket it should also be visible when querying the local S3 buckets in LocalStack via [`lstk aws`](/aws/developer-tools/running-localstack/lstk/#aws):
 
 ```bash
-awslocal s3 ls
+lstk aws s3 ls
 ```
 
 ```bash title="Output"
@@ -233,7 +233,7 @@ crossplane-test-queue   True    True     http://host.docker.internal:4566/000000
 ...and the queue should be visible when listing the SQS queues in LocalStack:
 
 ```bash
-awslocal sqs list-queues
+lstk aws sqs list-queues
 ```
 
 ```bash title="Output"