@reventlessdev/reventless-aws 3.0.0-alpha.346 → 3.0.0-alpha.348

package/scripts/DeployApp.res.mjs

@@ -0,0 +1,1015 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Yaml from "yaml";
+import * as Nodefs from "node:fs";
+import * as Nodeurl from "node:url";
+import * as Nodepath from "node:path";
+import * as SSM$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/SSM.res.mjs";
+import * as STS$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/STS.res.mjs";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Lambda$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/Lambda.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Lambda$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/Lambda/Lambda.res.mjs";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as ClientSsm from "@aws-sdk/client-ssm";
+import * as ClientSts from "@aws-sdk/client-sts";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as ClientLambda from "@aws-sdk/client-lambda";
+import * as BakeManifest$ReventlessAws from "./BakeManifest.res.mjs";
+import * as AccountsManifest$Reventless from "@reventlessdev/reventless-spec/src/types/AccountsManifest.res.mjs";
+import * as Util_AwsError$ReventlessAws from "../src/util/Util_AwsError.res.mjs";
+import * as DeployManifest$ReventlessAws from "./DeployManifest.res.mjs";
+import * as ProvisionAccounts$ReventlessAws from "./ProvisionAccounts.res.mjs";
+import * as IndexJs from "@pulumi/pulumi/automation/index.js";
+
+let defaultStack = "dev";
+
+function parseArgs(argv) {
+  let acc = {
+    TAG: "Ok",
+    _0: {
+      command: undefined,
+      manifest: undefined,
+      stack: defaultStack,
+      help: false
+    }
+  };
+  let i = 0;
+  let count = argv.length;
+  while (i < count) {
+    let flag = argv[i];
+    let value = argv[i + 1 | 0];
+    let match = acc;
+    let exit = 0;
+    if (match.TAG === "Ok") {
+      let a = match._0;
+      let exit$1 = 0;
+      switch (flag) {
+        case "--manifest" :
+          if (value !== undefined) {
+            acc = {
+              TAG: "Ok",
+              _0: {
+                command: a.command,
+                manifest: value,
+                stack: a.stack,
+                help: a.help
+              }
+            };
+            i = i + 2 | 0;
+          } else {
+            exit = 1;
+          }
+          break;
+        case "--stack" :
+          if (value !== undefined) {
+            acc = {
+              TAG: "Ok",
+              _0: {
+                command: a.command,
+                manifest: a.manifest,
+                stack: value,
+                help: a.help
+              }
+            };
+            i = i + 2 | 0;
+          } else {
+            exit = 1;
+          }
+          break;
+        case "--help" :
+        case "-h" :
+          exit$1 = 2;
+          break;
+        case "down" :
+          if (a.command === undefined) {
+            acc = {
+              TAG: "Ok",
+              _0: {
+                command: "Down",
+                manifest: a.manifest,
+                stack: a.stack,
+                help: a.help
+              }
+            };
+            i = i + 1 | 0;
+          } else {
+            exit$1 = 3;
+          }
+          break;
+        case "up" :
+          if (a.command === undefined) {
+            acc = {
+              TAG: "Ok",
+              _0: {
+                command: "Up",
+                manifest: a.manifest,
+                stack: a.stack,
+                help: a.help
+              }
+            };
+            i = i + 1 | 0;
+          } else {
+            exit$1 = 3;
+          }
+          break;
+        default:
+          exit$1 = 3;
+      }
+      switch (exit$1) {
+        case 2 :
+          acc = {
+            TAG: "Ok",
+            _0: {
+              command: a.command,
+              manifest: a.manifest,
+              stack: a.stack,
+              help: true
+            }
+          };
+          i = i + 1 | 0;
+          break;
+        case 3 :
+          acc = {
+            TAG: "Error",
+            _0: `unknown argument "` + flag + `"`
+          };
+          break;
+      }
+    } else {
+      i = count;
+    }
+    if (exit === 1) {
+      acc = {
+        TAG: "Error",
+        _0: flag + ` needs a value`
+      };
+    }
+  };
+  return acc;
+}
+
+let usage = `
+Deploy an app to AWS, or remove it again.
+
+  deploy-app up     Deploy the platform and every plugin, bake the component
+                    manifest, create the accounts in .reventless/users.<stack>.yaml,
+                    and print the web address and the sign-ins.
+  deploy-app down   Remove every stack, and the Lambda layer and SSM parameter
+                    \`up\` created.
+
+  --manifest <path>  The deploy manifest. Defaults to ` + DeployManifest$ReventlessAws.defaultFile + `
+                     in the working directory.
+  --stack <name>     The try-out stack. Defaults to "` + defaultStack + `".
+
+Region and credentials come from the environment, as for any AWS call. Only
+stacks declaring reventless:disposable: "true" are touched; \`up\` sets it on
+every stack it creates.
+`;
+
+function projectOf(p) {
+  let file = Nodepath.join(p.dir, "Pulumi.yaml");
+  let json;
+  try {
+    json = Yaml.parse(Nodefs.readFileSync(file, "utf8"));
+  } catch (exn) {
+    json = undefined;
+  }
+  if (json === undefined) {
+    return {
+      TAG: "Error",
+      _0: file + ` cannot be read — is ` + p.dir + ` a Pulumi project?`
+    };
+  }
+  let field = name => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), o => o[name]), Stdlib_JSON.Decode.string);
+  let projectName = field("name");
+  if (projectName !== undefined) {
+    return {
+      TAG: "Ok",
+      _0: {
+        label: p.name,
+        dir: p.dir,
+        projectName: projectName,
+        program: Nodepath.join(p.dir, Stdlib_Option.getOr(field("main"), "index.js")),
+        stackDefaults: p.stackDefaults
+      }
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: file + ` names no project`
+    };
+  }
+}
+
+function projectsOf(manifest) {
+  let e = projectOf(manifest.platform);
+  if (e.TAG !== "Ok") {
+    return e;
+  }
+  let plugins = manifest.plugins.map(projectOf);
+  let match = plugins.find(Stdlib_Result.isError);
+  if (match !== undefined && match.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: match._0
+    };
+  }
+  return {
+    TAG: "Ok",
+    _0: [
+      e._0,
+      Stdlib_Array.filterMap(plugins, r => Stdlib_Result.mapOr(r, undefined, p => p))
+    ]
+  };
+}
+
+function checkNode(version) {
+  let major = Stdlib_Option.flatMap(version.split(".")[0], v => Stdlib_Int.fromString(v, undefined));
+  if (major !== undefined && major >= 22) {
+    return;
+  }
+  return `Reventless needs Node ` + (22).toString() + ` or later, and this is Node ` + version + `. Switch to the version in .node-version (for example \`fnm use\` or \`nvm use\`).`;
+}
+
+function backendNeedsPassphrase(url, env) {
+  if (url !== undefined && !url.startsWith("https://") && env["PULUMI_CONFIG_PASSPHRASE"] === undefined) {
+    return env["PULUMI_CONFIG_PASSPHRASE_FILE"] === undefined;
+  } else {
+    return false;
+  }
+}
+
+function unbuilt(projects) {
+  return projects.filter(p => !Nodefs.existsSync(p.program));
+}
+
+async function check(projects) {
+  let problems = [];
+  Stdlib_Option.forEach(checkNode(Stdlib_Option.getOr(process.versions["node"], "0")), p => {
+    problems.push(p);
+  });
+  let sts = STS$AwsSdk.client(undefined, undefined);
+  let region;
+  let exit = 0;
+  let region$1;
+  try {
+    region$1 = await sts.config.region();
+    exit = 1;
+  } catch (exn) {
+    problems.push("No AWS region is set. Set AWS_REGION (for example `export AWS_REGION=eu-west-1`) or give your AWS profile a region.");
+    region = undefined;
+  }
+  if (exit === 1) {
+    region = region$1;
+  }
+  let account;
+  if (region !== undefined) {
+    let exit$1 = 0;
+    let identity;
+    try {
+      identity = await STS$AwsSdk.client(region, undefined).send(new ClientSts.GetCallerIdentityCommand({}));
+      exit$1 = 1;
+    } catch (raw_exn) {
+      let exn$1 = Primitive_exceptions.internalToException(raw_exn);
+      problems.push(`The AWS credentials do not work (` + Util_AwsError$ReventlessAws.describe(exn$1) + `). Sign in — \`aws sso login\`, or set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY — and try again.`);
+      account = undefined;
+    }
+    if (exit$1 === 1) {
+      account = identity.Account;
+    }
+  } else {
+    account = undefined;
+  }
+  let platform = projects[0];
+  if (platform !== undefined) {
+    let exit$2 = 0;
+    let workspace;
+    try {
+      workspace = await IndexJs.LocalWorkspace.create({
+        workDir: platform.dir
+      });
+      exit$2 = 1;
+    } catch (exn$2) {
+      problems.push("The Pulumi CLI could not be run. Install it — https://www.pulumi.com/docs/iac/download-install/ — and try again.");
+    }
+    if (exit$2 === 1) {
+      let exit$3 = 0;
+      let who;
+      try {
+        who = await workspace.whoAmI();
+        exit$3 = 2;
+      } catch (exn$3) {
+        problems.push("Pulumi is not logged in. Run `pulumi login` (Pulumi Cloud) or `pulumi login --local`, and try again.");
+      }
+      if (exit$3 === 2) {
+        if (backendNeedsPassphrase(who.url, process.env)) {
+          problems.push(`Pulumi is logged in to ` + Stdlib_Option.getOr(who.url, "a self-managed backend") + `, which protects stack secrets with a passphrase. Set PULUMI_CONFIG_PASSPHRASE (an empty value is allowed) and try again.`);
+        }
+      }
+    }
+  }
+  unbuilt(projects).forEach(p => {
+    problems.push(p.label + ` is not built: ` + p.program + ` is missing. Run \`pnpm run build\` and try again.`);
+  });
+  if (problems.length !== 0) {
+    return {
+      TAG: "Error",
+      _0: problems
+    };
+  } else if (region !== undefined) {
+    if (account !== undefined) {
+      return {
+        TAG: "Ok",
+        _0: {
+          region: region,
+          account: account
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: ["The AWS account could not be identified."]
+      };
+    }
+  } else {
+    return {
+      TAG: "Error",
+      _0: ["The AWS account could not be identified."]
+    };
+  }
+}
+
+function layerName(stack) {
+  return `reventless-aws-` + stack;
+}
+
+let layerDescriptionPrefix = "reventless-aws@";
+
+function layerDescription(version) {
+  return layerDescriptionPrefix + version;
+}
+
+function releaseUrl(version) {
+  return `https://github.com/ReventlessDev/reventless-core/releases/download/` + encodeURIComponent("@reventlessdev/reventless-aws@" + version) + `/reventless-layer.zip`;
+}
+
+function installedVersion() {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(Nodefs.readFileSync(Nodepath.join(Nodepath.dirname(Nodeurl.fileURLToPath(import.meta.url)), "..", "package.json"), "utf8"))), o => o["version"]), Stdlib_JSON.Decode.string), "unknown");
+}
+
+function errorName(exn) {
+  return Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), e => Stdlib_JsExn.name(e));
+}
+
+async function storedLayerArn(ssm, parameter) {
+  let output;
+  try {
+    output = await ssm.send(new ClientSsm.GetParameterCommand({
+      Name: parameter
+    }));
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    if (Primitive_object.equal(errorName(exn), SSM$AwsSdk.parameterNotFound)) {
+      return;
+    }
+    throw exn;
+  }
+  return Stdlib_Option.flatMap(output.Parameter, p => p.Value);
+}
+
+async function layerVersionDescription(lambda, arn) {
+  let output;
+  try {
+    output = await lambda.send(new ClientLambda.GetLayerVersionByArnCommand({
+      Arn: arn
+    }));
+  } catch (exn) {
+    return;
+  }
+  return output.Description;
+}
+
+async function ensureLayer(stack, region, version) {
+  let arn = process.env["REVENTLESS_LAYER_ARN"];
+  let exit = 0;
+  if (arn !== undefined) {
+    if (arn.trim() !== "") {
+      console.log(`layer    ` + arn + ` (from REVENTLESS_LAYER_ARN)`);
+      return {
+        TAG: "Ok",
+        _0: arn.trim()
+      };
+    }
+    exit = 1;
+  } else {
+    exit = 1;
+  }
+  if (exit === 1) {
+    let ssm = SSM$AwsSdk.client(region, undefined);
+    let lambda = Lambda$AwsSdk.client(region, undefined);
+    let parameter = Lambda$PulumiAws.layerParameter(stack);
+    let stored = await storedLayerArn(ssm, parameter);
+    let current = stored !== undefined && Primitive_object.equal(await layerVersionDescription(lambda, stored), layerDescriptionPrefix + version) ? stored : undefined;
+    if (current !== undefined) {
+      console.log(`layer    ` + current + ` (already published for ` + version + `)`);
+      return {
+        TAG: "Ok",
+        _0: current
+      };
+    }
+    let url = releaseUrl(version);
+    console.log(`layer    downloading ` + url);
+    let exit$1 = 0;
+    let response;
+    try {
+      response = await fetch(url, {});
+      exit$1 = 2;
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      return {
+        TAG: "Error",
+        _0: `downloading ` + url + ` failed: ` + Util_AwsError$ReventlessAws.describe(exn)
+      };
+    }
+    if (exit$1 === 2) {
+      if (response.status === 404) {
+        return {
+          TAG: "Error",
+          _0: `No Lambda layer was released for reventless-aws@` + version + ` — this checkout sits between two releases. Build one with \`REVENTLESS_AWS_VERSION=` + version + ` pnpm run build\` in reventless/layer-builder/, publish it, and set REVENTLESS_LAYER_ARN.`
+        };
+      }
+      if (!response.ok) {
+        return {
+          TAG: "Error",
+          _0: `downloading ` + url + ` failed with HTTP ` + response.status.toString()
+        };
+      }
+      let zip = new Uint8Array(await response.arrayBuffer());
+      let published = await lambda.send(new ClientLambda.PublishLayerVersionCommand({
+        LayerName: layerName(stack),
+        Description: layerDescriptionPrefix + version,
+        Content: {
+          ZipFile: zip
+        },
+        CompatibleRuntimes: [
+          "nodejs20.x",
+          "nodejs22.x"
+        ]
+      }));
+      let arn$1 = published.LayerVersionArn;
+      if (arn$1 !== undefined) {
+        await ssm.send(new ClientSsm.PutParameterCommand({
+          Name: parameter,
+          Value: arn$1,
+          Type: "String",
+          Overwrite: true
+        }));
+        console.log(`layer    ` + arn$1 + ` (published, stored in ` + parameter + `)`);
+        return {
+          TAG: "Ok",
+          _0: arn$1
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: `publishing the layer ` + layerName(stack) + ` returned no ARN`
+        };
+      }
+    }
+  }
+}
+
+async function removeLayer(stack, region) {
+  let lambda = Lambda$AwsSdk.client(region, undefined);
+  let ssm = SSM$AwsSdk.client(region, undefined);
+  let name = layerName(stack);
+  let versions = [];
+  let marker;
+  let more = true;
+  while (more) {
+    let exit = 0;
+    let page;
+    try {
+      page = await lambda.send(new ClientLambda.ListLayerVersionsCommand({
+        LayerName: name,
+        Marker: marker
+      }));
+      exit = 1;
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      if (Primitive_object.equal(errorName(exn), "ResourceNotFoundException")) {
+        more = false;
+      } else {
+        throw exn;
+      }
+    }
+    if (exit === 1) {
+      Stdlib_Option.forEach(page.LayerVersions, page => {
+        versions.push(...page);
+      });
+      marker = page.NextMarker;
+      more = page.NextMarker !== undefined;
+    }
+  };
+  for (let index = 0, index_finish = versions.length; index < index_finish; ++index) {
+    let v = versions[index];
+    let match = v.Version;
+    let match$1 = v.Description;
+    if (match !== undefined && match$1 !== undefined && match$1.startsWith(layerDescriptionPrefix)) {
+      await lambda.send(new ClientLambda.DeleteLayerVersionCommand({
+        LayerName: name,
+        VersionNumber: match
+      }));
+      console.log(`layer    removed ` + name + `:` + match.toString());
+    }
+  }
+  let parameter = Lambda$PulumiAws.layerParameter(stack);
+  let arn = await storedLayerArn(ssm, parameter);
+  if (arn !== undefined && arn.includes(`:layer:` + name + `:`)) {
+    await ssm.send(new ClientSsm.DeleteParameterCommand({
+      Name: parameter
+    }));
+    console.log(`layer    removed ` + parameter);
+    return;
+  }
+}
+
+let disposableKey = "reventless:disposable";
+
+async function isDisposable(stack) {
+  let val;
+  try {
+    val = await stack.getConfig(disposableKey);
+  } catch (exn) {
+    return false;
+  }
+  return val.value === "true";
+}
+
+async function existingStack(project, stack, envVars) {
+  let found;
+  try {
+    found = await IndexJs.LocalWorkspace.selectStack({
+      stackName: stack,
+      workDir: project.dir
+    }, {
+      envVars: envVars
+    });
+  } catch (exn) {
+    return;
+  }
+  return Primitive_option.some(found);
+}
+
+function newStackConfig(project, region) {
+  return Object.entries(project.stackDefaults).concat([
+    [
+      "aws:region",
+      region
+    ],
+    [
+      "aws-native:region",
+      region
+    ],
+    [
+      disposableKey,
+      "true"
+    ]
+  ]);
+}
+
+async function openForUp(project, stack, region, envVars, extra) {
+  let setAll = async (s, settings) => {
+    for (let index = 0, index_finish = settings.length; index < index_finish; ++index) {
+      let match = settings[index];
+      await s.setConfig(match[0], {
+        value: match[1]
+      });
+    }
+  };
+  let existing = await existingStack(project, stack, envVars);
+  if (existing !== undefined) {
+    let existing$1 = Primitive_option.valFromOption(existing);
+    if (await isDisposable(existing$1)) {
+      await setAll(existing$1, extra);
+      return {
+        TAG: "Ok",
+        _0: existing$1
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: project.projectName + `/` + stack + ` already exists and does not declare ` + disposableKey + `: "true". deploy-app only deploys try-out stacks it created; pick another --stack.`
+      };
+    }
+  }
+  let created = await IndexJs.LocalWorkspace.createOrSelectStack({
+    stackName: stack,
+    workDir: project.dir
+  }, {
+    envVars: envVars
+  });
+  await setAll(created, newStackConfig(project, region).concat(extra));
+  console.log(`stack    ` + project.projectName + `/` + stack + ` (created)`);
+  return {
+    TAG: "Ok",
+    _0: created
+  };
+}
+
+function stream(text) {
+  process.stdout.write(text);
+}
+
+function failureDetail(exn) {
+  let message = Util_AwsError$ReventlessAws.describe(exn);
+  let errors = [];
+  message.split("\n").map(prim => prim.trim()).forEach(line => {
+    if (line.startsWith("error:") && !errors.includes(line)) {
+      errors.push(line);
+      return;
+    }
+  });
+  if (errors.length !== 0) {
+    return errors.join("\n");
+  } else {
+    return message;
+  }
+}
+
+async function deploy(project, stack, name) {
+  console.log(`\n── Deploying ` + project.label + ` (` + project.projectName + `/` + name + `) ──\n`);
+  try {
+    await stack.up({
+      onOutput: stream
+    });
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return {
+      TAG: "Error",
+      _0: `deploying ` + project.projectName + `/` + name + ` failed. Fix the cause and run up again; what was created is kept and reused.\n` + failureDetail(exn)
+    };
+  }
+}
+
+function outputString(outputs, name) {
+  return Stdlib_Option.flatMap(outputs[name], o => Stdlib_JSON.Decode.string(o.value));
+}
+
+function accountsFileName(stack) {
+  return `users.` + stack + `.yaml`;
+}
+
+function accountsFile(platformDir, stack) {
+  let file = Nodepath.join(platformDir, ".reventless", accountsFileName(stack));
+  let template = Nodepath.join(platformDir, AccountsManifest$Reventless.templateName);
+  let match = Nodefs.existsSync(file);
+  let match$1 = Nodefs.existsSync(template);
+  if (match) {
+    return file;
+  } else if (match$1) {
+    Nodefs.mkdirSync(Nodepath.dirname(file), {
+      recursive: true
+    });
+    Nodefs.cpSync(template, file, {});
+    console.log(`manifest ` + file + ` (new, copied from ` + template + `)`);
+    return file;
+  } else {
+    return;
+  }
+}
+
+function signInLines(entries) {
+  let width = Stdlib_Array.reduce(entries, 0, (w, e) => Math.max(w, e.username.length));
+  return entries.map(e => `    ` + e.username.padEnd(width, " ") + `  [` + e.groups.join(", ") + `]`);
+}
+
+async function up(manifest, stack) {
+  let e = projectsOf(manifest);
+  if (e.TAG !== "Ok") {
+    return e;
+  }
+  let match = e._0;
+  let plugins = match[1];
+  let platform = match[0];
+  let problems = await check([platform].concat(plugins));
+  if (problems.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: `not ready to deploy:\n` + problems._0.map(p => `  - ` + p).join("\n")
+    };
+  }
+  let match$1 = problems._0;
+  let region = match$1.region;
+  console.log(`account  ` + match$1.account + `, region ` + region + `, stack ` + stack);
+  let startedAt = new Date().toISOString();
+  let e$1 = await ensureLayer(stack, region, installedVersion());
+  if (e$1.TAG !== "Ok") {
+    return e$1;
+  }
+  let envVars = Object.fromEntries([[
+      "REVENTLESS_LAYER_ARN",
+      e$1._0
+    ]]);
+  let e$2 = await openForUp(platform, stack, region, envVars, []);
+  if (e$2.TAG !== "Ok") {
+    return e$2;
+  }
+  let platformStack = e$2._0;
+  let e$3 = await deploy(platform, platformStack, stack);
+  if (e$3.TAG !== "Ok") {
+    return e$3;
+  }
+  let platformOutputs = await platformStack.outputs();
+  let platformRef = outputString(platformOutputs, "platformStack");
+  if (platformRef === undefined) {
+    return {
+      TAG: "Error",
+      _0: `the platform stack exports no platformStack — its reventless-aws is older than this command`
+    };
+  }
+  let deployPlugins = async index => {
+    let plugin = plugins[index];
+    if (plugin === undefined) {
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    }
+    let e = await openForUp(plugin, stack, region, envVars, [[
+        "platform:stack",
+        platformRef
+      ]]);
+    if (e.TAG !== "Ok") {
+      return e;
+    }
+    let e$1 = await deploy(plugin, e._0, stack);
+    if (e$1.TAG === "Ok") {
+      return await deployPlugins(index + 1 | 0);
+    } else {
+      return e$1;
+    }
+  };
+  let e$4 = await deployPlugins(0);
+  if (e$4.TAG !== "Ok") {
+    return e$4;
+  }
+  console.log("\n── Baking the component manifest ──\n");
+  let e$5 = await BakeManifest$ReventlessAws.bake(manifest, stack, startedAt);
+  if (e$5.TAG !== "Ok") {
+    return e$5;
+  }
+  let match$2 = accountsFile(platform.dir, stack);
+  let match$3 = outputString(platformOutputs, "identityProviderId");
+  let accounts;
+  if (match$2 !== undefined) {
+    if (match$3 !== undefined) {
+      console.log("\n── Creating the accounts ──\n");
+      let e$6 = await ProvisionAccounts$ReventlessAws.provision(match$2, match$3, undefined);
+      accounts = e$6.TAG === "Ok" ? ({
+          TAG: "Ok",
+          _0: match$2
+        }) : e$6;
+    } else {
+      accounts = {
+        TAG: "Error",
+        _0: "the platform stack exports no identityProviderId to create accounts in"
+      };
+    }
+  } else {
+    accounts = {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
+  if (accounts.TAG !== "Ok") {
+    return accounts;
+  }
+  console.log("\n── Ready ──\n");
+  let url = outputString(platformOutputs, "hostShellUrl");
+  if (url !== undefined) {
+    console.log(`  Open:    ` + url);
+  } else {
+    console.log("  This platform deploys no web app.");
+  }
+  Stdlib_Option.forEach(accounts._0, file => {
+    let entries = AccountsManifest$Reventless.parseFile(file);
+    if (entries.TAG !== "Ok") {
+      return;
+    }
+    let entries$1 = entries._0;
+    if (entries$1.length !== 0) {
+      console.log("  Sign in:");
+      signInLines(entries$1).forEach(line => {
+        console.log(line);
+      });
+      console.log(`  The passwords are in ` + file + `.`);
+      return;
+    }
+  });
+  console.log(`  Remove it all again: deploy-app down --stack ` + stack);
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+async function down(manifest, stack) {
+  let e = projectsOf(manifest);
+  if (e.TAG !== "Ok") {
+    return e;
+  }
+  let match = e._0;
+  let sts = STS$AwsSdk.client(undefined, undefined);
+  let region;
+  try {
+    region = await sts.config.region();
+  } catch (exn) {
+    return {
+      TAG: "Error",
+      _0: "No AWS region is set. Set AWS_REGION and try again."
+    };
+  }
+  let envVars = {};
+  let ordered = match[1].toReversed().concat([match[0]]);
+  let found = [];
+  let refused = [];
+  for (let index = 0, index_finish = ordered.length; index < index_finish; ++index) {
+    let project = ordered[index];
+    let s = await existingStack(project, stack, envVars);
+    if (s !== undefined) {
+      let s$1 = Primitive_option.valFromOption(s);
+      if (await isDisposable(s$1)) {
+        found.push([
+          project,
+          s$1
+        ]);
+      } else {
+        refused.push(project.projectName + `/` + stack);
+      }
+    } else {
+      console.log(`stack    ` + project.projectName + `/` + stack + ` (not deployed)`);
+    }
+  }
+  if (refused.length !== 0) {
+    return {
+      TAG: "Error",
+      _0: `nothing was removed: ` + refused.join(", ") + ` ` + (
+        refused.length === 1 ? "does" : "do"
+      ) + ` not declare ` + disposableKey + `: "true", and deploy-app only removes try-out stacks it created.`
+    };
+  }
+  let removeStacks = async index => {
+    let match = found[index];
+    if (match === undefined) {
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    }
+    let s = match[1];
+    let project = match[0];
+    console.log(`\n── Removing ` + project.label + ` (` + project.projectName + `/` + stack + `) ──\n`);
+    let val;
+    try {
+      val = await s.destroy({
+        onOutput: stream
+      });
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      return {
+        TAG: "Error",
+        _0: `removing ` + project.projectName + `/` + stack + ` failed. Fix the cause and run down again.\n` + failureDetail(exn)
+      };
+    }
+    await s.workspace.removeStack(stack);
+    return await removeStacks(index + 1 | 0);
+  };
+  let e$1 = await removeStacks(0);
+  if (e$1.TAG !== "Ok") {
+    return e$1;
+  }
+  await removeLayer(stack, region);
+  console.log(found.length === 0 ? `\nNo stack was deployed as ` + stack + `.` : `\nRemoved ` + stack + `.`);
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+async function run() {
+  let e = parseArgs(process.argv.slice(2, process.argv.length));
+  if (e.TAG !== "Ok") {
+    return e;
+  }
+  let args = e._0;
+  let command = args.command;
+  if (args.help) {
+    console.log(usage);
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
+  if (command === undefined) {
+    return {
+      TAG: "Error",
+      _0: "say `up` or `down` (--help for more)"
+    };
+  }
+  let stack = args.stack;
+  let e$1 = DeployManifest$ReventlessAws.load(Stdlib_Option.getOr(args.manifest, DeployManifest$ReventlessAws.defaultFile));
+  if (e$1.TAG !== "Ok") {
+    return e$1;
+  }
+  let manifest = e$1._0;
+  if (command === "Up") {
+    return await up(manifest, stack);
+  } else {
+    return await down(manifest, stack);
+  }
+}
+
+async function main() {
+  let message;
+  try {
+    message = await run();
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    console.error(`deploy-app: ` + Util_AwsError$ReventlessAws.describe(exn));
+    process.exit(1);
+    return;
+  }
+  if (message.TAG === "Ok") {
+    return;
+  }
+  console.error(`deploy-app: ` + message._0);
+  process.exit(1);
+}
+
+let Automation;
+
+let Lambda;
+
+let Ssm;
+
+let Sts;
+
+let Manifest;
+
+let requiredNodeMajor = 22;
+
+export {
+  Automation,
+  Lambda,
+  Ssm,
+  Sts,
+  Manifest,
+  defaultStack,
+  parseArgs,
+  usage,
+  projectOf,
+  projectsOf,
+  requiredNodeMajor,
+  checkNode,
+  backendNeedsPassphrase,
+  unbuilt,
+  check,
+  layerName,
+  layerDescriptionPrefix,
+  layerDescription,
+  releaseUrl,
+  installedVersion,
+  errorName,
+  storedLayerArn,
+  layerVersionDescription,
+  ensureLayer,
+  removeLayer,
+  disposableKey,
+  isDisposable,
+  existingStack,
+  newStackConfig,
+  openForUp,
+  stream,
+  failureDetail,
+  deploy,
+  outputString,
+  accountsFileName,
+  accountsFile,
+  signInLines,
+  up,
+  down,
+  run,
+  main,
+}
+/* yaml Not a pure module */