@projectdochelp/s3te 3.1.1 → 3.1.3

package/README.md

@@ -6,14 +6,19 @@ This README is the user guide for the rewrite generation. The deeper implementat
 
 ## Table of Contents
 
-1. [Motivation](#motivation)
-2. [Support](#support)
-3. [Concept](#concept)
-4. [Installation (AWS)](#installation-aws)
-5. [Installation (VSCode)](#installation-vscode)
-6. [Installation (S3TE)](#installation-s3te)
-7. [Usage](#usage)
-8. [Optional: Webiny CMS](#optional-webiny-cms)
+- [S3TemplateEngine](#s3templateengine)
+  - [Table of Contents](#table-of-contents)
+  - [Motivation](#motivation)
+  - [Support](#support)
+  - [Concept](#concept)
+  - [Installation (AWS)](#installation-aws)
+  - [Installation (VSCode)](#installation-vscode)
+  - [Installation (S3TE)](#installation-s3te)
+  - [Usage](#usage)
+    - [Daily Workflow](#daily-workflow)
+    - [CLI Commands](#cli-commands)
+    - [Template Commands](#template-commands)
+  - [Optional: Webiny CMS](#optional-webiny-cms)
 
 ## Motivation
 
@@ -54,7 +59,9 @@ The website bucket contains the finished result that visitors actually receive t
 <details>
   <summary>What happens when I deploy?</summary>
 
-`s3te deploy` validates the project, packages the AWS runtime, creates or updates one persistent CloudFormation environment stack, creates one temporary CloudFormation deploy stack for packaging artifacts, synchronizes your current source files into the code bucket, and removes the temporary stack again after the real deploy run.
+`s3te deploy` loads the validated project configuration, packages the AWS runtime, creates or updates one persistent CloudFormation environment stack, creates one temporary CloudFormation deploy stack for packaging artifacts, synchronizes your current source files into the code bucket, and removes the temporary stack again after the real deploy run.
+
+That source sync is not limited to Lambda code. It includes your `.html`, `.part`, CSS, JavaScript, images and other project files so the running AWS stack can react to source changes inside the code bucket.
 
 The persistent environment stack contains the long-lived AWS resources such as buckets, Lambda functions, DynamoDB tables, CloudFront distributions and the runtime manifest parameter. The temporary deploy stack exists only so CloudFormation can consume the packaged Lambda artifacts cleanly.
 
@@ -152,7 +159,7 @@ With the local package installed, initialize the project like this:
 npx s3te init --project-name mywebsite --base-url example.com
 ```
 
-If `npm install` already created a minimal `package.json`, `s3te init` extends it with the missing S3TE defaults and scripts instead of failing.
+You can safely run `s3te init` more than once. If `npm install` already created a minimal `package.json`, `s3te init` extends it with the missing S3TE defaults and scripts instead of failing. An existing `s3te.config.json` is completed with missing scaffold defaults, explicit `--project-name` and `--base-url` values are refreshed on re-run, and the generated schema file is updated to the current package version. Existing content files and templates stay untouched unless you use `--force`.
 
 If you want a one-shot scaffold without installing first, and `@projectdochelp/s3te` is already published on npm, this also works:
 
@@ -160,25 +167,15 @@ If you want a one-shot scaffold without installing first, and `@projectdochelp/s
 npx --package @projectdochelp/s3te s3te init --project-name mywebsite --base-url example.com
 ```
 
-That command only works after a real npm publish. A GitHub repository on its own is not enough.
-
-If you are still working from this repository before the first npm publish, run the CLI directly from the repo root instead:
-
-```bash
-node packages/cli/bin/s3te.mjs init --dir ./mywebsite --project-name mywebsite --base-url example.com
-```
-
-</details>
-
-<details>
-  <summary>4. What the scaffold creates</summary>
-
 The default scaffold creates:
 
 ```text
 mywebsite/
   package.json
   s3te.config.json
+  .github/
+    workflows/
+      s3te-sync.yml
   app/
     part/
       head.part
@@ -195,10 +192,12 @@ mywebsite/
     extensions.json
 ```
 
+The generated `.github/workflows/s3te-sync.yml` is the default CI path for GitHub-based source publishing into the S3TE code bucket. It is scaffolded once and then left alone on later `s3te init` runs unless you use `--force`.
+
 </details>
 
 <details>
-  <summary>5. Fill in the real AWS values in <code>s3te.config.json</code></summary>
+  <summary>4. Fill in the real AWS values in <code>s3te.config.json</code></summary>
 
 The most important fields for a first deployment are:
 
@@ -227,10 +226,12 @@ The most important fields for a first deployment are:
 
 `route53HostedZoneId` is optional. Leave it out if you want to manage DNS yourself.
 
+Use plain hostnames in `baseUrl` and `cloudFrontAliases`, not full URLs. If your config contains a `prod` environment plus additional environments such as `test` or `stage`, S3TE keeps the `prod` hostname unchanged and derives non-production hostnames automatically by prepending `<env>.`.
+
 </details>
 
 <details>
-  <summary>6. Run the first local check and deploy</summary>
+  <summary>5. Run the first local check and deploy</summary>
 
 ```bash
 npx s3te validate
@@ -244,13 +245,15 @@ npx s3te deploy --env dev
 
 `deploy` creates or updates the persistent environment stack, uses a temporary deploy stack for packaged Lambda artifacts, synchronizes the source project into the code bucket, and removes the temporary stack again when the deploy finishes.
 
+After the first successful deploy, use `s3te sync --env dev` for regular template, partial, asset and source updates when the infrastructure itself did not change.
+
 If you left `route53HostedZoneId` out of the config, the last DNS step stays manual: point your domain at the created CloudFront distribution after deploy.
 
 </details>
 
 ## Usage
 
-Once the project is installed, your everyday loop is deliberately small: edit templates, validate, render locally, then deploy.
+Once the project is installed, your everyday loop splits into two paths: deploy when infrastructure changes, sync when only project sources changed.
 
 ### Daily Workflow
 
@@ -261,15 +264,24 @@ Once the project is installed, your everyday loop is deliberately small: edit te
 2. If you use content-driven tags without Webiny, edit `offline/content/en.json` or `offline/content/items.json`.
 3. Validate and render locally.
 4. Run your tests.
-5. Deploy when the result looks right.
+5. Use `deploy` for the first installation or after infrastructure/config/runtime changes.
+6. Use `sync` for day-to-day source publishing into the code bucket.
 
 ```bash
 npx s3te validate
 npx s3te render --env dev
 npx s3te test
+npx s3te sync --env dev
+```
+
+Use a full deploy only when needed:
+
+```bash
 npx s3te deploy --env dev
 ```
 
+Once Webiny is installed and the stack is deployed with Webiny enabled, CMS content changes are picked up in AWS through the DynamoDB stream integration. Those content changes do not require another `sync` or `deploy`.
+
 </details>
 
 ### CLI Commands
@@ -284,6 +296,7 @@ npx s3te deploy --env dev
 | `s3te render --env <name>` | Renders locally into `offline/S3TELocal/preview/<env>/...`. |
 | `s3te test` | Runs the project tests from `offline/tests/`. |
 | `s3te package --env <name>` | Builds the AWS deployment artifacts without deploying them yet. |
+| `s3te sync --env <name>` | Uploads current project sources into the configured code buckets. |
 | `s3te doctor --env <name>` | Checks local machine and AWS access before deploy. |
 | `s3te deploy --env <name>` | Deploys or updates the AWS environment and syncs source files. |
 | `s3te migrate` | Updates older project configs and can retrofit Webiny into an existing S3TE project. |
@@ -378,6 +391,13 @@ npx s3te migrate --enable-webiny --webiny-source-table webiny-1234567 --webiny-t
 
 `staticContent` and `staticCodeContent` are kept automatically. Add `--webiny-model` once per custom model you want S3TE to mirror.
 
+If different environments should read from different Webiny installations or tenants, run the migration per environment:
+
+```bash
+npx s3te migrate --env test --enable-webiny --webiny-source-table webiny-test-1234567 --webiny-tenant preview --write
+npx s3te migrate --env prod --enable-webiny --webiny-source-table webiny-live-1234567 --webiny-tenant root --write
+```
+
 4. Turn on DynamoDB Streams for the Webiny source table with `NEW_AND_OLD_IMAGES`.
 5. If your S3TE language keys are not identical to your Webiny locales, add `webinyLocale` per language in `s3te.config.json`, for example `"en": { "webinyLocale": "en-US" }`.
 6. If your Webiny installation hosts multiple tenants, keep `integrations.webiny.tenant` set so S3TE only mirrors the intended tenant.
@@ -393,7 +413,100 @@ npx s3te doctor --env prod
 npx s3te deploy --env prod
 ```
 
-That deploy updates the existing environment stack and adds the Webiny mirror resources to it. You do not need a fresh S3TE installation.
+That deploy updates the existing environment stack and adds the Webiny mirror resources to it. You do not need a fresh S3TE installation. After that, Webiny content changes flow through the deployed AWS resources automatically; only template or asset changes still need `s3te sync --env <name>`.
+
+</details>
+
+<details>
+  <summary>GitHub Actions source publishing</summary>
+
+If your team works through GitHub instead of running `s3te sync` locally, the scaffold already includes `.github/workflows/s3te-sync.yml`.
+
+That workflow is meant for source publishing only:
+
+- it validates the project
+- it uploads `app/...` and `part/...` into the S3TE code bucket
+- the resulting S3 events trigger the deployed Lambda pipeline in AWS
+
+Use a full `deploy` only when the infrastructure, environment config, or runtime package changes.
+
+Before the workflow can run, do this once:
+
+1. Run the first real `npx s3te deploy --env <name>` so the code bucket already exists.
+2. In AWS IAM, create an access key for a CI user that may sync only the S3TE code bucket for that environment.
+3. In GitHub open `Settings -> Secrets and variables -> Actions -> Secrets`.
+4. Add these repository secrets:
+   - `AWS_ACCESS_KEY_ID`
+   - `AWS_SECRET_ACCESS_KEY`
+5. Open `.github/workflows/s3te-sync.yml` and adjust:
+   - the branch under `on.push.branches`
+   - `aws-region`
+   - `npx s3te sync --env dev` to your target environment such as `prod` or `test`
+
+Minimal IAM policy example for one code bucket:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": ["s3:ListBucket"],
+      "Resource": ["arn:aws:s3:::dev-website-code-mywebsite"]
+    },
+    {
+      "Effect": "Allow",
+      "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
+      "Resource": ["arn:aws:s3:::dev-website-code-mywebsite/*"]
+    }
+  ]
+}
+```
+
+For non-production environments or additional variants, use the derived code bucket names from your config, for example `test-website-code-mywebsite` or `app-code-mywebsite`.
+
+The scaffolded workflow looks like this:
+
+```yaml
+name: S3TE Sync
+on:
+  workflow_dispatch:
+  push:
+    branches: ["main"]
+    paths:
+      - "app/**"
+      - "package.json"
+      - "package-lock.json"
+      - ".github/workflows/s3te-sync.yml"
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+      - name: Install dependencies
+        shell: bash
+        run: |
+          if [ -f package-lock.json ]; then
+            npm ci
+          else
+            npm install
+          fi
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: eu-central-1
+      - run: npx s3te validate
+      - run: npx s3te sync --env dev
+```
 
 </details>
 
@@ -411,7 +524,17 @@ Example config block:
     "sourceTableName": "webiny-1234567",
     "mirrorTableName": "{stackPrefix}_s3te_content_{project}",
     "tenant": "root",
-    "relevantModels": ["article", "staticContent", "staticCodeContent"]
+    "relevantModels": ["article", "staticContent", "staticCodeContent"],
+    "environments": {
+      "test": {
+        "sourceTableName": "webiny-test-1234567",
+        "tenant": "preview"
+      },
+      "prod": {
+        "sourceTableName": "webiny-live-1234567",
+        "tenant": "root"
+      }
+    }
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectdochelp/s3te",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "description": "CLI, render core, AWS adapter, and testkit for S3TemplateEngine projects",
   "repository": {
     "type": "git",

package/packages/aws-adapter/src/deploy.mjs

@@ -10,6 +10,7 @@ import { ensureAwsCliAvailable, ensureAwsCredentials, runAwsCli } from "./aws-cl
 import { resolveRequestedFeatures } from "./features.mjs";
 import { buildAwsRuntimeManifest, extractStackOutputsMap } from "./manifest.mjs";
 import { packageAwsProject } from "./package.mjs";
+import { syncPreparedSources } from "./sync.mjs";
 import { buildTemporaryDeployStackTemplate } from "./template.mjs";
 
 function normalizeRelative(projectDir, targetPath) {
@@ -243,12 +244,12 @@ export async function deployAwsProject({
 }) {
   const runtimeConfig = buildEnvironmentRuntimeConfig(config, environment);
   const requestedFeatureSet = new Set(features);
-  const featureSet = new Set(resolveRequestedFeatures(config, features));
+  const featureSet = new Set(resolveRequestedFeatures(config, features, environment));
   const stackName = resolveStackName(config, environment);
   const tempStackName = temporaryStackName(stackName);
   const runtimeManifestPath = path.join(projectDir, packageDir ?? path.join("offline", "IAAS", "package", environment), "runtime-manifest.json");
 
-  if (requestedFeatureSet.has("webiny") && !config.integrations.webiny.enabled) {
+  if (requestedFeatureSet.has("webiny") && !runtimeConfig.integrations.webiny.enabled) {
     throw new S3teError("ADAPTER_ERROR", "Feature webiny was requested but is not enabled in s3te.config.json.");
   }
 
@@ -365,20 +366,15 @@ export async function deployAwsProject({
       stdio
     });
 
-    const syncedCodeBuckets = [];
-    if (!noSync) {
-      for (const [variantName, variantConfig] of Object.entries(runtimeConfig.variants)) {
-        const syncDir = path.join(projectDir, packaged.manifest.syncDirectories[variantName]);
-        await runAwsCli(["s3", "sync", syncDir, `s3://${variantConfig.codeBucket}`], {
-          region: runtimeConfig.awsRegion,
+    const syncedCodeBuckets = noSync
+      ? []
+      : (await syncPreparedSources({
+          projectDir,
+          runtimeConfig,
+          syncDirectories: packaged.manifest.syncDirectories,
           profile,
-          cwd: projectDir,
-          stdio,
-          errorCode: "ADAPTER_ERROR"
-        });
-        syncedCodeBuckets.push(variantConfig.codeBucket);
-      }
-    }
+          stdio
+        })).syncedCodeBuckets;
 
     const distributions = [];
     for (const [variantName, variantConfig] of Object.entries(runtimeConfig.variants)) {

package/packages/aws-adapter/src/features.mjs

@@ -1,16 +1,29 @@
-export function getConfiguredFeatures(config) {
+import { resolveEnvironmentWebinyIntegration } from "../../core/src/index.mjs";
+
+export function getConfiguredFeatures(config, environment) {
   const features = [];
 
-  if (config.integrations?.webiny?.enabled) {
+  if (environment) {
+    if (resolveEnvironmentWebinyIntegration(config, environment).enabled) {
+      features.push("webiny");
+    }
+    return features;
+  }
+
+  const hasAnyEnvironmentWebiny = Object.keys(config.environments ?? {}).some((environmentName) => (
+    resolveEnvironmentWebinyIntegration(config, environmentName).enabled
+  ));
+
+  if (hasAnyEnvironmentWebiny) {
     features.push("webiny");
   }
 
   return features;
 }
 
-export function resolveRequestedFeatures(config, requestedFeatures = []) {
+export function resolveRequestedFeatures(config, requestedFeatures = [], environment) {
   return [...new Set([
     ...requestedFeatures,
-    ...getConfiguredFeatures(config)
+    ...getConfiguredFeatures(config, environment)
   ])].sort();
 }

package/packages/aws-adapter/src/index.mjs

@@ -5,3 +5,4 @@ export { ensureAwsCliAvailable, ensureAwsCredentials, runAwsCli } from "./aws-cl
 export { getConfiguredFeatures, resolveRequestedFeatures } from "./features.mjs";
 export { packageAwsProject } from "./package.mjs";
 export { deployAwsProject } from "./deploy.mjs";
+export { stageProjectSources, syncPreparedSources, syncAwsProject } from "./sync.mjs";

package/packages/aws-adapter/src/package.mjs

@@ -221,11 +221,13 @@ export async function packageAwsProject({
   clean = false,
   features = []
 }) {
-  if (features.includes("webiny") && !config.integrations.webiny.enabled) {
+  const runtimeConfig = buildEnvironmentRuntimeConfig(config, environment);
+
+  if (features.includes("webiny") && !runtimeConfig.integrations.webiny.enabled) {
     throw new S3teError("ADAPTER_ERROR", "Feature webiny was requested but is not enabled in s3te.config.json.");
   }
 
-  const resolvedFeatures = resolveRequestedFeatures(config, features);
+  const resolvedFeatures = resolveRequestedFeatures(config, features, environment);
   const packageDir = outDir
     ? path.join(projectDir, outDir)
     : path.join(projectDir, "offline", "IAAS", "package", environment);
@@ -234,7 +236,6 @@ export async function packageAwsProject({
   }
   await ensureDirectory(packageDir);
 
-  const runtimeConfig = buildEnvironmentRuntimeConfig(config, environment);
   const lambdaDir = path.join(packageDir, "lambda");
   const templatePath = path.join(packageDir, "cloudformation.template.json");
   const packagingManifestPath = path.join(packageDir, "manifest.json");

package/packages/aws-adapter/src/sync.mjs

@@ -0,0 +1,155 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { buildEnvironmentRuntimeConfig } from "../../core/src/index.mjs";
+import { ensureAwsCliAvailable, ensureAwsCredentials, runAwsCli } from "./aws-cli.mjs";
+
+async function ensureDirectory(targetDir) {
+  await fs.mkdir(targetDir, { recursive: true });
+}
+
+async function removeDirectory(targetDir) {
+  await fs.rm(targetDir, { recursive: true, force: true });
+}
+
+async function listFiles(rootDir, currentDir = rootDir) {
+  const entries = await fs.readdir(currentDir, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    const fullPath = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFiles(rootDir, fullPath));
+      continue;
+    }
+
+    if (entry.isFile()) {
+      files.push(path.relative(rootDir, fullPath).replace(/\\/g, "/"));
+    }
+  }
+
+  return files.sort();
+}
+
+async function copyDirectory(sourceDir, targetDir) {
+  const files = await listFiles(sourceDir);
+  for (const relativePath of files) {
+    const sourcePath = path.join(sourceDir, relativePath);
+    const targetPath = path.join(targetDir, relativePath);
+    await ensureDirectory(path.dirname(targetPath));
+    await fs.copyFile(sourcePath, targetPath);
+  }
+}
+
+function normalizeRelative(projectDir, targetPath) {
+  return path.relative(projectDir, targetPath).replace(/\\/g, "/");
+}
+
+async function stageVariantSources(projectDir, runtimeConfig, variantName, syncRoot) {
+  const variantConfig = runtimeConfig.variants[variantName];
+  const variantRoot = path.join(syncRoot, variantName);
+  await removeDirectory(variantRoot);
+  await ensureDirectory(variantRoot);
+
+  await copyDirectory(path.join(projectDir, variantConfig.partDir), path.join(variantRoot, "part"));
+  await copyDirectory(path.join(projectDir, variantConfig.sourceDir), path.join(variantRoot, variantName));
+
+  return variantRoot;
+}
+
+export async function stageProjectSources({
+  projectDir,
+  config,
+  environment,
+  outDir
+}) {
+  const runtimeConfig = buildEnvironmentRuntimeConfig(config, environment);
+  const syncRoot = outDir
+    ? path.join(projectDir, outDir)
+    : path.join(projectDir, "offline", "IAAS", "sync", environment);
+
+  await ensureDirectory(syncRoot);
+
+  const syncDirectories = {};
+  for (const variantName of Object.keys(runtimeConfig.variants)) {
+    const variantRoot = await stageVariantSources(projectDir, runtimeConfig, variantName, syncRoot);
+    syncDirectories[variantName] = normalizeRelative(projectDir, variantRoot);
+  }
+
+  return {
+    runtimeConfig,
+    syncRoot: normalizeRelative(projectDir, syncRoot),
+    syncDirectories
+  };
+}
+
+export async function syncPreparedSources({
+  projectDir,
+  runtimeConfig,
+  syncDirectories,
+  profile,
+  stdio = "pipe",
+  ensureAwsCliAvailableFn = ensureAwsCliAvailable,
+  ensureAwsCredentialsFn = ensureAwsCredentials,
+  runAwsCliFn = runAwsCli
+}) {
+  await ensureAwsCliAvailableFn({ cwd: projectDir });
+  await ensureAwsCredentialsFn({
+    region: runtimeConfig.awsRegion,
+    profile,
+    cwd: projectDir
+  });
+
+  const syncedCodeBuckets = [];
+  for (const [variantName, variantConfig] of Object.entries(runtimeConfig.variants)) {
+    const syncDir = path.join(projectDir, syncDirectories[variantName]);
+    await runAwsCliFn(["s3", "sync", syncDir, `s3://${variantConfig.codeBucket}`, "--delete"], {
+      region: runtimeConfig.awsRegion,
+      profile,
+      cwd: projectDir,
+      stdio,
+      errorCode: "ADAPTER_ERROR"
+    });
+    syncedCodeBuckets.push(variantConfig.codeBucket);
+  }
+
+  return {
+    syncedCodeBuckets
+  };
+}
+
+export async function syncAwsProject({
+  projectDir,
+  config,
+  environment,
+  outDir,
+  profile,
+  stdio = "pipe",
+  ensureAwsCliAvailableFn = ensureAwsCliAvailable,
+  ensureAwsCredentialsFn = ensureAwsCredentials,
+  runAwsCliFn = runAwsCli
+}) {
+  const prepared = await stageProjectSources({
+    projectDir,
+    config,
+    environment,
+    outDir
+  });
+
+  const synced = await syncPreparedSources({
+    projectDir,
+    runtimeConfig: prepared.runtimeConfig,
+    syncDirectories: prepared.syncDirectories,
+    profile,
+    stdio,
+    ensureAwsCliAvailableFn,
+    ensureAwsCredentialsFn,
+    runAwsCliFn
+  });
+
+  return {
+    syncRoot: prepared.syncRoot,
+    syncDirectories: prepared.syncDirectories,
+    syncedCodeBuckets: synced.syncedCodeBuckets
+  };
+}

package/packages/cli/bin/s3te.mjs

@@ -11,6 +11,7 @@ import {
   renderProject,
   runProjectTests,
   scaffoldProject,
+  syncProject,
   validateProject
 } from "../src/project.mjs";
 
@@ -82,6 +83,7 @@ function printHelp() {
     "  render\n" +
     "  test\n" +
     "  package\n" +
+    "  sync\n" +
     "  deploy\n" +
     "  doctor\n" +
     "  migrate\n"
@@ -281,6 +283,37 @@ async function main() {
     return;
   }
 
+  if (command === "sync") {
+    const loaded = await loadConfigForCommand(cwd, options.config);
+    if (!loaded.ok) {
+      if (wantsJson) {
+        printJson("sync", false, loaded.warnings, loaded.errors, startedAt);
+      }
+      process.exitCode = 2;
+      return;
+    }
+    if (!options.env) {
+      process.stderr.write("sync requires --env <name>\n");
+      process.exitCode = 1;
+      return;
+    }
+
+    const report = await syncProject(cwd, loaded.config, {
+      environment: asArray(options.env)[0],
+      outDir: options["out-dir"],
+      profile: options.profile,
+      stdio: wantsJson ? "pipe" : "inherit"
+    });
+
+    if (wantsJson) {
+      printJson("sync", true, [], [], startedAt, report);
+      return;
+    }
+
+    process.stdout.write(`Synced project sources to ${report.syncedCodeBuckets.length} code bucket(s)\n`);
+    return;
+  }
+
   if (command === "deploy") {
     const loaded = await loadConfigForCommand(cwd, options.config);
     if (!loaded.ok) {
@@ -349,6 +382,7 @@ async function main() {
     const rawConfig = JSON.parse(await fs.readFile(configPath, "utf8"));
     const migration = await migrateProject(configPath, rawConfig, {
       writeChanges: Boolean(options.write) && !Boolean(options["dry-run"]),
+      environment: asArray(options.env)[0],
       enableWebiny: Boolean(options["enable-webiny"]),
       disableWebiny: Boolean(options["disable-webiny"]),
       webinySourceTable: options["webiny-source-table"],