@cdktn/cli-core 0.22.0-pre.2

package/src/lib/models/deploy-machine.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAndStartDestroyService = exports.createAndStartDeployService = exports.terraformPtyService = exports.deployMachine = exports.handleLineReceived = exports.bufferUnterminatedLines = exports.extractVariableNameFromPrompt = exports.isDeployEvent = void 0;
+const xstate_1 = require("xstate");
+const commons_1 = require("@cdktn/commons");
+const errors_1 = require("../errors");
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const os_1 = require("os");
+const pty_process_1 = require("./pty-process");
+function isDeployEvent(event, type) {
+    return event.type === type;
+}
+exports.isDeployEvent = isDeployEvent;
+function extractVariableNameFromPrompt(line) {
+    const noColorLine = (0, strip_ansi_1.default)(line);
+    const lines = noColorLine.split("\n");
+    const lineWithVar = lines.find((line) => line.includes("var."));
+    if (!lineWithVar) {
+        throw commons_1.Errors.Internal(`Could not find variable name in prompt: ${line}. This is most likely a bug in cdktn. Please report it at http://cdktn.io/issues`);
+    }
+    return lineWithVar.split("var.")[1].trim();
+}
+exports.extractVariableNameFromPrompt = extractVariableNameFromPrompt;
+// used to only send completed lines (= with a newline at the end of them) to our logic (#2827)
+function bufferUnterminatedLines(handler) {
+    let buffer = "";
+    function bufferedReceiverFunction(output) {
+        buffer += output;
+        const lines = buffer.split(os_1.EOL);
+        // if the string ends with \n this will be an empty string
+        // else it will contain an "unfinished" line
+        // the fallback to an empty string is to make TS happy and should never happen
+        buffer = lines.pop() || "";
+        if (lines.length > 0)
+            handler(lines.join(os_1.EOL) + "\n");
+    }
+    bufferedReceiverFunction.getBuffer = () => buffer;
+    return bufferedReceiverFunction;
+}
+exports.bufferUnterminatedLines = bufferUnterminatedLines;
+function handleLineReceived(send) {
+    return (output) => {
+        let hideOutput = false;
+        const noColorLine = (0, strip_ansi_1.default)(output);
+        // possible events based on line
+        if (noColorLine.includes("approved using the UI or API")) {
+            send({ type: "APPROVED_EXTERNALLY" });
+        }
+        else if (noColorLine.includes("discarded using the UI or API")) {
+            send({ type: "REJECTED_EXTERNALLY" });
+        }
+        else if (noColorLine.includes("Do you want to perform these actions") ||
+            noColorLine.includes("Do you really want to destroy all resources?") ||
+            noColorLine.includes("Do you really want to destroy all resources in workspace")) {
+            hideOutput = true;
+            send({ type: "OUTPUT_RECEIVED", output });
+            send({ type: "REQUEST_APPROVAL" });
+        }
+        else if (noColorLine.includes("var.") &&
+            noColorLine.includes("Enter a value:")) {
+            hideOutput = true;
+            const variableName = extractVariableNameFromPrompt(output);
+            send({
+                type: "OUTPUT_RECEIVED",
+                output: (0, errors_1.missingVariable)(variableName),
+            });
+            send({ type: "VARIABLE_MISSING", variableName });
+        }
+        else if (noColorLine.includes("Do you want to override the soft failed policy check?")) {
+            hideOutput = true;
+            send({ type: "OUTPUT_RECEIVED", output });
+            send({ type: "REQUEST_SENTINEL_OVERRIDE" });
+        }
+        else if (noColorLine.includes("overridden using the UI or API")) {
+            send({ type: "OVERRIDDEN_EXTERNALLY" });
+        }
+        if (!hideOutput) {
+            send({
+                type: "OUTPUT_RECEIVED",
+                output,
+            });
+        }
+    };
+}
+exports.handleLineReceived = handleLineReceived;
+exports.deployMachine = (0, xstate_1.createMachine)({
+    predictableActionArguments: true,
+    context: {},
+    initial: "idle",
+    id: "root",
+    states: {
+        idle: {
+            on: {
+                START: { target: "running" },
+            },
+        },
+        running: {
+            invoke: {
+                id: "pty",
+                src: "runTerraformInPty",
+            },
+            on: {
+                EXITED: "exited",
+                STOP: "stopped",
+            },
+            initial: "processing",
+            states: {
+                // TODO: what else might TF CLI be asking? Can we detect any question from the TF CLI to show a good error?
+                processing: {
+                    on: {
+                        REQUEST_APPROVAL: "awaiting_approval",
+                        REQUEST_SENTINEL_OVERRIDE: "awaiting_sentinel_override",
+                        VARIABLE_MISSING: {
+                            actions: (0, xstate_1.send)({ type: "EXITED", exitCode: 1 }),
+                        },
+                    },
+                },
+                awaiting_approval: {
+                    on: {
+                        APPROVED_EXTERNALLY: "processing",
+                        REJECTED_EXTERNALLY: {
+                            target: "#root.exited",
+                            actions: (0, xstate_1.assign)({ cancelled: true }),
+                        },
+                        APPROVE: {
+                            target: "processing",
+                            actions: (0, xstate_1.send)({ type: "SEND_LINE", input: "yes" }, { to: "pty" }),
+                        },
+                        REJECT: {
+                            target: "processing",
+                            actions: [
+                                (0, xstate_1.send)({ type: "SEND_LINE", input: "no" }, { to: "pty" }),
+                                (0, xstate_1.assign)({
+                                    cancelled: true,
+                                }),
+                            ],
+                        },
+                    },
+                },
+                awaiting_sentinel_override: {
+                    on: {
+                        OVERRIDDEN_EXTERNALLY: "processing",
+                        OVERRIDE_REJECTED_EXTERNALLY: {
+                            target: "#root.exited",
+                            actions: (0, xstate_1.assign)({ cancelled: true }),
+                        },
+                        // This is a bit of a hack, because the external discard message
+                        // posted by Terraform UI is the same as during apply. So, we capture that
+                        // and emit our own event to make it more specific.
+                        REJECTED_EXTERNALLY: {
+                            actions: (0, xstate_1.send)({ type: "OVERRIDE_REJECTED_EXTERNALLY" }),
+                        },
+                        OVERRIDE: {
+                            target: "processing",
+                            actions: (0, xstate_1.send)({ type: "SEND_LINE", input: "override" }, { to: "pty" }),
+                        },
+                        REJECT_OVERRIDE: {
+                            target: "processing",
+                            actions: [
+                                (0, xstate_1.send)({ type: "SEND_LINE", input: "no" }, { to: "pty" }),
+                                (0, xstate_1.assign)({
+                                    cancelled: true,
+                                }),
+                            ],
+                        },
+                    },
+                },
+            },
+        },
+        exited: { type: "final" },
+        stopped: { type: "final" },
+    },
+}, {
+    services: {
+        runTerraformInPty: (context, event) => terraformPtyService(context, event, pty_process_1.spawnPty),
+    },
+});
+function terraformPtyService(_context, event, spawn = pty_process_1.spawnPty) {
+    return (send, onReceive) => {
+        if (event.type !== "START") {
+            throw commons_1.Errors.Internal(`Terraform CLI invocation state machine: Unexpected event caused transition to the running state: ${event.type}`);
+        }
+        // Communication from the pty to the caller
+        const receiver = bufferUnterminatedLines(handleLineReceived(send));
+        const { exitCode, actions } = spawn(event.pty, (data) => {
+            receiver(data);
+        });
+        // Communication from the caller to the pty
+        onReceive((event) => {
+            if (event.type === "SEND_LINE") {
+                actions.writeLine(event.input);
+            }
+        });
+        exitCode.then((exitCode) => {
+            const lastBuffer = receiver.getBuffer();
+            if (lastBuffer.length > 0) {
+                commons_1.logger.debug(`Terraform CLI exited but the last outputted line was not terminated with a newline and hence is still in the buffer and wasn't printed: "${lastBuffer}"`);
+            }
+            send({ type: "EXITED", exitCode });
+        });
+        return () => {
+            commons_1.logger.trace("Terraform CLI state machine: cleaning up pty");
+            actions.stop();
+        };
+    };
+}
+exports.terraformPtyService = terraformPtyService;
+function createAndStartDeployService(options) {
+    var _a, _b;
+    const service = (0, xstate_1.interpret)(exports.deployMachine);
+    const args = [
+        "apply",
+        ...(options.autoApprove ? ["-auto-approve"] : []),
+        // "-input=false", we can't use this anymore but TODO: we need to detect TF CLI asking for missing inputs and either allow passing them or stop there and fail
+        ...options.extraOptions,
+        ...(options.refreshOnly ? ["-refresh-only"] : []),
+        ...(options.noColor ? ["-no-color"] : []),
+        ...(options.parallelism > -1
+            ? [`-parallelism=${options.parallelism}`]
+            : []),
+    ];
+    (_a = options.vars) === null || _a === void 0 ? void 0 : _a.forEach((v) => {
+        args.push(`-var=${v}`);
+    });
+    (_b = options.varFiles) === null || _b === void 0 ? void 0 : _b.forEach((v) => {
+        args.push(`-var-file=${v}`);
+    });
+    commons_1.logger.debug(`Executing ${options.terraformBinaryName} ${args.join(" ")} in ${options.workdir}`);
+    const config = {
+        file: options.terraformBinaryName,
+        args,
+        options: {
+            cwd: options.workdir,
+            env: process.env, // TODO: make this explicit and move to caller or whatever
+        },
+    };
+    service.send({ type: "START", pty: config });
+    return service;
+}
+exports.createAndStartDeployService = createAndStartDeployService;
+function createAndStartDestroyService(options) {
+    var _a, _b;
+    const service = (0, xstate_1.interpret)(exports.deployMachine);
+    const args = [
+        "destroy",
+        ...(options.autoApprove ? ["-auto-approve"] : []),
+        // "-input=false", we can't use this anymore but TODO: we need to detect TF CLI asking for missing inputs and either allow passing them or stop there and fail
+        ...options.extraOptions,
+        ...(options.noColor ? ["-no-color"] : []),
+        ...(options.parallelism > -1
+            ? [`-parallelism=${options.parallelism}`]
+            : []),
+    ];
+    (_a = options.vars) === null || _a === void 0 ? void 0 : _a.forEach((v) => {
+        args.push(`-var=${v}`);
+    });
+    (_b = options.varFiles) === null || _b === void 0 ? void 0 : _b.forEach((v) => {
+        args.push(`-var-file=${v}`);
+    });
+    commons_1.logger.debug(`Executing ${options.terraformBinaryName} ${args.join(" ")} in ${options.workdir}`);
+    const config = {
+        file: options.terraformBinaryName,
+        args,
+        options: {
+            cwd: options.workdir,
+            env: process.env, // TODO: make this explicit and move to caller or whatever
+        },
+    };
+    service.send({ type: "START", pty: config });
+    return service;
+}
+exports.createAndStartDestroyService = createAndStartDestroyService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploy-machine.js","sourceRoot":"","sources":["deploy-machine.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (c) HashiCorp, Inc.\n * SPDX-License-Identifier: MPL-2.0\n */\n\nimport {\n  createMachine,\n  send,\n  interpret,\n  EventObject,\n  assign,\n  Sender,\n  Receiver,\n} from \"xstate\";\nimport * as pty from \"@cdktf/node-pty-prebuilt-multiarch\";\nimport { Errors, logger } from \"@cdktn/commons\";\nimport { missingVariable } from \"../errors\";\nimport stripAnsi from \"strip-ansi\";\nimport { EOL } from \"os\";\nimport { spawnPty } from \"./pty-process\";\n\ninterface PtySpawnConfig {\n  file: Parameters<typeof pty.spawn>[0];\n  args: Parameters<typeof pty.spawn>[1];\n  options: Parameters<typeof pty.spawn>[2] & { cwd: string };\n}\n\ninterface DeployContext {\n  exitCode?: number;\n  /**\n   * Terraform will exit with 1 if it was cancelled, but we don't want to fail in that case\n   */\n  cancelled?: boolean;\n}\n\nexport type DeployEvent =\n  | { type: \"START\"; pty: PtySpawnConfig }\n  | { type: \"STOP\" }\n  | { type: \"SEND_LINE\"; input: string }\n  | { type: \"OUTPUT_RECEIVED\"; output: string }\n  | { type: \"APPROVED_EXTERNALLY\" } // e.g. via TFC UI or API\n  | { type: \"REJECTED_EXTERNALLY\" }\n  | { type: \"OVERRIDDEN_EXTERNALLY\" }\n  | { type: \"OVERRIDE_REJECTED_EXTERNALLY\" }\n  | { type: \"OVERRIDE\" }\n  | { type: \"REJECT_OVERRIDE\" }\n  | { type: \"REQUEST_APPROVAL\" }\n  | { type: \"VARIABLE_MISSING\"; variableName: string }\n  | { type: \"REQUEST_SENTINEL_OVERRIDE\" }\n  | { type: \"APPROVE\" }\n  | { type: \"REJECT\" }\n  | { type: \"EXITED\"; exitCode: number };\n\nexport function isDeployEvent<DeployEventType extends DeployEvent[\"type\"]>(\n  event: EventObject,\n  type: DeployEventType,\n): event is DeployEvent & { type: DeployEventType } {\n  return event.type === type;\n}\n\nexport type DeployState =\n  | {\n      value: \"idle\";\n      context: DeployContext;\n    }\n  | {\n      value: \"running\";\n      context: DeployContext;\n    }\n  | {\n      value: { running: \"processing\" };\n      context: DeployContext;\n    }\n  | {\n      value: { running: \"awaiting_approval\" };\n      context: DeployContext;\n    }\n  | {\n      value: { running: \"awaiting_sentinel_override\" };\n      context: DeployContext;\n    }\n  | {\n      value: \"exited\";\n      context: DeployContext & { exitCode: number };\n    }\n  | {\n      value: \"stopped\";\n      context: DeployContext;\n    };\n\nexport function extractVariableNameFromPrompt(line: string) {\n  const noColorLine = stripAnsi(line);\n  const lines = noColorLine.split(\"\\n\");\n  const lineWithVar = lines.find((line) => line.includes(\"var.\"));\n  if (!lineWithVar) {\n    throw Errors.Internal(\n      `Could not find variable name in prompt: ${line}. This is most likely a bug in cdktn. Please report it at http://cdktn.io/issues`,\n    );\n  }\n  return lineWithVar.split(\"var.\")[1].trim();\n}\n\ninterface BufferedReceiverFunction {\n  (output: string): void;\n  /**\n   * used to get the last buffer when the PTY exits to log a debug message if there's output left in there\n   * (might help debugging on Windows if EOL from Nodejs doesn't work in WSL)\n   */\n  getBuffer: () => string;\n}\n\n// used to only send completed lines (= with a newline at the end of them) to our logic (#2827)\nexport function bufferUnterminatedLines(\n  handler: (output: string) => void,\n): BufferedReceiverFunction {\n  let buffer = \"\";\n  function bufferedReceiverFunction(output: string) {\n    buffer += output;\n    const lines = buffer.split(EOL);\n\n    // if the string ends with \\n this will be an empty string\n    // else it will contain an \"unfinished\" line\n    // the fallback to an empty string is to make TS happy and should never happen\n    buffer = lines.pop() || \"\";\n\n    if (lines.length > 0) handler(lines.join(EOL) + \"\\n\");\n  }\n  bufferedReceiverFunction.getBuffer = () => buffer;\n\n  return bufferedReceiverFunction;\n}\n\nexport function handleLineReceived(send: (event: DeployEvent) => void) {\n  return (output: string) => {\n    let hideOutput = false;\n    const noColorLine = stripAnsi(output);\n\n    // possible events based on line\n    if (noColorLine.includes(\"approved using the UI or API\")) {\n      send({ type: \"APPROVED_EXTERNALLY\" });\n    } else if (noColorLine.includes(\"discarded using the UI or API\")) {\n      send({ type: \"REJECTED_EXTERNALLY\" });\n    } else if (\n      noColorLine.includes(\"Do you want to perform these actions\") ||\n      noColorLine.includes(\"Do you really want to destroy all resources?\") ||\n      noColorLine.includes(\n        \"Do you really want to destroy all resources in workspace\",\n      )\n    ) {\n      hideOutput = true;\n      send({ type: \"OUTPUT_RECEIVED\", output });\n      send({ type: \"REQUEST_APPROVAL\" });\n    } else if (\n      noColorLine.includes(\"var.\") &&\n      noColorLine.includes(\"Enter a value:\")\n    ) {\n      hideOutput = true;\n\n      const variableName = extractVariableNameFromPrompt(output);\n      send({\n        type: \"OUTPUT_RECEIVED\",\n        output: missingVariable(variableName),\n      });\n      send({ type: \"VARIABLE_MISSING\", variableName });\n    } else if (\n      noColorLine.includes(\n        \"Do you want to override the soft failed policy check?\",\n      )\n    ) {\n      hideOutput = true;\n      send({ type: \"OUTPUT_RECEIVED\", output });\n\n      send({ type: \"REQUEST_SENTINEL_OVERRIDE\" });\n    } else if (noColorLine.includes(\"overridden using the UI or API\")) {\n      send({ type: \"OVERRIDDEN_EXTERNALLY\" });\n    }\n\n    if (!hideOutput) {\n      send({\n        type: \"OUTPUT_RECEIVED\",\n        output,\n      });\n    }\n  };\n}\n\nexport const deployMachine = createMachine<\n  DeployContext,\n  DeployEvent,\n  DeployState\n>(\n  {\n    predictableActionArguments: true,\n    context: {},\n    initial: \"idle\",\n    id: \"root\",\n    states: {\n      idle: {\n        on: {\n          START: { target: \"running\" },\n        },\n      },\n      running: {\n        invoke: {\n          id: \"pty\",\n          src: \"runTerraformInPty\",\n        },\n        on: {\n          EXITED: \"exited\",\n          STOP: \"stopped\",\n        },\n        initial: \"processing\",\n        states: {\n          // TODO: what else might TF CLI be asking? Can we detect any question from the TF CLI to show a good error?\n          processing: {\n            on: {\n              REQUEST_APPROVAL: \"awaiting_approval\",\n              REQUEST_SENTINEL_OVERRIDE: \"awaiting_sentinel_override\",\n              VARIABLE_MISSING: {\n                actions: send({ type: \"EXITED\", exitCode: 1 }),\n              },\n            },\n          },\n          awaiting_approval: {\n            on: {\n              APPROVED_EXTERNALLY: \"processing\",\n              REJECTED_EXTERNALLY: {\n                target: \"#root.exited\",\n                actions: assign<\n                  DeployContext,\n                  DeployEvent & { type: \"REJECTED_EXTERNALLY\" }\n                >({ cancelled: true }),\n              },\n              APPROVE: {\n                target: \"processing\",\n                actions: send(\n                  { type: \"SEND_LINE\", input: \"yes\" },\n                  { to: \"pty\" },\n                ),\n              },\n              REJECT: {\n                target: \"processing\",\n                actions: [\n                  send({ type: \"SEND_LINE\", input: \"no\" }, { to: \"pty\" }),\n                  assign<DeployContext, DeployEvent & { type: \"REJECT\" }>({\n                    cancelled: true,\n                  }),\n                ],\n              },\n            },\n          },\n          awaiting_sentinel_override: {\n            on: {\n              OVERRIDDEN_EXTERNALLY: \"processing\",\n              OVERRIDE_REJECTED_EXTERNALLY: {\n                target: \"#root.exited\",\n                actions: assign<\n                  DeployContext,\n                  DeployEvent & { type: \"OVERRIDE_REJECTED_EXTERNALLY\" }\n                >({ cancelled: true }),\n              },\n              // This is a bit of a hack, because the external discard message\n              // posted by Terraform UI is the same as during apply. So, we capture that\n              // and emit our own event to make it more specific.\n              REJECTED_EXTERNALLY: {\n                actions: send({ type: \"OVERRIDE_REJECTED_EXTERNALLY\" }),\n              },\n              OVERRIDE: {\n                target: \"processing\",\n                actions: send(\n                  { type: \"SEND_LINE\", input: \"override\" },\n                  { to: \"pty\" },\n                ),\n              },\n              REJECT_OVERRIDE: {\n                target: \"processing\",\n                actions: [\n                  send({ type: \"SEND_LINE\", input: \"no\" }, { to: \"pty\" }),\n                  assign<\n                    DeployContext,\n                    DeployEvent & { type: \"REJECT_OVERRIDE\" }\n                  >({\n                    cancelled: true,\n                  }),\n                ],\n              },\n            },\n          },\n        },\n      },\n      exited: { type: \"final\" },\n      stopped: { type: \"final\" },\n    },\n  },\n  {\n    services: {\n      runTerraformInPty: (context, event) =>\n        terraformPtyService(context, event, spawnPty),\n    },\n  },\n);\n\nexport function terraformPtyService(\n  _context: DeployContext,\n  event: DeployEvent,\n  spawn = spawnPty,\n): (send: Sender<DeployEvent>, onReceive: Receiver<DeployEvent>) => void {\n  return (send: Sender<DeployEvent>, onReceive: Receiver<DeployEvent>) => {\n    if (event.type !== \"START\") {\n      throw Errors.Internal(\n        `Terraform CLI invocation state machine: Unexpected event caused transition to the running state: ${event.type}`,\n      );\n    }\n\n    // Communication from the pty to the caller\n    const receiver = bufferUnterminatedLines(handleLineReceived(send));\n    const { exitCode, actions } = spawn(event.pty, (data) => {\n      receiver(data);\n    });\n\n    // Communication from the caller to the pty\n    onReceive((event: DeployEvent) => {\n      if (event.type === \"SEND_LINE\") {\n        actions.writeLine(event.input);\n      }\n    });\n\n    exitCode.then((exitCode) => {\n      const lastBuffer = receiver.getBuffer();\n      if (lastBuffer.length > 0) {\n        logger.debug(\n          `Terraform CLI exited but the last outputted line was not terminated with a newline and hence is still in the buffer and wasn't printed: \"${lastBuffer}\"`,\n        );\n      }\n\n      send({ type: \"EXITED\", exitCode });\n    });\n\n    return () => {\n      logger.trace(\"Terraform CLI state machine: cleaning up pty\");\n      actions.stop();\n    };\n  };\n}\n\nexport function createAndStartDeployService(options: {\n  refreshOnly?: boolean;\n  parallelism: number;\n  extraOptions: string[];\n  terraformBinaryName: string;\n  autoApprove?: boolean;\n  noColor?: boolean;\n  workdir: string;\n  vars?: string[];\n  varFiles?: string[];\n}) {\n  const service = interpret(deployMachine);\n  const args = [\n    \"apply\",\n    ...(options.autoApprove ? [\"-auto-approve\"] : []),\n    // \"-input=false\", we can't use this anymore but TODO: we need to detect TF CLI asking for missing inputs and either allow passing them or stop there and fail\n\n    ...options.extraOptions,\n    ...(options.refreshOnly ? [\"-refresh-only\"] : []),\n    ...(options.noColor ? [\"-no-color\"] : []),\n    ...(options.parallelism > -1\n      ? [`-parallelism=${options.parallelism}`]\n      : []),\n  ];\n\n  options.vars?.forEach((v) => {\n    args.push(`-var=${v}`);\n  });\n\n  options.varFiles?.forEach((v) => {\n    args.push(`-var-file=${v}`);\n  });\n\n  logger.debug(\n    `Executing ${options.terraformBinaryName} ${args.join(\" \")} in ${\n      options.workdir\n    }`,\n  );\n\n  const config: PtySpawnConfig = {\n    file: options.terraformBinaryName,\n    args,\n    options: {\n      cwd: options.workdir,\n      env: process.env as { [key: string]: string }, // TODO: make this explicit and move to caller or whatever\n    },\n  };\n\n  service.send({ type: \"START\", pty: config });\n\n  return service;\n}\n\nexport function createAndStartDestroyService(options: {\n  parallelism: number;\n  extraOptions: string[];\n  terraformBinaryName: string;\n  autoApprove?: boolean;\n  noColor?: boolean;\n  workdir: string;\n  vars?: string[];\n  varFiles?: string[];\n}) {\n  const service = interpret(deployMachine);\n\n  const args = [\n    \"destroy\",\n    ...(options.autoApprove ? [\"-auto-approve\"] : []),\n    // \"-input=false\", we can't use this anymore but TODO: we need to detect TF CLI asking for missing inputs and either allow passing them or stop there and fail\n\n    ...options.extraOptions,\n    ...(options.noColor ? [\"-no-color\"] : []),\n    ...(options.parallelism > -1\n      ? [`-parallelism=${options.parallelism}`]\n      : []),\n  ];\n\n  options.vars?.forEach((v) => {\n    args.push(`-var=${v}`);\n  });\n\n  options.varFiles?.forEach((v) => {\n    args.push(`-var-file=${v}`);\n  });\n\n  logger.debug(\n    `Executing ${options.terraformBinaryName} ${args.join(\" \")} in ${\n      options.workdir\n    }`,\n  );\n\n  const config: PtySpawnConfig = {\n    file: options.terraformBinaryName,\n    args,\n    options: {\n      cwd: options.workdir,\n      env: process.env as { [key: string]: string }, // TODO: make this explicit and move to caller or whatever\n    },\n  };\n\n  service.send({ type: \"START\", pty: config });\n\n  return service;\n}\n"]}

