projen 0.100.6 → 0.101.0

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,18 +199,101 @@ 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;
+    };
     /**
-     * Shell command to execute
+     * 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.
+     *
+     * The whole command is a single shell string. To pass arguments as a list
+     * instead - without having to quote spaces or other characters yourself -
+     * use `execArgs`.
      *
      * @default - don't execute a shell command
      */
     readonly exec?: string;
+    /**
+     * Shell command to execute, provided as a list of the program followed by
+     * its arguments (an "argv").
+     *
+     * Often more convenient than `exec`: each element is passed to the
+     * program as-is, so arguments with spaces or special characters don't need
+     * quoting. Fixed (`args`) or received (`receiveArgs`) arguments are inserted
+     * wherever a `$@` element appears, or appended at the end if there is none.
+     *
+     * The elements are not run through a shell, so environment variables (`$FOO`)
+     * are not expanded and other shell features are unavailable. Use `exec`
+     * if you need them.
+     *
+     * Mutually exclusive with `exec`.
+     *
+     * @example { execArgs: ["echo", "hello world"] }
+     *
+     * @default - don't execute a shell command
+     */
+    readonly execArgs?: string[];
     /**
      * Subtask to execute
      *

package/lib/task-model.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# 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"]}

package/lib/task-shell.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The shell used to run a task's commands - including its `condition` and any
+ * `$(...)` environment-variable evaluation.
+ *
+ * Choose one of the built-in shells, or provide an explicit shell invocation:
+ *
+ * - {@link TaskShell.projen} (the default) - the built-in cross-platform shell.
+ * - {@link TaskShell.system} - the operating system's native shell.
+ * - {@link TaskShell.bash} / {@link TaskShell.sh} - common POSIX shells.
+ * - {@link TaskShell.command} - an arbitrary shell invocation given as an
+ *   explicit argument list, e.g. `TaskShell.command(["npx", "-c"])`.
+ *
+ * A `shell` can be set at the project (tasks), task and step level, and the
+ * nearest declared level wins (it is a scalar override, not merged).
+ */
+export declare class TaskShell {
+    private readonly value;
+    /**
+     * The built-in cross-platform shell (the default). It interprets POSIX-style
+     * task syntax (`mkdir -p`, `&&`, `$VAR`, ...) identically on every platform,
+     * including Windows.
+     */
+    static projen(): TaskShell;
+    /**
+     * The operating system's native shell (`/bin/sh` on POSIX, `cmd.exe` on
+     * Windows).
+     *
+     * Use this to opt out of the cross-platform shell and run commands through
+     * whatever shell the host provides.
+     */
+    static system(): TaskShell;
+    /**
+     * Runs commands through `bash -c`.
+     */
+    static bash(): TaskShell;
+    /**
+     * Runs commands through `sh -c`.
+     */
+    static sh(): TaskShell;
+    /**
+     * An arbitrary shell invocation, given as an explicit argument list. The task
+     * command is appended as the final argument, so the invocation must accept
+     * the command as its last argument (e.g. `bash -c`, `sh -c`, `npx -c`,
+     * `yarn exec`).
+     *
+     *
+     * @example TaskShell.command(["bash", "-c"]);
+     * @example TaskShell.command(["npx", "-c"]);
+     *
+     * @param command The shell program followed by its arguments. Must not be
+     * empty.
+     */
+    static command(command: string[]): TaskShell;
+    private constructor();
+    /**
+     * Renders the shell to its `tasks.json` representation: a built-in keyword
+     * string (`"projen"` or `"system"`) for the built-ins, or an explicit
+     * argument list for a custom shell invocation.
+     *
+     * @internal
+     */
+    _render(): string | string[];
+}

