@pulumi/command 0.0.1-alpha.100

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,400 @@
+[![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.
+
+There are many scenarios where the Command package can be useful:
+
+* Running a command locally after creating a resource, to register it with an external service
+* Running a command locally before deleting a resource, to deregister it with an external service
+* Running a command remotely on a remote host immediately after creating it
+* Copying a file to a remote host after creating it (potentially as a script to be executed afterwards)
+* As a simple alternative to some use cases for Dynamic Providers (especially in languages which do not yet support Dynamic Providers).
+
+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, 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.
+
+
+> **NOTE**: The Command package is in preview.  The API design may change ahead of general availability based on [user feedback](https://github.com/pulumi/pulumi-command/issues). 
+
+## Examples
+
+### A simple local resource (random)
+
+The simplest use case for `local.Command` is to just run a command on `create`, which can return some value which will be stored in the state file, and will be persistent for the life of the stack (or until the resource is destroyed or replaced).  The example below uses this as an alternative to the `random` package to create some randomness which is stored in Pulumi state.
+
+```ts
+import { local } from "@pulumi/command";
+
+const random = new local.Command("random", {
+    create: "openssl rand -hex 16",
+});
+
+export const output = random.stdout;
+```
+
+```go
+package main
+
+import (
+	"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.CommandInput{
+			Create: pulumi.String("openssl rand -hex 16"),
+		})
+		if err != nil {
+			return err
+		}
+
+		ctx.Export("output", random.Stdout)
+		return nil
+	})
+}
+```
+
+### Remote provisioning of an EC2 instance
+
+This example creates and EC2 instance, and then uses `remote.Command` and `remote.CopyFile` to run commands and copy files to the remote instance (via SSH). Similar things are possible with Azure, Google Cloud and other cloud provider virtual machines.  Support for Windows-based VMs is being tracked [here](https://github.com/pulumi/pulumi-command/issues/15).
+
+Note that implicit and explicit (`dependsOn`) dependencies can be used to control the order that these `Command` and `CopyFile` resources are constructed relative to each other and to the cloud resources they depend on.  This ensures that the `create` operations run after all dependencies are created, and the `delete` operations run before all dependencies are deleted.
+
+Because the `Command` and `CopyFile` resources replace on changes to their connection, if the EC2 instance is replaced, the commands will all re-run on the new instance (and the `delete` operations will run on the old instance).
+
+Note also that `deleteBeforeReplace` can be composed with `Command` resources to ensure that the `delete` operation on an "old" instance is run before the `create` operation of the new instance, in case a scarce resource is managed by the command.  Similarly, other resource options can naturally be applied to `Command` resources, like `ignoreChanges`.
+
+```ts
+import { interpolate, Config } from "@pulumi/pulumi";
+import { local, remote, types } from "@pulumi/command";
+import * as aws from "@pulumi/aws";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { size } from "./size";
+
+const config = new Config();
+const keyName = config.get("keyName") ?? new aws.ec2.KeyPair("key", { publicKey: config.require("publicKey") }).keyName;
+const privateKeyBase64 = config.get("privateKeyBase64");
+const privateKey = privateKeyBase64 ? Buffer.from(privateKeyBase64, 'base64').toString('ascii') : fs.readFileSync(path.join(os.homedir(), ".ssh", "id_rsa")).toString("utf8");
+
+const secgrp = new aws.ec2.SecurityGroup("secgrp", {
+    description: "Foo",
+    ingress: [
+        { protocol: "tcp", fromPort: 22, toPort: 22, cidrBlocks: ["0.0.0.0/0"] },
+        { protocol: "tcp", fromPort: 80, toPort: 80, cidrBlocks: ["0.0.0.0/0"] },
+    ],
+});
+
+const ami = aws.ec2.getAmiOutput({
+    owners: ["amazon"],
+    mostRecent: true,
+    filters: [{
+        name: "name",
+        values: ["amzn2-ami-hvm-2.0.????????-x86_64-gp2"],
+    }],
+});
+
+const server = new aws.ec2.Instance("server", {
+    instanceType: size,
+    ami: ami.id,
+    keyName: keyName,
+    vpcSecurityGroupIds: [secgrp.id],
+}, { replaceOnChanges: ["instanceType"] });
+
+// Now set up a connection to the instance and run some provisioning operations on the instance.
+
+const connection: types.input.remote.ConnectionInput = {
+    host: server.publicIp,
+    user: "ec2-user",
+    privateKey: privateKey,
+};
+
+const hostname = new remote.Command("hostname", {
+    connection,
+    create: "hostname",
+});
+
+new remote.Command("remotePrivateIP", {
+    connection,
+    create: interpolate`echo ${server.privateIp} > private_ip.txt`,
+    delete: `rm private_ip.txt`,
+}, { deleteBeforeReplace: true });
+
+new local.Command("localPrivateIP", {
+    create: interpolate`echo ${server.privateIp} > private_ip.txt`,
+    delete: `rm private_ip.txt`,
+}, { deleteBeforeReplace: true });
+
+const sizeFile = new remote.CopyFile("size", {
+    connection,
+    localPath: "./size.ts",
+    remotePath: "size.ts",
+})
+
+const catSize = new remote.Command("checkSize", {
+    connection,
+    create: "cat size.ts",
+}, { dependsOn: sizeFile })
+
+export const confirmSize = catSize.stdout;
+export const publicIp = server.publicIp;
+export const publicHostName = server.publicDns;
+export const hostnameStdout = hostname.stdout;
+```
+
+### Invoking a Lambda during Pulumi deployment
+
+There may be cases where it is useful to run some code within an AWS Lambda or other serverless function during the deployment.  For example, this may allow running some code from within a VPC, or with a specific role, without needing to have persistent compute available (such as the EC2 example above).
+
+Note that the Lambda function itself can be created within the same Pulumi program, and then invoked after creation.  
+
+The example below simply creates some random value within the Lambda, which is a very roundabout way of doing the same thing as the first "random" example above, but this pattern can be used for more complex scenarios where the Lambda does things a local script could not.
+
+```ts
+import { local } from "@pulumi/command";
+import * as aws from "@pulumi/aws";
+import * as crypto from "crypto";
+
+const f = new aws.lambda.CallbackFunction("f", {
+    publish: true,
+    callback: async (ev: any) => {
+        return crypto.randomBytes(ev.len/2).toString('hex');
+    }
+});
+
+const rand = new local.Command("execf", {
+    create: `aws lambda invoke --function-name "$FN" --payload '{"len": 10}' --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: "",
+    },
+})
+
+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`/`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.
+
+```ts
+import * as pulumi from "@pulumi/pulumi";
+import * as random from "@pulumi/random";
+import { local } from "@pulumi/command";
+
+interface LabelArgs {
+    owner: pulumi.Input<string>;
+    repo: pulumi.Input<string>;
+    name: pulumi.Input<string>;
+    githubToken: pulumi.Input<string>;
+}
+
+class GitHubLabel extends pulumi.ComponentResource {
+    public url: pulumi.Output<string>;
+
+    constructor(name: string, args: LabelArgs, opts?: pulumi.ComponentResourceOptions) {
+        super("example:github:Label", name, args, opts);
+
+        const label = new local.Command("label", {
+            create: "./create_label.sh",
+            delete: "./delete_label.sh",
+            environment: {
+                OWNER: args.owner,
+                REPO: args.repo,
+                NAME: args.name,
+                GITHUB_TOKEN: args.githubToken,
+            }
+        }, { parent: this });
+
+        const response = label.stdout.apply(JSON.parse);
+        this.url = response.apply((x: any) => x.url as string);
+    }
+}
+
+const config = new pulumi.Config();
+const rand = new random.RandomString("s", { length: 10, special: false });
+
+const label = new GitHubLabel("l", {
+    owner: "pulumi",
+    repo: "pulumi-command",
+    name: rand.result,
+    githubToken: config.requireSecret("githubToken"),
+});
+
+export const labelUrl = label.url;
+```
+
+```sh
+# create_label.sh
+curl \
+  -s \
+  -X POST \
+  -H "authorization: Bearer $GITHUB_TOKEN" \
+  -H "Accept: application/vnd.github.v3+json" \
+  https://api.github.com/repos/$OWNER/$REPO/labels \
+  -d "{\"name\":\"$NAME\"}"
+```
+
+```sh
+# delete_label.sh
+curl \
+  -s \
+  -X DELETE \
+  -H "authorization: Bearer $GITHUB_TOKEN" \
+  -H "Accept: application/vnd.github.v3+json" \
+  https://api.github.com/repos/$OWNER/$REPO/labels/$NAME
+```
+
+### Graceful cleanup of workloads in a Kubernetes cluster
+
+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 * as pulumi from "@pulumi/pulumi";
+import * as command from "@pulumi/command";
+import * as eks from "@pulumi/eks";
+
+const cluster = new eks.Cluster("cluster", {});
+
+// We could also use `RemoteCommand` to run this from within a node in the cluster
+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 --kubeconfig <(echo \"$KUBECONFIG_DATA\") delete namespace nginx\n",
+    // Process substitution "<()" doesn't work in the default interpreter sh.
+    interpreter: [
+        "/bin/bash",
+        "-c",
+    ],
+    environment: {
+        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.17
+- NodeJS 10.X.X or later
+- Python 3.6 or later
+- .NET Core 3.1
+
+Please refer to [Contributing to Pulumi](https://github.com/pulumi/pulumi/blob/master/CONTRIBUTING.md) for installation
+guidance.
+
+### Building locally
+
+Run the following commands to install Go modules, generate all SDKs, and build the provider:
+
+```
+$ make ensure
+$ make build
+$ make install
+```
+
+Add the `bin` folder to your `$PATH` or copy the `bin/pulumi-resource-command` file to another location in your `$PATH`.
+
+### Running an example
+
+Navigate to the simple example and run Pulumi:
+
+```
+$ cd examples/simple
+$ yarn link @pulumi/command
+$ yarn install
+$ pulumi up
+```
+

package/index.d.ts

@@ -0,0 +1,7 @@
+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";
+export { local, remote, types, };

package/index.js

@@ -0,0 +1,26 @@
+"use strict";
+// *** WARNING: this file was generated by pulumi-language-nodejs. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.types = exports.remote = exports.local = exports.Provider = void 0;
+const pulumi = require("@pulumi/pulumi");
+const utilities = require("./utilities");
+exports.Provider = null;
+utilities.lazyLoad(exports, ["Provider"], () => require("./provider"));
+// Export sub-modules:
+const local = require("./local");
+exports.local = local;
+const remote = require("./remote");
+exports.remote = remote;
+const types = require("./types");
+exports.types = types;
+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 exports.Provider(name, undefined, { urn });
+    },
+});
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"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"}