package/src/lib/models/pty-process.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import * as pty from "@cdktf/node-pty-prebuilt-multiarch";
+interface PtySpawnConfig {
+    file: Parameters<typeof pty.spawn>[0];
+    args: Parameters<typeof pty.spawn>[1];
+    options: Parameters<typeof pty.spawn>[2] & {
+        cwd: string;
+    };
+}
+export interface PtyProcessActions {
+    write: (response: string) => void;
+    writeLine: (response: string) => void;
+    stop: () => void;
+}
+export interface PtyProcess {
+    exitCode: Promise<number>;
+    actions: PtyProcessActions;
+}
+/**
+ * A wrapper around node-pty that handles the platform specific differences
+ * and provide an intuitive API for bidirectional communication with the
+ * spawned process.
+ */
+export declare function spawnPty(config: PtySpawnConfig, onData: (data: string) => void): PtyProcess;
+export {};
+//# sourceMappingURL=pty-process.d.ts.map

package/src/lib/models/pty-process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pty-process.d.ts","sourceRoot":"","sources":["pty-process.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAG1D,UAAU,cAAc;IACtB,IAAI,EAAE,UAAU,CAAC,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACtC,IAAI,EAAE,UAAU,CAAC,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACtC,OAAO,EAAE,UAAU,CAAC,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5D;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IAEzB,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1B,OAAO,EAAE,iBAAiB,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC7B,UAAU,CA0DZ"}

