@pulumi/command 0.0.1-alpha.1640827590 → 0.0.1-testwindows.signing

package/README.md

@@ -1,3 +1,11 @@
+[![Actions Status](https://github.com/pulumi/pulumi-command/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-command/actions)
+[![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
+[![NPM version](https://badge.fury.io/js/%40pulumi%2Fcommand.svg)](https://www.npmjs.com/package/@pulumi/command)
+[![Python version](https://badge.fury.io/py/pulumi-command.svg)](https://pypi.org/project/pulumi-command)
+[![NuGet version](https://badge.fury.io/nu/pulumi.command.svg)](https://badge.fury.io/nu/pulumi.command)
+[![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-command/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-command/sdk/go)
+[![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-command/blob/master/LICENSE)
+
 # Pulumi Command Provider (preview)
 
 The Pulumi Command Provider enables you to execute commands and scripts either locally or remotely as part of the Pulumi resource model.  Resources in the command package support running scripts on `create` and `destroy` operations, supporting stateful local and remote command execution.
@@ -12,7 +20,7 @@ There are many scenarios where the Command package can be useful:
 
 Some users may have experience with Terraform "provisioners", and the Command package offers support for similar scenarios.  However, the Command package is provided as independent resources which can be combined with other resources in many interesting ways. This has many strengths, but also some differences, such as the fact that a Command resource failing does not cause a resource it is operating on to fail.
 
-You can use the Command package from a Pulumi program written in any Pulumi language: C#, Go, JavaScript/TypeScript, and Python.
+You can use the Command package from a Pulumi program written in any Pulumi language: C#, Go, JavaScript/TypeScript, Python, and YAML.
 You'll need to [install and configure the Pulumi CLI](https://pulumi.com/docs/get-started/install) if you haven't already.
 
 
@@ -38,14 +46,14 @@ export const output = random.stdout;
 package main
 
 import (
-	"github.com/pulumi/pulumi-command/sdk/v3/go/command/local"
+	"github.com/pulumi/pulumi-command/sdk/go/command/local"
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
 func main() {
 	pulumi.Run(func(ctx *pulumi.Context) error {
 
-		random, err := local.NewCommand(ctx, "my-bucket", &local.CommandArgs{
+		random, err := local.NewCommand(ctx, "my-bucket", &local.CommandInput{
 			Create: pulumi.String("openssl rand -hex 16"),
 		})
 		if err != nil {
@@ -108,7 +116,7 @@ const server = new aws.ec2.Instance("server", {
 
 // Now set up a connection to the instance and run some provisioning operations on the instance.
 
-const connection: types.input.remote.ConnectionArgs = {
+const connection: types.input.remote.ConnectionInput = {
     host: server.publicIp,
     user: "ec2-user",
     privateKey: privateKey,
@@ -181,7 +189,7 @@ export const output = rand.stdout;
 
 ### Using `local.Command `with CURL to manage external REST API
 
-This example uses `local.Command` to create a simple resource provider for managing GitHub labels, by invoking `curl` commands on `create` and `delete` commands against the GitHub REST API.  A similar approach could be applied to build other simple providers against any REST API directly from within Pulumi programs in any language.  This approach is somewhat limited by the fact that `local.Command` does not yet support `diff`/`update`/`read`.  Support for those may be [added in the future](https://github.com/pulumi/pulumi-command/issues/20).
+This example uses `local.Command` to create a simple resource provider for managing GitHub labels, by invoking `curl` commands on `create` and `delete` commands against the GitHub REST API. A similar approach could be applied to build other simple providers against any REST API directly from within Pulumi programs in any language. This approach is somewhat limited by the fact that `local.Command` does not yet support `diff`/`read`. Support for [Read](https://github.com/pulumi/pulumi-command/issues/432) and [Diff](https://github.com/pulumi/pulumi-command/issues/433) may be added in the future.
 
 This example also shows how `local.Command` can be used as an implementation detail inside a nicer abstraction, like the `GitHubLabel` component defined below.
 
@@ -255,32 +263,111 @@ curl \
 
 ### Graceful cleanup of workloads in a Kubernetes cluster
 
-There are cases where it's important to run some cleanup operation before destroying a resource, in case destroying the resource does not properly handle orderly cleanup.  For example, destroying an EKS Cluster will not ensure that all Kubernetes object finalizers are run, which may lead to leaking external resources managed by those Kubernetes resources.  This example shows how we can use a `delete`-only `Command` to ensure some cleanup is run within a cluster before destroying it.
+There are cases where it's important to run some cleanup operation before destroying a resource such as when destroying the resource does not properly handle orderly cleanup.  For example, destroying an EKS Cluster will not ensure that all Kubernetes object finalizers are run, which may lead to leaking external resources managed by those Kubernetes resources.  This example shows how we can use a `delete`-only `Command` to ensure some cleanup is run within a cluster before destroying it.
+
+```yaml
+resources:
+  cluster:
+    type: eks:Cluster
+
+  cleanupKubernetesNamespaces:
+    # We could also use `RemoteCommand` to run this from
+    # within a node in the cluster.
+    type: command:local:Command
+    properties:
+      # This will run before the cluster is destroyed.
+      # Everything else will need to depend on this resource
+      # to ensure this cleanup doesn't happen too early.
+      delete: |
+        kubectl --kubeconfig <(echo "$KUBECONFIG_DATA") delete namespace nginx
+      # Process substitution "<()" doesn't work in the default interpreter sh.
+      interpreter: ["/bin/bash", "-c"]
+      environment:
+        KUBECONFIG_DATA: "${cluster.kubeconfigJson}"
+```
 
 ```ts
-import { local } from "@pulumi/command";
+import * as pulumi from "@pulumi/pulumi";
+import * as command from "@pulumi/command";
 import * as eks from "@pulumi/eks";
-import * as random from "@pulumi/random";
-import { interpolate } from "@pulumi/pulumi";
 
 const cluster = new eks.Cluster("cluster", {});
 
 // We could also use `RemoteCommand` to run this from within a node in the cluster
-const cleanupKubernetesNamespaces = new local.Command("cleanupKubernetesNamespaces", {
+const cleanupKubernetesNamespaces = new command.local.Command("cleanupKubernetesNamespaces", {
     // This will run before the cluster is destroyed.  Everything else will need to 
     // depend on this resource to ensure this cleanup doesn't happen too early.
-    delete: "kubectl delete --all namespaces",
+    "delete": "kubectl --kubeconfig <(echo \"$KUBECONFIG_DATA\") delete namespace nginx\n",
+    // Process substitution "<()" doesn't work in the default interpreter sh.
+    interpreter: [
+        "/bin/bash",
+        "-c",
+    ],
     environment: {
-        KUBECONFIG: cluster.kubeconfig,
+        KUBECONFIG_DATA: cluster.kubeconfigJson,
     },
 });
 ```
 
+### Working with Assets and Paths
+
+When a local command creates assets as part of its execution, these can be captured by specifying `assetPaths` or `archivePaths`.
+
+```typescript
+const lambdaBuild = local.runOutput({
+    dir: "../my-function",
+    command: `yarn && yarn build`,
+    archivePaths: ["dist/**"],
+});
+
+new aws.lambda.Function("my-function", {
+    code: lambdaBuild.archive,
+   // ...
+});
+```
+
+When using the `assetPaths` and `archivePaths`, they take a list of 'globs'.
+- We only include files not directories for assets and archives.
+- Path separators are `/` on all platforms - including Windows.
+- Patterns starting with `!` are 'exclude' rules.
+- Rules are evaluated in order, so exclude rules should be after inclusion rules.
+- `*` matches anything except `/`
+- `**` matches anything, _including_ `/`
+- All returned paths are relative to the working directory (without leading `./`) e.g. `file.text` or `subfolder/file.txt`.
+- For full details of the globbing syntax, see [github.com/gobwas/glob](https://github.com/gobwas/glob)
+
+#### Asset Paths Example
+
+Given the rules:
+```yaml
+- "assets/**"
+- "src/**.js"
+- "!**secret.*"
+```
+
+When evaluating against this folder:
+
+```yaml
+- assets/
+  - logos/
+    - logo.svg
+- src/
+  - index.js
+  - secret.js
+```
+
+The following paths will be returned:
+
+```yaml
+- assets/logos/logo.svg
+- src/index.js
+```
+
 ## Building
 
 ### Dependencies
 
-- Go 1.16
+- Go 1.17
 - NodeJS 10.X.X or later
 - Python 3.6 or later
 - .NET Core 3.1
@@ -298,7 +385,7 @@ $ make build
 $ make install
 ```
 
-Add the `bin` folder to your `$PATH` or copy the `bin/pulumi-resource-aws-native` file to another location in your `$PATH`.
+Add the `bin` folder to your `$PATH` or copy the `bin/pulumi-resource-command` file to another location in your `$PATH`.
 
 ### Running an example
 

package/index.d.ts

@@ -1,4 +1,6 @@
-export * from "./provider";
+export { ProviderArgs } from "./provider";
+export type Provider = import("./provider").Provider;
+export declare const Provider: typeof import("./provider").Provider;
 import * as local from "./local";
 import * as remote from "./remote";
 import * as types from "./types";

package/index.js

@@ -1,22 +1,12 @@
 "use strict";
-// *** WARNING: this file was generated by pulumigen. ***
+// *** WARNING: this file was generated by pulumi-language-nodejs. ***
 // *** Do not edit by hand unless you're certain you know what you are doing! ***
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.types = exports.remote = exports.local = void 0;
+exports.types = exports.remote = exports.local = exports.Provider = void 0;
 const pulumi = require("@pulumi/pulumi");
 const utilities = require("./utilities");
-// Export members:
-__exportStar(require("./provider"), exports);
+exports.Provider = null;
+utilities.lazyLoad(exports, ["Provider"], () => require("./provider"));
 // Export sub-modules:
 const local = require("./local");
 exports.local = local;
@@ -24,14 +14,13 @@ const remote = require("./remote");
 exports.remote = remote;
 const types = require("./types");
 exports.types = types;
-const provider_1 = require("./provider");
 pulumi.runtime.registerResourcePackage("command", {
     version: utilities.getVersion(),
     constructProvider: (name, type, urn) => {
         if (type !== "pulumi:providers:command") {
             throw new Error(`unknown provider type ${type}`);
         }
-        return new provider_1.Provider(name, undefined, { urn });
+        return new exports.Provider(name, undefined, { urn });
     },
 });
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";AAAA,yDAAyD;AACzD,iFAAiF;;;;;;;;;;;;;AAEjF,yCAAyC;AACzC,yCAAyC;AAEzC,kBAAkB;AAClB,6CAA2B;AAE3B,sBAAsB;AACtB,iCAAiC;AAK7B,sBAAK;AAJT,mCAAmC;AAK/B,wBAAM;AAJV,iCAAiC;AAK7B,sBAAK;AAGT,yCAAsC;AAEtC,MAAM,CAAC,OAAO,CAAC,uBAAuB,CAAC,SAAS,EAAE;IAC9C,OAAO,EAAE,SAAS,CAAC,UAAU,EAAE;IAC/B,iBAAiB,EAAE,CAAC,IAAY,EAAE,IAAY,EAAE,GAAW,EAA2B,EAAE;QACpF,IAAI,IAAI,KAAK,0BAA0B,EAAE;YACrC,MAAM,IAAI,KAAK,CAAC,yBAAyB,IAAI,EAAE,CAAC,CAAC;SACpD;QACD,OAAO,IAAI,mBAAQ,CAAC,IAAI,EAAO,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IACvD,CAAC;CACJ,CAAC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AACzC,yCAAyC;AAK5B,QAAA,QAAQ,GAAyC,IAAW,CAAC;AAC1E,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,UAAU,CAAC,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;AAGvE,sBAAsB;AACtB,iCAAiC;AAK7B,sBAAK;AAJT,mCAAmC;AAK/B,wBAAM;AAJV,iCAAiC;AAK7B,sBAAK;AAET,MAAM,CAAC,OAAO,CAAC,uBAAuB,CAAC,SAAS,EAAE;IAC9C,OAAO,EAAE,SAAS,CAAC,UAAU,EAAE;IAC/B,iBAAiB,EAAE,CAAC,IAAY,EAAE,IAAY,EAAE,GAAW,EAA2B,EAAE;QACpF,IAAI,IAAI,KAAK,0BAA0B,EAAE;YACrC,MAAM,IAAI,KAAK,CAAC,yBAAyB,IAAI,EAAE,CAAC,CAAC;SACpD;QACD,OAAO,IAAI,gBAAQ,CAAC,IAAI,EAAO,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IACvD,CAAC;CACJ,CAAC,CAAC"}

package/local/command.d.ts

@@ -1,10 +1,82 @@
 import * as pulumi from "@pulumi/pulumi";
+import * as enums from "../types/enums";
 /**
  * A local command to be executed.
- * This command can be inserted into the life cycles of other resources using the
- * `dependsOn` or `parent` resource options. A command is considered to have
- * failed when it finished with a non-zero exit code. This will fail the CRUD step
- * of the `Command` resource.
+ *
+ * This command can be inserted into the life cycles of other resources using the `dependsOn` or `parent` resource options. A command is considered to have failed when it finished with a non-zero exit code. This will fail the CRUD step of the `Command` resource.
+ *
+ * ## Example Usage
+ *
+ * ### Basic Example
+ *
+ * This example shows the simplest use case, simply running a command on `create` in the Pulumi lifecycle.
+ *
+ * ```typescript
+ * import { local } from "@pulumi/command";
+ *
+ * const random = new local.Command("random", {
+ *     create: "openssl rand -hex 16",
+ * });
+ *
+ * export const output = random.stdout;
+ * ```
+ *
+ * ### Invoking a Lambda during Pulumi Deployment
+ *
+ * This example show using a local command to invoke an AWS Lambda once it's deployed. The Lambda invocation could also depend on other resources.
+ *
+ * ```typescript
+ * import * as aws from "@pulumi/aws";
+ * import { local } from "@pulumi/command";
+ * import { getStack } from "@pulumi/pulumi";
+ *
+ * const f = new aws.lambda.CallbackFunction("f", {
+ *     publish: true,
+ *     callback: async (ev: any) => {
+ *         return `Stack ${ev.stackName} is deployed!`;
+ *     }
+ * });
+ *
+ * const invoke = new local.Command("execf", {
+ *     create: `aws lambda invoke --function-name "$FN" --payload '{"stackName": "${getStack()}"}' --cli-binary-format raw-in-base64-out out.txt >/dev/null && cat out.txt | tr -d '"'  && rm out.txt`,
+ *     environment: {
+ *         FN: f.qualifiedArn,
+ *         AWS_REGION: aws.config.region!,
+ *         AWS_PAGER: "",
+ *     },
+ * }, { dependsOn: f })
+ *
+ * export const output = invoke.stdout;
+ * ```
+ *
+ * ### Using Triggers
+ *
+ * This example defines several trigger values of various kinds. Changes to any of them will cause `cmd` to be re-run.
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as command from "@pulumi/command";
+ * import * as random from "@pulumi/random";
+ *
+ * const str = "foo";
+ * const fileAsset = new pulumi.asset.FileAsset("Pulumi.yaml");
+ * const rand = new random.RandomString("rand", {length: 5});
+ * const localFile = new command.local.Command("localFile", {
+ *     create: "touch foo.txt",
+ *     archivePaths: ["*.txt"],
+ * });
+ *
+ * const cmd = new command.local.Command("cmd", {
+ *     create: "echo create > op.txt",
+ *     delete: "echo delete >> op.txt",
+ *     triggers: [
+ *         str,
+ *         rand.result,
+ *         fileAsset,
+ *         localFile.archive,
+ *     ],
+ * });
+ * ```
  */
 export declare class Command extends pulumi.CustomResource {
     /**
@@ -21,12 +93,113 @@ export declare class Command extends pulumi.CustomResource {
      * when multiple copies of the Pulumi SDK have been loaded into the same process.
      */
     static isInstance(obj: any): obj is Command;
+    /**
+     * If the previous command's stdout and stderr (as generated by the prior create/update) is
+     * injected into the environment of the next run as PULUMI_COMMAND_STDOUT and PULUMI_COMMAND_STDERR.
+     * Defaults to true.
+     */
+    readonly addPreviousOutputInEnv: pulumi.Output<boolean | undefined>;
+    /**
+     * An archive asset containing files found after running the command.
+     */
+    readonly archive: pulumi.Output<pulumi.asset.Archive | undefined>;
+    /**
+     * A list of path globs to return as a single archive asset after the command completes.
+     *
+     * When specifying glob patterns the following rules apply:
+     * - We only include files not directories for assets and archives.
+     * - Path separators are `/` on all platforms - including Windows.
+     * - Patterns starting with `!` are 'exclude' rules.
+     * - Rules are evaluated in order, so exclude rules should be after inclusion rules.
+     * - `*` matches anything except `/`
+     * - `**` matches anything, _including_ `/`
+     * - All returned paths are relative to the working directory (without leading `./`) e.g. `file.text` or `subfolder/file.txt`.
+     * - For full details of the globbing syntax, see [github.com/gobwas/glob](https://github.com/gobwas/glob)
+     *
+     * #### Example
+     *
+     * Given the rules:
+     * ```yaml
+     * - "assets/**"
+     * - "src/**.js"
+     * - "!**secret.*"
+     * ```
+     *
+     * When evaluating against this folder:
+     *
+     * ```yaml
+     * - assets/
+     *   - logos/
+     *     - logo.svg
+     * - src/
+     *   - index.js
+     *   - secret.js
+     * ```
+     *
+     * The following paths will be returned:
+     *
+     * ```yaml
+     * - assets/logos/logo.svg
+     * - src/index.js
+     * ```
+     */
+    readonly archivePaths: pulumi.Output<string[] | undefined>;
+    /**
+     * A list of path globs to read after the command completes.
+     *
+     * When specifying glob patterns the following rules apply:
+     * - We only include files not directories for assets and archives.
+     * - Path separators are `/` on all platforms - including Windows.
+     * - Patterns starting with `!` are 'exclude' rules.
+     * - Rules are evaluated in order, so exclude rules should be after inclusion rules.
+     * - `*` matches anything except `/`
+     * - `**` matches anything, _including_ `/`
+     * - All returned paths are relative to the working directory (without leading `./`) e.g. `file.text` or `subfolder/file.txt`.
+     * - For full details of the globbing syntax, see [github.com/gobwas/glob](https://github.com/gobwas/glob)
+     *
+     * #### Example
+     *
+     * Given the rules:
+     * ```yaml
+     * - "assets/**"
+     * - "src/**.js"
+     * - "!**secret.*"
+     * ```
+     *
+     * When evaluating against this folder:
+     *
+     * ```yaml
+     * - assets/
+     *   - logos/
+     *     - logo.svg
+     * - src/
+     *   - index.js
+     *   - secret.js
+     * ```
+     *
+     * The following paths will be returned:
+     *
+     * ```yaml
+     * - assets/logos/logo.svg
+     * - src/index.js
+     * ```
+     */
+    readonly assetPaths: pulumi.Output<string[] | undefined>;
+    /**
+     * A map of assets found after running the command.
+     * The key is the relative path from the command dir
+     */
+    readonly assets: pulumi.Output<{
+        [key: string]: pulumi.asset.Asset | pulumi.asset.Archive;
+    } | undefined>;
     /**
      * The command to run on create.
      */
     readonly create: pulumi.Output<string | undefined>;
     /**
-     * The command to run on delete.
+     * The command to run on delete. The environment variables PULUMI_COMMAND_STDOUT
+     * and PULUMI_COMMAND_STDERR are set to the stdout and stderr properties of the
+     * Command resource from previous create or update steps.
      */
     readonly delete: pulumi.Output<string | undefined>;
     /**
@@ -42,19 +215,39 @@ export declare class Command extends pulumi.CustomResource {
     } | undefined>;
     /**
      * The program and arguments to run the command.
-     * For example: `["/bin/sh", "-c"]`
+     * On Linux and macOS, defaults to: `["/bin/sh", "-c"]`. On Windows, defaults to: `["cmd", "/C"]`
      */
     readonly interpreter: pulumi.Output<string[] | undefined>;
+    /**
+     * If the command's stdout and stderr should be logged. This doesn't affect the capturing of
+     * stdout and stderr as outputs. If there might be secrets in the output, you can disable logging here and mark the
+     * outputs as secret via 'additionalSecretOutputs'. Defaults to logging both stdout and stderr.
+     */
+    readonly logging: pulumi.Output<enums.local.Logging | undefined>;
     /**
      * The standard error of the command's process
      */
     readonly stderr: pulumi.Output<string>;
+    /**
+     * Pass a string to the command's process as standard in
+     */
+    readonly stdin: pulumi.Output<string | undefined>;
     /**
      * The standard output of the command's process
      */
     readonly stdout: pulumi.Output<string>;
     /**
-     * The command to run on update.
+     * Trigger a resource replacement on changes to any of these values. The
+     * trigger values can be of any type. If a value is different in the current update compared to the
+     * previous update, the resource will be replaced, i.e., the "create" command will be re-run.
+     * Please see the resource documentation for examples.
+     */
+    readonly triggers: pulumi.Output<any[] | undefined>;
+    /**
+     * The command to run on update, if empty, create will
+     * run again. The environment variables PULUMI_COMMAND_STDOUT and PULUMI_COMMAND_STDERR
+     * are set to the stdout and stderr properties of the Command resource from previous
+     * create or update steps.
      */
     readonly update: pulumi.Output<string | undefined>;
     /**
@@ -70,16 +263,107 @@ export declare class Command extends pulumi.CustomResource {
  * The set of arguments for constructing a Command resource.
  */
 export interface CommandArgs {
+    /**
+     * If the previous command's stdout and stderr (as generated by the prior create/update) is
+     * injected into the environment of the next run as PULUMI_COMMAND_STDOUT and PULUMI_COMMAND_STDERR.
+     * Defaults to true.
+     */
+    addPreviousOutputInEnv?: pulumi.Input<boolean>;
+    /**
+     * A list of path globs to return as a single archive asset after the command completes.
+     *
+     * When specifying glob patterns the following rules apply:
+     * - We only include files not directories for assets and archives.
+     * - Path separators are `/` on all platforms - including Windows.
+     * - Patterns starting with `!` are 'exclude' rules.
+     * - Rules are evaluated in order, so exclude rules should be after inclusion rules.
+     * - `*` matches anything except `/`
+     * - `**` matches anything, _including_ `/`
+     * - All returned paths are relative to the working directory (without leading `./`) e.g. `file.text` or `subfolder/file.txt`.
+     * - For full details of the globbing syntax, see [github.com/gobwas/glob](https://github.com/gobwas/glob)
+     *
+     * #### Example
+     *
+     * Given the rules:
+     * ```yaml
+     * - "assets/**"
+     * - "src/**.js"
+     * - "!**secret.*"
+     * ```
+     *
+     * When evaluating against this folder:
+     *
+     * ```yaml
+     * - assets/
+     *   - logos/
+     *     - logo.svg
+     * - src/
+     *   - index.js
+     *   - secret.js
+     * ```
+     *
+     * The following paths will be returned:
+     *
+     * ```yaml
+     * - assets/logos/logo.svg
+     * - src/index.js
+     * ```
+     */
+    archivePaths?: pulumi.Input<pulumi.Input<string>[]>;
+    /**
+     * A list of path globs to read after the command completes.
+     *
+     * When specifying glob patterns the following rules apply:
+     * - We only include files not directories for assets and archives.
+     * - Path separators are `/` on all platforms - including Windows.
+     * - Patterns starting with `!` are 'exclude' rules.
+     * - Rules are evaluated in order, so exclude rules should be after inclusion rules.
+     * - `*` matches anything except `/`
+     * - `**` matches anything, _including_ `/`
+     * - All returned paths are relative to the working directory (without leading `./`) e.g. `file.text` or `subfolder/file.txt`.
+     * - For full details of the globbing syntax, see [github.com/gobwas/glob](https://github.com/gobwas/glob)
+     *
+     * #### Example
+     *
+     * Given the rules:
+     * ```yaml
+     * - "assets/**"
+     * - "src/**.js"
+     * - "!**secret.*"
+     * ```
+     *
+     * When evaluating against this folder:
+     *
+     * ```yaml
+     * - assets/
+     *   - logos/
+     *     - logo.svg
+     * - src/
+     *   - index.js
+     *   - secret.js
+     * ```
+     *
+     * The following paths will be returned:
+     *
+     * ```yaml
+     * - assets/logos/logo.svg
+     * - src/index.js
+     * ```
+     */
+    assetPaths?: pulumi.Input<pulumi.Input<string>[]>;
     /**
      * The command to run on create.
      */
     create?: pulumi.Input<string>;
     /**
-     * The command to run on delete.
+     * The command to run on delete. The environment variables PULUMI_COMMAND_STDOUT
+     * and PULUMI_COMMAND_STDERR are set to the stdout and stderr properties of the
+     * Command resource from previous create or update steps.
      */
     delete?: pulumi.Input<string>;
     /**
-     * The working directory in which to run the command from.
+     * The directory from which to run the command from. If `dir` does not exist, then
+     * `Command` will fail.
      */
     dir?: pulumi.Input<string>;
     /**
@@ -94,7 +378,27 @@ export interface CommandArgs {
      */
     interpreter?: pulumi.Input<pulumi.Input<string>[]>;
     /**
-     * The command to run on update.
+     * If the command's stdout and stderr should be logged. This doesn't affect the capturing of
+     * stdout and stderr as outputs. If there might be secrets in the output, you can disable logging here and mark the
+     * outputs as secret via 'additionalSecretOutputs'. Defaults to logging both stdout and stderr.
+     */
+    logging?: pulumi.Input<enums.local.Logging>;
+    /**
+     * Pass a string to the command's process as standard in
+     */
+    stdin?: pulumi.Input<string>;
+    /**
+     * Trigger a resource replacement on changes to any of these values. The
+     * trigger values can be of any type. If a value is different in the current update compared to the
+     * previous update, the resource will be replaced, i.e., the "create" command will be re-run.
+     * Please see the resource documentation for examples.
+     */
+    triggers?: pulumi.Input<any[]>;
+    /**
+     * The command to run on update, if empty, create will
+     * run again. The environment variables PULUMI_COMMAND_STDOUT and PULUMI_COMMAND_STDERR
+     * are set to the stdout and stderr properties of the Command resource from previous
+     * create or update steps.
      */
     update?: pulumi.Input<string>;
 }