projen 0.100.7 → 0.101.0

package/lib/run-task.cjs

@@ -1733,7 +1733,7 @@ var require_package = __commonJS({
       publishConfig: {
         access: "public"
       },
-      version: "0.100.7",
+      version: "0.101.0",
       jest: {
         coverageProvider: "v8",
         coverageReporters: [
@@ -14295,7 +14295,7 @@ function createPath(path62) {
 
 // src/common.ts
 var PROJEN_DIR = ".projen";
-var TASKS_MANIFEST_VERSION = 2;
+var TASKS_MANIFEST_VERSION = 3;
 var IS_TEST_RUN = process.env.NODE_ENV === "test";
 var packageVersion = require_package().version;
 
@@ -14408,71 +14408,23 @@ function shimTool(file) {
 }
 var npm = shimTool("npm");
 var npx = shimTool("npx");
-var rawShell = {
-  /**
-   * Runs a command line through the system shell and returns a normalized
-   * result. Never throws for a non-zero exit (that is reported via `status`);
-   * a spawn failure is reported via `error`.
-   *
-   * The caller is responsible for supplying the full `env`.
-   */
-  exec(command, options) {
-    debug(`${command} (cwd: ${options.cwd})`);
-    const result = child_process.spawnSync(command, {
-      cwd: options.cwd,
-      shell: true,
-      maxBuffer: MAX_BUFFER,
-      env: options.env,
-      // "pipe" for STDERR (when capturing) means it appears in exceptions.
-      stdio: options.capture ? ["inherit", "pipe", "pipe"] : "inherit"
-    });
-    return {
-      status: result.status,
-      stdout: result.stdout ?? null,
-      stderr: result.stderr ?? null,
-      error: result.error
-    };
-  },
-  /**
-   * Runs a user-supplied shell command line and resolves its trimmed STDOUT.
-   * Rejects if the command exits non-zero.
-   */
-  capture: async (command, options) => {
-    const result = rawShell.exec(command, {
-      cwd: options.cwd,
-      env: { ...process.env, ...options.env },
-      capture: true
-    });
-    if (result.error) {
-      throw result.error;
-    }
-    if (result.status !== 0) {
-      const error = new Error(
-        `Command failed (exit code ${result.status}): ${command}`
-      );
-      error.status = result.status;
-      error.stderr = result.stderr;
-      throw error;
-    }
-    return (result.stdout?.toString("utf-8") ?? "").trim();
-  },
-  /**
-   * Runs a user-supplied shell command line and resolves its trimmed STDOUT,
-   * or `undefined` if the command failed or produced no output.
-   */
-  tryCapture: async (command, options) => {
-    const result = rawShell.exec(command, {
-      cwd: options.cwd,
-      env: { ...process.env, ...options.env },
-      capture: true
-    });
-    if (result.error || result.status !== 0) {
-      return void 0;
-    }
-    const out = (result.stdout?.toString("utf-8") ?? "").trim();
-    return out || void 0;
-  }
-};
+function systemShell(command, options) {
+  debug(`${command} (cwd: ${options.cwd})`);
+  const result = child_process.spawnSync(command, {
+    cwd: options.cwd,
+    shell: true,
+    maxBuffer: MAX_BUFFER,
+    env: options.env,
+    // "pipe" for STDERR (when capturing) means it appears in exceptions.
+    stdio: options.capture ? ["inherit", "pipe", "pipe"] : "inherit"
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout ?? null,
+    stderr: result.stderr ?? null,
+    error: result.error
+  };
+}
 
 // src/cli/task-runtime.ts
 var parseConflictJSONModule = require_lib2();
@@ -14480,6 +14432,9 @@ var parseConflictJSON = parseConflictJSONModule?.default ?? parseConflictJSONMod
 var ENV_TRIM_LEN = 20;
 var ARGS_MARKER = "$@";
 var QUOTED_ARGS_MARKER = `"${ARGS_MARKER}"`;
+function quoteArg(arg) {
+  return '"' + arg.replace(/(["$`\\])/g, "\\$1") + '"';
+}
 var TaskRuntime = class _TaskRuntime {
   /**
    * The project-relative path of the tasks manifest file.
@@ -14636,7 +14591,11 @@ var RunTask = class {
       this.logDebug((0, import_chalk2.gray)("No actions have been specified for this task."));
       return;
     }
-    this.env = await this.resolveEnvironment(this.envParam, parents);
+    this.env = await this.resolveEnvironment(
+      this.envParam,
+      parents,
+      this.resolveShell()
+    );
     const envlogs = [];
     for (const [k, v] of Object.entries(this.env)) {
       const vv = v ?? "";
@@ -14646,7 +14605,7 @@ var RunTask = class {
     if (envlogs.length) {
       this.logDebug((0, import_chalk2.gray)(`${(0, import_chalk2.underline)("env")}: ${envlogs.join(" ")}`));
     }
-    if (!await this.evalCondition(task)) {
+    if (!await this.evalCondition(task, this.resolveShell())) {
       this.log("condition exited with non-zero - skipping");
       return;
     }
@@ -14663,7 +14622,8 @@ var RunTask = class {
       );
     }
     for (const step of task.steps) {
-      if (!await this.evalCondition(step)) {
+      const stepShell = this.resolveShell(step);
+      if (!await this.evalCondition(step, stepShell)) {
         this.log("condition exited with non-zero - skipping");
         continue;
       }
@@ -14683,7 +14643,7 @@ var RunTask = class {
         );
       }
       const execs = step.exec ? [step.exec] : [];
-      const env = await this.evalEnvironment(step.env ?? {});
+      const env = await this.evalEnvironment(step.env ?? {}, stepShell);
       if (step.builtin) {
         execs.push(this.renderBuiltin(step.builtin));
       }
@@ -14704,13 +14664,12 @@ var RunTask = class {
         execs.push(argv);
       }
       for (const exec of execs) {
-        let hasError = false;
         let command = exec;
         if (typeof command === "string") {
           if (command.includes(QUOTED_ARGS_MARKER)) {
             command = command.replace(
               QUOTED_ARGS_MARKER,
-              argsList.map((arg) => `'${arg}'`).join(" ")
+              argsList.map(quoteArg).join(" ")
             );
           } else if (command.includes(ARGS_MARKER)) {
             command = command.replace(ARGS_MARKER, argsList.join(" "));
@@ -14719,20 +14678,13 @@ var RunTask = class {
           }
         }
         const cwd2 = step.cwd;
-        try {
-          const result = await this.shell({
-            command,
-            cwd: cwd2,
-            extraEnv: env
-          });
-          hasError = result.status !== 0;
-        } catch (e) {
-          if (e?.message?.startsWith("non-zero exit code:")) {
-            hasError = true;
-          }
-          throw e;
-        }
-        if (hasError) {
+        const result = await this.shell({
+          command,
+          cwd: cwd2,
+          extraEnv: env,
+          shell: stepShell
+        });
+        if (result.status !== 0) {
           throw new Error(
             `Task "${this.fullname}" failed when executing "${Array.isArray(command) ? command.join(" ") : command}" (cwd: ${(0, import_path.resolve)(cwd2 ?? this.workdir)})`
           );
@@ -14747,15 +14699,15 @@ var RunTask = class {
    * evaluates to false (exits with non-zero), indicating that the task should
    * be skipped.
    */
-  async evalCondition(taskOrStep) {
+  async evalCondition(taskOrStep, shell) {
     if (!taskOrStep.condition) {
       return true;
     }
     this.log((0, import_chalk2.gray)(`${(0, import_chalk2.underline)("condition")}: ${taskOrStep.condition}`));
     const result = await this.shell({
       command: taskOrStep.condition,
-      logprefix: "condition: ",
-      quiet: true
+      quiet: true,
+      shell
     });
     if (result.status === 0) {
       return true;
@@ -14766,12 +14718,17 @@ var RunTask = class {
   /**
    * Evaluates environment variables from shell commands (e.g. `$(xx)`)
    */
-  async evalEnvironment(env) {
+  async evalEnvironment(env, shell) {
     const output = {};
     for (const [key, value] of Object.entries(env ?? {})) {
       if (String(value).startsWith("$(") && String(value).endsWith(")")) {
         const query = value.substring(2, value.length - 1);
-        const result = await this.shellEval({ command: query });
+        const result = await this.shell({
+          command: query,
+          quiet: true,
+          captureOutput: true,
+          shell
+        });
         if (result.status !== 0) {
           const error = result.error ? result.error.stack : result.stderr?.toString().trim() || result.stdout?.toString().trim() || `command exited with code ${result.status}`;
           warn(
@@ -14794,7 +14751,7 @@ var RunTask = class {
    * `$(xx)` for allowing environment to be evaluated by executing a shell
    * command and obtaining its result.
    */
-  async resolveEnvironment(envParam, parents) {
+  async resolveEnvironment(envParam, parents, shell) {
     let env = this.runtime.manifest.env ?? {};
     for (const parent of parents) {
       env = {
@@ -14807,7 +14764,14 @@ var RunTask = class {
       ...this.task.env ?? {},
       ...envParam
     };
-    return this.evalEnvironment(env ?? {});
+    return this.evalEnvironment(env, shell);
+  }
+  /**
+   * Resolves the shell for a step's command (or the task's, when no step is
+   * given): step, then task, then project default, then "projen".
+   */
+  resolveShell(step) {
+    return step?.shell ?? this.task.shell ?? this.runtime.manifest.shell ?? "projen";
   }
   /**
    * Returns the "full name" of the task which includes all it's parent task names concatenated by chevrons.
@@ -14828,9 +14792,6 @@ var RunTask = class {
     const quiet = options.quiet ?? false;
     if (!quiet) {
       const log2 = new Array();
-      if (options.logprefix) {
-        log2.push(options.logprefix);
-      }
       log2.push(
         Array.isArray(options.command) ? options.command.join(" ") : options.command
       );
@@ -14845,48 +14806,63 @@ var RunTask = class {
         `invalid workdir (cwd): ${cwd2} must be an existing directory`
       );
     }
+    const shell = options.shell ?? "projen";
+    if (typeof shell === "string" && shell !== "projen" && shell !== "system") {
+      throw new Error(
+        `unknown built-in shell ${JSON.stringify(
+          shell
+        )}; use the built-in "projen" or "system" shells, or a TaskShell.command([...]) invocation`
+      );
+    }
+    const capture2 = options.captureOutput ?? false;
+    const command = options.command;
     const env = {
       ...process.env,
       ...this.env,
       ...options.extraEnv
     };
-    const capture2 = Array.isArray(options.spawnOptions?.stdio);
-    const command = options.command;
-    if (process.platform === "win32") {
-      const cmd = Array.isArray(command) ? $2`${command[0]} ${command.slice(1)}` : $2.raw`${command}`;
-      const result = await cmd.cwd(cwd2).env(env).stdout(capture2 ? "piped" : "inherit").stderr(capture2 ? "piped" : "inherit").noThrow();
-      return {
-        status: result.code,
-        stdout: capture2 ? Buffer.from(result.stdoutBytes) : null,
-        stderr: capture2 ? Buffer.from(result.stderrBytes) : null
-      };
-    }
-    if (!Array.isArray(command)) {
-      return rawShell.exec(command, { cwd: cwd2, env, capture: capture2 });
-    }
-    const [file, ...args] = command;
-    try {
-      tool(file).run(args, {
-        cwd: cwd2,
-        env,
-        inheritStdio: true
-      });
-      return { status: 0 };
-    } catch (e) {
-      if (typeof e?.status === "number") {
-        return { status: e.status };
+    if (shell === "system") {
+      if (Array.isArray(command)) {
+        const [program, ...args] = command;
+        try {
+          tool(program).run(args, { cwd: cwd2, env, inheritStdio: true });
+          return { status: 0 };
+        } catch (e) {
+          if (typeof e?.status === "number") {
+            return { status: e.status };
+          }
+          throw e;
+        }
       }
-      throw e;
+      return systemShell(command, { cwd: cwd2, env, capture: capture2 });
     }
+    const builder = this.buildDaxCommand(command, shell);
+    const result = await builder.cwd(cwd2).env(env).stdout(capture2 ? "piped" : "inherit").stderr(capture2 ? "piped" : "inherit").noThrow();
+    return {
+      status: result.code,
+      stdout: capture2 ? Buffer.from(result.stdoutBytes) : null,
+      stderr: capture2 ? Buffer.from(result.stderrBytes) : null
+    };
   }
-  async shellEval(options) {
-    return this.shell({
-      quiet: true,
-      ...options,
-      spawnOptions: {
-        stdio: ["inherit", "pipe", "pipe"]
-      }
-    });
+  /**
+   * Builds the dax command for the "projen" shell or an explicit invocation.
+   * (The "system" shell is handled host-side, not here.) `command` is a shell
+   * line (string) or an `execArgs` argv (string[]); `shell` is `"projen"` or an
+   * invocation argv such as `["bash", "-c"]`.
+   */
+  buildDaxCommand(command, shell) {
+    if (Array.isArray(shell)) {
+      const [program, ...flags] = shell;
+      const commandLine = Array.isArray(command) ? command.map(quoteArg).join(" ") : command;
+      return $2`${program} ${[...flags, commandLine]}`;
+    }
+    return Array.isArray(command) ? (
+      // execArgs: shell-free argv (each element escaped; `.cmd` shims resolved).
+      $2`${command[0]} ${command.slice(1)}`
+    ) : (
+      // string command, parsed in-process by dax's cross-platform shell.
+      $2.raw`${command}`
+    );
   }
   renderBuiltin(builtin) {
     let moduleRoot = __dirname;

package/lib/sample-file.js

@@ -45,7 +45,7 @@ const util_1 = require("./util");
  * Use this for creating example code files or other resources.
  */
 class SampleFile extends component_1.Component {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.SampleFile", version: "0.100.7" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.SampleFile", version: "0.101.0" };
     filePath;
     options;
     /**
@@ -96,7 +96,7 @@ exports.SampleFile = SampleFile;
  * Renders the given files into the directory if the directory does not exist. Use this to create sample code files
  */
 class SampleDir extends component_1.Component {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.SampleDir", version: "0.100.7" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.SampleDir", version: "0.101.0" };
     dir;
     options;
     /**

package/lib/source-code.js

@@ -9,7 +9,7 @@ const textfile_1 = require("./textfile");
  */
 class SourceCode extends component_1.Component {
     filePath;
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.SourceCode", version: "0.100.7" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.SourceCode", version: "0.101.0" };
     file;
     indentLevel = 0;
     indent;

package/lib/task-model.d.ts

@@ -1,3 +1,4 @@
+import type { TaskShell } from "./task-shell";
 /**
  * Schema for `tasks.json`.
  */
@@ -24,6 +25,12 @@ export interface TasksManifest {
     readonly env?: {
         [name: string]: string;
     };
+    /**
+     * The default task shell, in `tasks.json` form: a keyword (`"projen"` or
+     * `"system"`) or an invocation argument list. See
+     * {@link TaskCommonOptions.shell}.
+     */
+    readonly shell?: string | string[];
 }
 export interface TaskCommonOptions {
     /**
@@ -57,15 +64,65 @@ export interface TaskCommonOptions {
      * @default - process.cwd()
      */
     readonly cwd?: string;
+    /**
+     * The shell used to run this task's commands, including its `condition` and
+     * `$(...)` environment evaluation. Use {@link TaskShell} to pick a built-in
+     * or an explicit invocation. Set at project, task or step level; the nearest
+     * declared level wins.
+     *
+     * @default - inherited from the task/project, otherwise the built-in projen shell
+     */
+    readonly shell?: TaskShell;
 }
 /**
  * Specification of a single task.
+ *
+ * The `tasks.json` (manifest) form of a task. {@link TaskCommonOptions} is the
+ * form used to define one; they differ only in the rendered `shell` field.
  */
-export interface TaskSpec extends TaskCommonOptions {
+export interface TaskSpec {
     /**
      * Task name.
      */
     readonly name: string;
+    /**
+     * The description of this build command.
+     * @default - the task name
+     */
+    readonly description?: string;
+    /**
+     * Defines environment variables for the execution of this task.
+     * Values in this map will be evaluated in a shell, so you can do stuff like `$(echo "foo")`.
+     * @default {}
+     */
+    readonly env?: {
+        [name: string]: string;
+    };
+    /**
+     * A set of environment variables that must be defined in order to execute
+     * this task. Task execution will fail if one of these is not defined.
+     */
+    readonly requiredEnv?: string[];
+    /**
+     * A shell command which determines if the this task should be executed. If
+     * the program exits with a zero exit code, steps will be executed. A non-zero
+     * code means that task will be skipped.
+     */
+    readonly condition?: string;
+    /**
+     * The working directory for all steps in this task (unless overridden by the
+     * step).
+     *
+     * @default - process.cwd()
+     */
+    readonly cwd?: string;
+    /**
+     * The task shell in `tasks.json` form: a keyword (`"projen"` or `"system"`)
+     * or an invocation argument list.
+     *
+     * @default - the built-in projen shell
+     */
+    readonly shell?: string | string[];
     /**
      * Task steps.
      */
@@ -99,7 +156,7 @@ export interface TaskStepOptions {
      * If `true`, args are passed through at the end of the `exec` shell command.\
      * The position of the args can be changed by including the marker `$@` inside the command string.
      *
-     * If the marker is explicitly double-quoted ("$@") arguments will be wrapped in single quotes, approximating
+     * If the marker is explicitly double-quoted ("$@") arguments will be wrapped in double quotes, approximating
      * the whitespace preserving behavior of bash variable expansion.
      *
      * If the step spawns a subtask, args are passed to the subtask.
@@ -142,12 +199,71 @@ export interface TaskStepOptions {
     readonly env?: {
         [name: string]: string;
     };
+    /**
+     * The shell used to run this step, overriding the task/project shell.
+     *
+     * @see {@link TaskCommonOptions.shell}
+     * @default - the task's (or project's) shell
+     */
+    readonly shell?: TaskShell;
 }
 /**
  * A single step within a task. The step could either be  the execution of a
  * shell command or execution of a sub-task, by name.
+ *
+ * The `tasks.json` (manifest) form of a step. {@link TaskStepOptions} is the
+ * form used to define steps (via `task.exec()` etc.); they differ only in the
+ * rendered `shell` field.
  */
-export interface TaskStep extends TaskStepOptions {
+export interface TaskStep {
+    /**
+     * Step name
+     *
+     * @default - no name
+     */
+    readonly name?: string;
+    /**
+     * The working directory for this step.
+     *
+     * @default - determined by the task
+     */
+    readonly cwd?: string;
+    /**
+     * A shell command which determines if the this step should be executed. If
+     * the program exits with a zero exit code, the step will be executed. A non-zero
+     * code means the step will be skipped (subsequent task steps will still be evaluated/executed).
+     */
+    readonly condition?: string;
+    /**
+     * Should this step receive args passed to the task.
+     *
+     * @see {@link TaskStepOptions.receiveArgs}
+     * @default false
+     */
+    readonly receiveArgs?: boolean;
+    /**
+     * A list of fixed arguments always passed to the step.
+     *
+     * @see {@link TaskStepOptions.args}
+     * @default - no arguments are passed to the step
+     */
+    readonly args?: string[];
+    /**
+     * Defines environment variables for the execution of this step (`exec` and `builtin` only).
+     *
+     * @see {@link TaskStepOptions.env}
+     * @default - no environment variables defined in step
+     */
+    readonly env?: {
+        [name: string]: string;
+    };
+    /**
+     * The step shell in `tasks.json` form: a keyword (`"projen"` or `"system"`)
+     * or an invocation argument list.
+     *
+     * @default - the task's (or project's) shell
+     */
+    readonly shell?: string | string[];
     /**
      * Shell command to execute.
      *

package/lib/task-model.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-model.js","sourceRoot":"","sources":["../src/task-model.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Schema for `tasks.json`.\n */\nexport interface TasksManifest {\n  /**\n   * The version of the tasks manifest schema.\n   *\n   * Used by the task runtime to detect manifests produced by a newer version\n   * of projen. Manifests generated by older versions of projen omit this field\n   * and are treated as \"legacy\" for backwards compatibility.\n   *\n   * @default - the manifest is treated as a legacy (unversioned) manifest\n   */\n  readonly manifestVersion?: number;\n\n  /**\n   * All tasks available for this project.\n   */\n  readonly tasks?: { [name: string]: TaskSpec };\n\n  /**\n   * Environment for all tasks.\n   */\n  readonly env?: { [name: string]: string };\n}\n\nexport interface TaskCommonOptions {\n  /**\n   * The description of this build command.\n   * @default - the task name\n   */\n  readonly description?: string;\n\n  /**\n   * Defines environment variables for the execution of this task.\n   * Values in this map will be evaluated in a shell, so you can do stuff like `$(echo \"foo\")`.\n   * @default {}\n   */\n  readonly env?: { [name: string]: string };\n\n  /**\n   * A set of environment variables that must be defined in order to execute\n   * this task. Task execution will fail if one of these is not defined.\n   */\n  readonly requiredEnv?: string[];\n\n  /**\n   * A shell command which determines if the this task should be executed. If\n   * the program exits with a zero exit code, steps will be executed. A non-zero\n   * code means that task will be skipped.\n   */\n  readonly condition?: string;\n\n  /**\n   * The working directory for all steps in this task (unless overridden by the\n   * step).\n   *\n   * @default - process.cwd()\n   */\n  readonly cwd?: string;\n}\n\n/**\n * Specification of a single task.\n */\nexport interface TaskSpec extends TaskCommonOptions {\n  /**\n   * Task name.\n   */\n  readonly name: string;\n\n  /**\n   * Task steps.\n   */\n  readonly steps?: TaskStep[];\n}\n\n/**\n * Options for task steps.\n */\nexport interface TaskStepOptions {\n  /**\n   * Step name\n   *\n   * @default - no name\n   */\n  readonly name?: string;\n\n  /**\n   * The working directory for this step.\n   *\n   * @default - determined by the task\n   */\n  readonly cwd?: string;\n\n  /**\n   * A shell command which determines if the this step should be executed. If\n   * the program exits with a zero exit code, the step will be executed. A non-zero\n   * code means the step will be skipped (subsequent task steps will still be evaluated/executed).\n   */\n  readonly condition?: string;\n\n  /**\n   * Should this step receive args passed to the task.\n   *\n   * If `true`, args are passed through at the end of the `exec` shell command.\\\n   * The position of the args can be changed by including the marker `$@` inside the command string.\n   *\n   * If the marker is explicitly double-quoted (\"$@\") arguments will be wrapped in single quotes, approximating\n   * the whitespace preserving behavior of bash variable expansion.\n   *\n   * If the step spawns a subtask, args are passed to the subtask.\n   * The subtask must define steps receiving args for this to have any effect.\n   *\n   * @example task.exec(\"echo Hello $@ World!\", { receiveArgs: true });\n   *\n   * @default false\n   */\n  readonly receiveArgs?: boolean;\n\n  /**\n   * A list of fixed arguments always passed to the step.\n   *\n   * Useful to re-use existing tasks without having to re-define the whole task.\\\n   * Fixed args are always passed to the step, even if `receiveArgs` is `false`\n   * and are always passed before any args the task is called with.\n   *\n   * If the step executes a shell commands, args are passed through at the end of the `exec` shell command.\\\n   * The position of the args can be changed by including the marker `$@` inside the command string.\n   *\n   * If the step spawns a subtask, args are passed to the subtask.\n   * The subtask must define steps receiving args for this to have any effect.\n   *\n   * If the step calls a builtin script, args are passed to the script.\n   * It is up to the script to use or discard the arguments.\n   *\n   * @example task.spawn(\"deploy\", { args: [\"--force\"] });\n   *\n   * @default - no arguments are passed to the step\n   */\n  readonly args?: string[];\n\n  /**\n   * Defines environment variables for the execution of this step (`exec` and `builtin` only).\n   * Values in this map can be simple, literal values or shell expressions that will be evaluated at runtime e.g. `$(echo \"foo\")`.\n   *\n   * @example { \"foo\": \"bar\", \"boo\": \"$(echo baz)\" }\n   *\n   * @default - no environment variables defined in step\n   */\n  readonly env?: { [name: string]: string };\n}\n\n/**\n * A single step within a task. The step could either be  the execution of a\n * shell command or execution of a sub-task, by name.\n */\nexport interface TaskStep extends TaskStepOptions {\n  /**\n   * Shell command to execute.\n   *\n   * The whole command is a single shell string. To pass arguments as a list\n   * instead - without having to quote spaces or other characters yourself -\n   * use `execArgs`.\n   *\n   * @default - don't execute a shell command\n   */\n  readonly exec?: string;\n\n  /**\n   * Shell command to execute, provided as a list of the program followed by\n   * its arguments (an \"argv\").\n   *\n   * Often more convenient than `exec`: each element is passed to the\n   * program as-is, so arguments with spaces or special characters don't need\n   * quoting. Fixed (`args`) or received (`receiveArgs`) arguments are inserted\n   * wherever a `$@` element appears, or appended at the end if there is none.\n   *\n   * The elements are not run through a shell, so environment variables (`$FOO`)\n   * are not expanded and other shell features are unavailable. Use `exec`\n   * if you need them.\n   *\n   * Mutually exclusive with `exec`.\n   *\n   * @example { execArgs: [\"echo\", \"hello world\"] }\n   *\n   * @default - don't execute a shell command\n   */\n  readonly execArgs?: string[];\n\n  /**\n   * Subtask to execute\n   *\n   * @default - don't spawn a subtask\n   */\n  readonly spawn?: string;\n\n  /**\n   * Print a message.\n   * @default - don't say anything\n   */\n  readonly say?: string;\n\n  /**\n   * The name of a built-in task to execute.\n   *\n   * Built-in tasks are node.js programs baked into the projen module and as\n   * component runtime helpers.\n   *\n   * The name is a path relative to the projen lib/ directory (without the .task.js extension).\n   * For example, if your built in builtin task is under `src/release/resolve-version.task.ts`,\n   * then this would be `release/resolve-version`.\n   *\n   * @default - do not execute a builtin task\n   */\n  readonly builtin?: string;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-model.js","sourceRoot":"","sources":["../src/task-model.ts"],"names":[],"mappings":"","sourcesContent":["import type { TaskShell } from \"./task-shell\";\n\n/**\n * Schema for `tasks.json`.\n */\nexport interface TasksManifest {\n  /**\n   * The version of the tasks manifest schema.\n   *\n   * Used by the task runtime to detect manifests produced by a newer version\n   * of projen. Manifests generated by older versions of projen omit this field\n   * and are treated as \"legacy\" for backwards compatibility.\n   *\n   * @default - the manifest is treated as a legacy (unversioned) manifest\n   */\n  readonly manifestVersion?: number;\n\n  /**\n   * All tasks available for this project.\n   */\n  readonly tasks?: { [name: string]: TaskSpec };\n\n  /**\n   * Environment for all tasks.\n   */\n  readonly env?: { [name: string]: string };\n\n  /**\n   * The default task shell, in `tasks.json` form: a keyword (`\"projen\"` or\n   * `\"system\"`) or an invocation argument list. See\n   * {@link TaskCommonOptions.shell}.\n   */\n  readonly shell?: string | string[];\n}\n\nexport interface TaskCommonOptions {\n  /**\n   * The description of this build command.\n   * @default - the task name\n   */\n  readonly description?: string;\n\n  /**\n   * Defines environment variables for the execution of this task.\n   * Values in this map will be evaluated in a shell, so you can do stuff like `$(echo \"foo\")`.\n   * @default {}\n   */\n  readonly env?: { [name: string]: string };\n\n  /**\n   * A set of environment variables that must be defined in order to execute\n   * this task. Task execution will fail if one of these is not defined.\n   */\n  readonly requiredEnv?: string[];\n\n  /**\n   * A shell command which determines if the this task should be executed. If\n   * the program exits with a zero exit code, steps will be executed. A non-zero\n   * code means that task will be skipped.\n   */\n  readonly condition?: string;\n\n  /**\n   * The working directory for all steps in this task (unless overridden by the\n   * step).\n   *\n   * @default - process.cwd()\n   */\n  readonly cwd?: string;\n\n  /**\n   * The shell used to run this task's commands, including its `condition` and\n   * `$(...)` environment evaluation. Use {@link TaskShell} to pick a built-in\n   * or an explicit invocation. Set at project, task or step level; the nearest\n   * declared level wins.\n   *\n   * @default - inherited from the task/project, otherwise the built-in projen shell\n   */\n  readonly shell?: TaskShell;\n}\n\n/**\n * Specification of a single task.\n *\n * The `tasks.json` (manifest) form of a task. {@link TaskCommonOptions} is the\n * form used to define one; they differ only in the rendered `shell` field.\n */\nexport interface TaskSpec {\n  /**\n   * Task name.\n   */\n  readonly name: string;\n\n  /**\n   * The description of this build command.\n   * @default - the task name\n   */\n  readonly description?: string;\n\n  /**\n   * Defines environment variables for the execution of this task.\n   * Values in this map will be evaluated in a shell, so you can do stuff like `$(echo \"foo\")`.\n   * @default {}\n   */\n  readonly env?: { [name: string]: string };\n\n  /**\n   * A set of environment variables that must be defined in order to execute\n   * this task. Task execution will fail if one of these is not defined.\n   */\n  readonly requiredEnv?: string[];\n\n  /**\n   * A shell command which determines if the this task should be executed. If\n   * the program exits with a zero exit code, steps will be executed. A non-zero\n   * code means that task will be skipped.\n   */\n  readonly condition?: string;\n\n  /**\n   * The working directory for all steps in this task (unless overridden by the\n   * step).\n   *\n   * @default - process.cwd()\n   */\n  readonly cwd?: string;\n\n  /**\n   * The task shell in `tasks.json` form: a keyword (`\"projen\"` or `\"system\"`)\n   * or an invocation argument list.\n   *\n   * @default - the built-in projen shell\n   */\n  readonly shell?: string | string[];\n\n  /**\n   * Task steps.\n   */\n  readonly steps?: TaskStep[];\n}\n\n/**\n * Options for task steps.\n */\nexport interface TaskStepOptions {\n  /**\n   * Step name\n   *\n   * @default - no name\n   */\n  readonly name?: string;\n\n  /**\n   * The working directory for this step.\n   *\n   * @default - determined by the task\n   */\n  readonly cwd?: string;\n\n  /**\n   * A shell command which determines if the this step should be executed. If\n   * the program exits with a zero exit code, the step will be executed. A non-zero\n   * code means the step will be skipped (subsequent task steps will still be evaluated/executed).\n   */\n  readonly condition?: string;\n\n  /**\n   * Should this step receive args passed to the task.\n   *\n   * If `true`, args are passed through at the end of the `exec` shell command.\\\n   * The position of the args can be changed by including the marker `$@` inside the command string.\n   *\n   * If the marker is explicitly double-quoted (\"$@\") arguments will be wrapped in double quotes, approximating\n   * the whitespace preserving behavior of bash variable expansion.\n   *\n   * If the step spawns a subtask, args are passed to the subtask.\n   * The subtask must define steps receiving args for this to have any effect.\n   *\n   * @example task.exec(\"echo Hello $@ World!\", { receiveArgs: true });\n   *\n   * @default false\n   */\n  readonly receiveArgs?: boolean;\n\n  /**\n   * A list of fixed arguments always passed to the step.\n   *\n   * Useful to re-use existing tasks without having to re-define the whole task.\\\n   * Fixed args are always passed to the step, even if `receiveArgs` is `false`\n   * and are always passed before any args the task is called with.\n   *\n   * If the step executes a shell commands, args are passed through at the end of the `exec` shell command.\\\n   * The position of the args can be changed by including the marker `$@` inside the command string.\n   *\n   * If the step spawns a subtask, args are passed to the subtask.\n   * The subtask must define steps receiving args for this to have any effect.\n   *\n   * If the step calls a builtin script, args are passed to the script.\n   * It is up to the script to use or discard the arguments.\n   *\n   * @example task.spawn(\"deploy\", { args: [\"--force\"] });\n   *\n   * @default - no arguments are passed to the step\n   */\n  readonly args?: string[];\n\n  /**\n   * Defines environment variables for the execution of this step (`exec` and `builtin` only).\n   * Values in this map can be simple, literal values or shell expressions that will be evaluated at runtime e.g. `$(echo \"foo\")`.\n   *\n   * @example { \"foo\": \"bar\", \"boo\": \"$(echo baz)\" }\n   *\n   * @default - no environment variables defined in step\n   */\n  readonly env?: { [name: string]: string };\n\n  /**\n   * The shell used to run this step, overriding the task/project shell.\n   *\n   * @see {@link TaskCommonOptions.shell}\n   * @default - the task's (or project's) shell\n   */\n  readonly shell?: TaskShell;\n}\n\n/**\n * A single step within a task. The step could either be  the execution of a\n * shell command or execution of a sub-task, by name.\n *\n * The `tasks.json` (manifest) form of a step. {@link TaskStepOptions} is the\n * form used to define steps (via `task.exec()` etc.); they differ only in the\n * rendered `shell` field.\n */\nexport interface TaskStep {\n  /**\n   * Step name\n   *\n   * @default - no name\n   */\n  readonly name?: string;\n\n  /**\n   * The working directory for this step.\n   *\n   * @default - determined by the task\n   */\n  readonly cwd?: string;\n\n  /**\n   * A shell command which determines if the this step should be executed. If\n   * the program exits with a zero exit code, the step will be executed. A non-zero\n   * code means the step will be skipped (subsequent task steps will still be evaluated/executed).\n   */\n  readonly condition?: string;\n\n  /**\n   * Should this step receive args passed to the task.\n   *\n   * @see {@link TaskStepOptions.receiveArgs}\n   * @default false\n   */\n  readonly receiveArgs?: boolean;\n\n  /**\n   * A list of fixed arguments always passed to the step.\n   *\n   * @see {@link TaskStepOptions.args}\n   * @default - no arguments are passed to the step\n   */\n  readonly args?: string[];\n\n  /**\n   * Defines environment variables for the execution of this step (`exec` and `builtin` only).\n   *\n   * @see {@link TaskStepOptions.env}\n   * @default - no environment variables defined in step\n   */\n  readonly env?: { [name: string]: string };\n\n  /**\n   * The step shell in `tasks.json` form: a keyword (`\"projen\"` or `\"system\"`)\n   * or an invocation argument list.\n   *\n   * @default - the task's (or project's) shell\n   */\n  readonly shell?: string | string[];\n\n  /**\n   * Shell command to execute.\n   *\n   * The whole command is a single shell string. To pass arguments as a list\n   * instead - without having to quote spaces or other characters yourself -\n   * use `execArgs`.\n   *\n   * @default - don't execute a shell command\n   */\n  readonly exec?: string;\n\n  /**\n   * Shell command to execute, provided as a list of the program followed by\n   * its arguments (an \"argv\").\n   *\n   * Often more convenient than `exec`: each element is passed to the\n   * program as-is, so arguments with spaces or special characters don't need\n   * quoting. Fixed (`args`) or received (`receiveArgs`) arguments are inserted\n   * wherever a `$@` element appears, or appended at the end if there is none.\n   *\n   * The elements are not run through a shell, so environment variables (`$FOO`)\n   * are not expanded and other shell features are unavailable. Use `exec`\n   * if you need them.\n   *\n   * Mutually exclusive with `exec`.\n   *\n   * @example { execArgs: [\"echo\", \"hello world\"] }\n   *\n   * @default - don't execute a shell command\n   */\n  readonly execArgs?: string[];\n\n  /**\n   * Subtask to execute\n   *\n   * @default - don't spawn a subtask\n   */\n  readonly spawn?: string;\n\n  /**\n   * Print a message.\n   * @default - don't say anything\n   */\n  readonly say?: string;\n\n  /**\n   * The name of a built-in task to execute.\n   *\n   * Built-in tasks are node.js programs baked into the projen module and as\n   * component runtime helpers.\n   *\n   * The name is a path relative to the projen lib/ directory (without the .task.js extension).\n   * For example, if your built in builtin task is under `src/release/resolve-version.task.ts`,\n   * then this would be `release/resolve-version`.\n   *\n   * @default - do not execute a builtin task\n   */\n  readonly builtin?: string;\n}\n"]}