package/src/lib/models/pty-process.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnPty = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const pty = __importStar(require("@cdktf/node-pty-prebuilt-multiarch"));
+const commons_1 = require("@cdktn/commons");
+/**
+ * A wrapper around node-pty that handles the platform specific differences
+ * and provide an intuitive API for bidirectional communication with the
+ * spawned process.
+ */
+function spawnPty(config, onData) {
+    const { args, options } = config;
+    const file = os.platform() === "win32"
+        ? findExecutable(config.file, options.cwd, options)
+        : config.file;
+    commons_1.logger.trace(`Spawning pty with file=${file}, args=${Array.isArray(args) ? `[${args.join(", ")}]` : `"${args}"`}, options=${JSON.stringify(options)}`);
+    const p = pty.spawn(file, args, options);
+    const actions = {
+        write: (response) => {
+            commons_1.logger.trace(`Sending response to pty (file=${file}, args=${Array.isArray(args) ? `[${args.join(", ")}]` : `"${args}"`}): ${response}`);
+            p.write(response);
+        },
+        writeLine: (response) => {
+            commons_1.logger.trace(`Sending response (with newline) to pty (file=${file}, args=${Array.isArray(args) ? `[${args.join(", ")}]` : `"${args}"`}): ${response}`);
+            p.write(`${response}${os.EOL}`);
+        },
+        stop: () => {
+            commons_1.logger.trace(`Aborting pty (file=${file}, args=${Array.isArray(args) ? `[${args.join(", ")}]` : `"${args}"`})`);
+            p.write("\x03"); // CTRL + C, pty.kill() does not work on windows
+        },
+    };
+    p.onData((data) => onData(data));
+    const exitCode = new Promise((resolve) => {
+        p.onExit(({ exitCode }) => {
+            if (exitCode !== 0) {
+                commons_1.logger.debug(`Pty (file=${file}, args=${Array.isArray(args) ? `[${args.join(", ")}]` : `"${args}"`}) exited with code ${exitCode}`);
+            }
+            resolve(exitCode);
+        });
+    });
+    return { exitCode, actions };
+}
+exports.spawnPty = spawnPty;
+// src: https://github.com/Microsoft/vscode/blob/c0c9ea27d6e8d660d8716d7acee82cf3c00fa3e5/src/vs/workbench/parts/tasks/electron-browser/terminalTaskSystem.ts#L691
+// TODO: properly annotate source of this function
+function findExecutable(command, cwd, options) {
+    // If we have an absolute path then we take it.
+    if (path.isAbsolute(command)) {
+        return command;
+    }
+    const dir = path.dirname(command);
+    if (dir !== ".") {
+        // We have a directory and the directory is relative (see above). Make the path absolute
+        // to the current working directory.
+        return path.join(cwd, command);
+    }
+    let paths = undefined;
+    // The options can override the PATH. So consider that PATH if present.
+    if (options && options.env) {
+        // Path can be named in many different ways and for the execution it doesn't matter
+        for (const key of Object.keys(options.env)) {
+            if (key.toLowerCase() === "path") {
+                if (typeof options.env[key] === "string") {
+                    paths = options.env[key].split(path.delimiter);
+                }
+                break;
+            }
+        }
+    }
+    if (paths === void 0 && typeof process.env.PATH === "string") {
+        paths = process.env.PATH.split(path.delimiter);
+    }
+    // No PATH environment. Make path absolute to the cwd.
+    if (paths === void 0 || paths.length === 0) {
+        return path.join(cwd, command);
+    }
+    // We have a simple file name. We get the path variable from the env
+    // and try to find the executable on the path.
+    for (const pathEntry of paths) {
+        // The path entry is absolute.
+        let fullPath;
+        if (path.isAbsolute(pathEntry)) {
+            fullPath = path.join(pathEntry, command);
+        }
+        else {
+            fullPath = path.join(cwd, pathEntry, command);
+        }
+        if (fs.existsSync(fullPath)) {
+            return fullPath;
+        }
+        let withExtension = fullPath + ".com";
+        if (fs.existsSync(withExtension)) {
+            return withExtension;
+        }
+        withExtension = fullPath + ".exe";
+        if (fs.existsSync(withExtension)) {
+            return withExtension;
+        }
+    }
+    return path.join(cwd, command);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pty-process.js","sourceRoot":"","sources":["pty-process.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (c) HashiCorp, Inc.\n * SPDX-License-Identifier: MPL-2.0\n */\n\nimport * as os from \"os\";\nimport * as path from \"path\";\nimport * as fs from \"fs\";\n\nimport * as pty from \"@cdktf/node-pty-prebuilt-multiarch\";\nimport { logger } from \"@cdktn/commons\";\n\ninterface PtySpawnConfig {\n  file: Parameters<typeof pty.spawn>[0];\n  args: Parameters<typeof pty.spawn>[1];\n  options: Parameters<typeof pty.spawn>[2] & { cwd: string };\n}\n\nexport interface PtyProcessActions {\n  write: (response: string) => void;\n  writeLine: (response: string) => void;\n  stop: () => void;\n}\n\nexport interface PtyProcess {\n  // Always resolves, returns the exit code of the process\n  exitCode: Promise<number>;\n  actions: PtyProcessActions;\n}\n\n/**\n * A wrapper around node-pty that handles the platform specific differences\n * and provide an intuitive API for bidirectional communication with the\n * spawned process.\n */\nexport function spawnPty(\n  config: PtySpawnConfig,\n  onData: (data: string) => void,\n): PtyProcess {\n  const { args, options } = config;\n  const file =\n    os.platform() === \"win32\"\n      ? findExecutable(config.file, options.cwd, options)\n      : config.file;\n\n  logger.trace(\n    `Spawning pty with file=${file}, args=${\n      Array.isArray(args) ? `[${args.join(\", \")}]` : `\"${args}\"`\n    }, options=${JSON.stringify(options)}`,\n  );\n\n  const p = pty.spawn(file, args, options);\n\n  const actions: PtyProcessActions = {\n    write: (response: string) => {\n      logger.trace(\n        `Sending response to pty (file=${file}, args=${\n          Array.isArray(args) ? `[${args.join(\", \")}]` : `\"${args}\"`\n        }): ${response}`,\n      );\n      p.write(response);\n    },\n    writeLine: (response: string) => {\n      logger.trace(\n        `Sending response (with newline) to pty (file=${file}, args=${\n          Array.isArray(args) ? `[${args.join(\", \")}]` : `\"${args}\"`\n        }): ${response}`,\n      );\n      p.write(`${response}${os.EOL}`);\n    },\n    stop: () => {\n      logger.trace(\n        `Aborting pty (file=${file}, args=${\n          Array.isArray(args) ? `[${args.join(\", \")}]` : `\"${args}\"`\n        })`,\n      );\n      p.write(\"\\x03\"); // CTRL + C, pty.kill() does not work on windows\n    },\n  };\n\n  p.onData((data) => onData(data));\n\n  const exitCode = new Promise<number>((resolve) => {\n    p.onExit(({ exitCode }) => {\n      if (exitCode !== 0) {\n        logger.debug(\n          `Pty (file=${file}, args=${\n            Array.isArray(args) ? `[${args.join(\", \")}]` : `\"${args}\"`\n          }) exited with code ${exitCode}`,\n        );\n      }\n      resolve(exitCode);\n    });\n  });\n\n  return { exitCode, actions };\n}\n\n// src: https://github.com/Microsoft/vscode/blob/c0c9ea27d6e8d660d8716d7acee82cf3c00fa3e5/src/vs/workbench/parts/tasks/electron-browser/terminalTaskSystem.ts#L691\n// TODO: properly annotate source of this function\nfunction findExecutable(\n  command: string,\n  cwd: string,\n  options: { env?: { [key: string]: string } },\n): string {\n  // If we have an absolute path then we take it.\n  if (path.isAbsolute(command)) {\n    return command;\n  }\n  const dir = path.dirname(command);\n  if (dir !== \".\") {\n    // We have a directory and the directory is relative (see above). Make the path absolute\n    // to the current working directory.\n    return path.join(cwd, command);\n  }\n  let paths: string[] | undefined = undefined;\n  // The options can override the PATH. So consider that PATH if present.\n  if (options && options.env) {\n    // Path can be named in many different ways and for the execution it doesn't matter\n    for (const key of Object.keys(options.env)) {\n      if (key.toLowerCase() === \"path\") {\n        if (typeof options.env[key] === \"string\") {\n          paths = options.env[key].split(path.delimiter);\n        }\n        break;\n      }\n    }\n  }\n  if (paths === void 0 && typeof process.env.PATH === \"string\") {\n    paths = process.env.PATH.split(path.delimiter);\n  }\n  // No PATH environment. Make path absolute to the cwd.\n  if (paths === void 0 || paths.length === 0) {\n    return path.join(cwd, command);\n  }\n  // We have a simple file name. We get the path variable from the env\n  // and try to find the executable on the path.\n  for (const pathEntry of paths) {\n    // The path entry is absolute.\n    let fullPath: string;\n    if (path.isAbsolute(pathEntry)) {\n      fullPath = path.join(pathEntry, command);\n    } else {\n      fullPath = path.join(cwd, pathEntry, command);\n    }\n    if (fs.existsSync(fullPath)) {\n      return fullPath;\n    }\n    let withExtension = fullPath + \".com\";\n    if (fs.existsSync(withExtension)) {\n      return withExtension;\n    }\n    withExtension = fullPath + \".exe\";\n    if (fs.existsSync(withExtension)) {\n      return withExtension;\n    }\n  }\n  return path.join(cwd, command);\n}\n"]}