package/lib/task-shell.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskShell = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * The shell used to run a task's commands - including its `condition` and any
+ * `$(...)` environment-variable evaluation.
+ *
+ * Choose one of the built-in shells, or provide an explicit shell invocation:
+ *
+ * - {@link TaskShell.projen} (the default) - the built-in cross-platform shell.
+ * - {@link TaskShell.system} - the operating system's native shell.
+ * - {@link TaskShell.bash} / {@link TaskShell.sh} - common POSIX shells.
+ * - {@link TaskShell.command} - an arbitrary shell invocation given as an
+ *   explicit argument list, e.g. `TaskShell.command(["npx", "-c"])`.
+ *
+ * A `shell` can be set at the project (tasks), task and step level, and the
+ * nearest declared level wins (it is a scalar override, not merged).
+ */
+class TaskShell {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.TaskShell", version: "0.101.0" };
+    /**
+     * The built-in cross-platform shell (the default). It interprets POSIX-style
+     * task syntax (`mkdir -p`, `&&`, `$VAR`, ...) identically on every platform,
+     * including Windows.
+     */
+    static projen() {
+        return new TaskShell("projen");
+    }
+    /**
+     * The operating system's native shell (`/bin/sh` on POSIX, `cmd.exe` on
+     * Windows).
+     *
+     * Use this to opt out of the cross-platform shell and run commands through
+     * whatever shell the host provides.
+     */
+    static system() {
+        return new TaskShell("system");
+    }
+    /**
+     * Runs commands through `bash -c`.
+     */
+    static bash() {
+        return new TaskShell(["bash", "-c"]);
+    }
+    /**
+     * Runs commands through `sh -c`.
+     */
+    static sh() {
+        return new TaskShell(["sh", "-c"]);
+    }
+    /**
+     * An arbitrary shell invocation, given as an explicit argument list. The task
+     * command is appended as the final argument, so the invocation must accept
+     * the command as its last argument (e.g. `bash -c`, `sh -c`, `npx -c`,
+     * `yarn exec`).
+     *
+     *
+     * @example TaskShell.command(["bash", "-c"]);
+     * @example TaskShell.command(["npx", "-c"]);
+     *
+     * @param command The shell program followed by its arguments. Must not be
+     * empty.
+     */
+    static command(command) {
+        if (command.length === 0) {
+            throw new Error("TaskShell.command() requires at least the shell program");
+        }
+        return new TaskShell([...command]);
+    }
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Renders the shell to its `tasks.json` representation: a built-in keyword
+     * string (`"projen"` or `"system"`) for the built-ins, or an explicit
+     * argument list for a custom shell invocation.
+     *
+     * @internal
+     */
+    _render() {
+        return Array.isArray(this.value) ? [...this.value] : this.value;
+    }
+}
+exports.TaskShell = TaskShell;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/task.d.ts

@@ -1,10 +1,29 @@
 import type { TaskCommonOptions, TaskSpec, TaskStep, TaskStepOptions } from "./task-model";
+import type { TaskShell } from "./task-shell";
 export interface TaskOptions extends TaskCommonOptions {
     /**
      * Shell command to execute as the first command of the task.
+     *
+     * Mutually exclusive with `execArgs`.
+     *
      * @default - add steps using `task.exec(command)` or `task.spawn(subtask)`
      */
     readonly exec?: string;
+    /**
+     * Shell command to execute as the first command of the task, provided as a
+     * list of the program followed by its arguments (an "argv").
+     *
+     * A convenient alternative to `exec`: arguments with spaces or special
+     * characters are passed through as-is, with no quoting needed. The elements
+     * are not run through a shell, so environment variables (`$FOO`) are not
+     * expanded and other shell features are unavailable.
+     * @see TaskStep.execArgs
+     *
+     * Mutually exclusive with `exec`.
+     *
+     * @default - add steps using `task.execArgs(args)`, `task.exec(command)` or `task.spawn(subtask)`
+     */
+    readonly execArgs?: string[];
     /**
      * List of task steps to run.
      */
@@ -37,6 +56,7 @@ export declare class Task {
     private readonly _steps;
     private readonly _env;
     private _cwd?;
+    private _shell?;
     private readonly requiredEnv?;
     private _locked;
     private _description?;
@@ -53,6 +73,16 @@ export declare class Task {
      * Sets the working directory for this task.
      */
     set cwd(cwd: string | undefined);
+    /**
+     * The shell used to run this task's commands, or `undefined` when inheriting
+     * the built-in default shell.
+     * @see {@link TaskCommonOptions.shell}
+     */
+    get shell(): TaskShell | undefined;
+    /**
+     * Sets the shell used to run this task's commands.
+     */
+    set shell(shell: TaskShell | undefined);
     /**
      * Returns the description of this task.
      */
@@ -92,6 +122,21 @@ export declare class Task {
      * @param options Options
      */
     exec(command: string, options?: TaskStepOptions): void;
+    /**
+     * Executes a command provided as a list of the program followed by its
+     * arguments (an "argv").
+     *
+     * A convenient alternative to `Task.exec`: arguments with spaces or
+     * special characters are passed through as-is, with no quoting needed. The
+     * elements are not run through a shell, so environment variables (`$FOO`) are
+     * not expanded and other shell features are unavailable.
+     *
+     * @example task.execArgs(["echo", "hello world"]);
+     *
+     * @param command The program followed by its arguments.
+     * @param options Options
+     */
+    execArgs(command: string[], options?: TaskStepOptions): void;
     /**
      * Execute a builtin task.
      *
@@ -123,9 +168,9 @@ export declare class Task {
     prependSteps(...steps: TaskStep[]): void;
     /**
      * Adds a command at the beginning of the task.
-     * @param shell The command to add.
+     * @param command The command to add.
      */
-    prependExec(shell: string, options?: TaskStepOptions): void;
+    prependExec(command: string, options?: TaskStepOptions): void;
     /**
      * Adds a spawn instruction at the beginning of the task.
      * @param subtask The subtask to execute.
@@ -136,6 +181,11 @@ export declare class Task {
      * @param message Your message
      */
     prependSay(message: string, options?: TaskStepOptions): void;
+    /**
+     * Renders step options (with a {@link TaskShell}) to the manifest
+     * {@link TaskStep} form, where `shell` is its `string | string[]` rendering.
+     */
+    private renderStep;
     private _pushSteps;
     private _unshiftSteps;
     /**