tf-starter 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tf-starter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,421 @@
+# tf-starter
+
+**Enterprise-grade Terraform Infrastructure-as-Code project generator.**
+
+Generate production-ready Terraform projects for AWS, GCP, or Azure in seconds. `tf-starter` scaffolds a complete, modular IaC project with best practices baked in — multi-environment support, remote state, CI/CD pipelines, and more.
+
+```
+  _    __             _              _
+ | |  / _|       ___| |_ __ _ _ __| |_ ___ _ __
+ | __| |_ _____ / __| __/ _` | '__| __/ _ \ '__|
+ | |_|  _|_____|\__ \ || (_| | |  | ||  __/ |
+  \__|_|        |___/\__\__,_|_|   \__\___|_|
+
+  Enterprise Terraform Project Generator v1.0.0
+```
+
+---
+
+## Table of Contents
+
+- [Features](#features)
+- [Supported Providers](#supported-providers)
+- [Available Modules](#available-modules)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Interactive Prompts](#interactive-prompts)
+- [Generated Project Structure](#generated-project-structure)
+- [What Gets Generated](#what-gets-generated)
+- [Module Details](#module-details)
+- [Environment-Aware Configuration](#environment-aware-configuration)
+- [Dependencies & Smart Defaults](#dependencies--smart-defaults)
+- [Requirements](#requirements)
+- [License](#license)
+
+---
+
+## Features
+
+- **Multi-cloud support** — AWS, GCP, and Azure with provider-specific best practices
+- **Interactive CLI** — Guided prompts for environments, services, region, and backend configuration
+- **Modular architecture** — Pick only the services you need; each generates an isolated Terraform module
+- **9 service modules** — Network, Compute, Lambda, API Gateway, Database, Kubernetes, Monitoring, Messaging, Storage
+- **Multi-environment** — Generate separate configurations for dev, staging, prod, or custom environments
+- **Environment-aware defaults** — Production gets HA, multi-AZ, higher resources; dev gets cost-optimized settings
+- **Remote state backend** — Optional S3+DynamoDB (AWS), GCS (GCP), or Azure Storage backend
+- **CI/CD pipeline** — GitHub Actions workflow for Terraform plan/apply with environment-based triggers
+- **Makefile** — Pre-configured `make init`, `make plan`, `make apply`, `make destroy` commands
+- **Pre-commit hooks** — terraform fmt, validate, tflint, and tfsec checks
+- **Auto-generated README** — Project documentation with architecture diagram tailored to selected services
+- **Dependency enforcement** — Kubernetes auto-enables Compute; API Gateway auto-enables Lambda
+- **Jinja2 template engine** — Dynamic rendering with conditional blocks based on selected services
+- **Dual installation** — Install via pip (Python) or npm (Node.js)
+
+---
+
+## Supported Providers
+
+| Provider | Network | Compute | Serverless | Database | Kubernetes | Monitoring | Messaging | Storage |
+|----------|---------|---------|------------|----------|------------|------------|-----------|---------|
+| **AWS** | VPC, Subnets, IGW, NAT | EC2, ALB, ASG | Lambda, API Gateway | RDS PostgreSQL | EKS | CloudWatch, SNS | SQS | S3 |
+| **GCP** | VPC, Subnets, Firewall | GCE, Load Balancer | Cloud Functions, API Gateway | Cloud SQL | GKE | Cloud Monitoring | Pub/Sub | GCS |
+| **Azure** | VNet, Subnets, NSG | VM Scale Sets, LB | Azure Functions, API Management | Azure Database for PostgreSQL | AKS | Azure Monitor | Service Bus | Blob Storage |
+
+---
+
+## Available Modules
+
+| Module | Description | Always Included |
+|--------|-------------|:---------------:|
+| **network** | VPC/VNet, subnets (public + private), internet gateway, NAT, route tables | Yes |
+| **compute** | Virtual machines, load balancer, auto-scaling group, launch templates | No |
+| **lambda** | Serverless functions with IAM roles, CloudWatch logs, VPC deployment option | No |
+| **apigateway** | REST API with proxy integration to Lambda, throttling, CORS, access logging | No |
+| **database** | Managed PostgreSQL with encryption, multi-AZ (prod), automated backups | No |
+| **kubernetes** | Managed Kubernetes cluster with node groups, IAM/RBAC, cluster logging | No |
+| **monitoring** | Alarms, dashboards, log groups, notification topics | No |
+| **messaging** | Message queues with dead-letter queues, encryption, access policies | No |
+| **storage** | Object storage with versioning, encryption, lifecycle rules, public access block | No |
+
+---
+
+## Installation
+
+### Option 1: pip (Python)
+
+```bash
+# Clone the repository
+git clone https://github.com/your-org/tf-starter.git
+cd tf-starter
+
+# Create a virtual environment and install
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e .
+
+# Run
+tf-starter --provider aws --project-name myapp
+```
+
+### Option 2: npm (Node.js)
+
+```bash
+# Clone the repository
+git clone https://github.com/your-org/tf-starter.git
+cd tf-starter
+
+# Install (automatically sets up Python venv via postinstall)
+npm install
+
+# Run
+npx tf-starter --provider aws --project-name myapp
+```
+
+### Option 3: npm global install
+
+```bash
+npm install -g tf-starter
+tf-starter --provider aws --project-name myapp
+```
+
+---
+
+## Usage
+
+### Basic Command
+
+```bash
+tf-starter --provider <aws|gcp|azure> --project-name <name> [--output-dir <path>]
+```
+
+### Arguments
+
+| Argument | Required | Description |
+|----------|:--------:|-------------|
+| `--provider` | Yes | Cloud provider: `aws`, `gcp`, or `azure` |
+| `--project-name` | Yes | Name of the project (alphanumeric, hyphens, underscores) |
+| `--output-dir` | No | Output directory (default: current directory) |
+
+### Examples
+
+```bash
+# Generate an AWS project
+tf-starter --provider aws --project-name my-platform
+
+# Generate a GCP project in a specific directory
+tf-starter --provider gcp --project-name gcp-infra --output-dir ./projects
+
+# Generate an Azure project
+tf-starter --provider azure --project-name azure-stack
+```
+
+---
+
+## Interactive Prompts
+
+After running the command, `tf-starter` guides you through four interactive prompts:
+
+### 1. Environments
+
+```
+? Select environments to create:
+  [x] dev
+  [ ] staging
+  [ ] prod
+  [ ] custom
+```
+
+Select one or more environments. Each gets its own `terraform.tfvars` with environment-specific values. Choose "custom" to enter a custom environment name.
+
+### 2. Services
+
+```
+? Select service categories to enable:
+  [x] Compute     (EC2, ALB, Auto Scaling)
+  [ ] Lambda      (Serverless Functions)
+  [ ] API Gateway (REST API + Lambda Integration)
+  [ ] Database    (RDS PostgreSQL)
+  [ ] Kubernetes  (EKS)
+  [ ] Monitoring  (CloudWatch, SNS)
+  [ ] Messaging   (SQS)
+  [ ] Storage     (S3)
+```
+
+Select the infrastructure modules you need. The **Network** module is always included automatically.
+
+### 3. Region
+
+```
+? Select AWS region:
+  us-east-1
+  us-east-2
+  us-west-1
+  ...
+  Other (type manually)
+```
+
+Choose from common regions or type a custom one.
+
+### 4. Remote Backend
+
+```
+? Enable remote backend (recommended for teams)? (Y/n)
+```
+
+Enables provider-specific remote state storage (S3+DynamoDB for AWS, GCS for GCP, Azure Storage for Azure).
+
+---
+
+## Generated Project Structure
+
+After generation, you get a complete, ready-to-use Terraform project:
+
+```
+my-platform/
+├── main.tf                    # Root module — wires all service modules together
+├── variables.tf               # Root-level variable declarations
+├── outputs.tf                 # Root-level outputs
+├── providers.tf               # Provider configuration
+├── versions.tf                # Terraform & provider version constraints
+├── backend.tf                 # Remote state backend (if enabled)
+├── Makefile                   # make init / plan / apply / destroy
+├── README.md                  # Auto-generated docs with architecture diagram
+├── .pre-commit-config.yaml    # Pre-commit hooks (fmt, validate, tflint, tfsec)
+├── scripts/
+│   └── init.sh                # Backend initialization script
+├── .github/
+│   └── workflows/
+│       └── terraform.yml      # CI/CD pipeline (plan on PR, apply on merge)
+├── modules/
+│   ├── network/               # VPC, subnets, gateways, route tables
+│   │   ├── main.tf
+│   │   ├── variables.tf
+│   │   └── outputs.tf
+│   ├── compute/               # EC2, ALB, ASG (if selected)
+│   ├── lambda/                # Lambda functions (if selected)
+│   ├── apigateway/            # API Gateway (if selected)
+│   ├── database/              # RDS PostgreSQL (if selected)
+│   ├── kubernetes/            # EKS cluster (if selected)
+│   ├── monitoring/            # CloudWatch alarms (if selected)
+│   ├── messaging/             # SQS queues (if selected)
+│   └── storage/               # S3 buckets (if selected)
+└── environments/
+    ├── dev/
+    │   ├── main.tf            # References root module
+    │   ├── variables.tf       # Environment variable declarations
+    │   ├── terraform.tfvars   # Dev-specific values (smaller instances, no HA)
+    │   └── backend.tf         # Environment-specific backend config
+    ├── staging/
+    │   └── ...
+    └── prod/
+        └── ...                # Prod gets HA, multi-AZ, larger instances
+```
+
+---
+
+## What Gets Generated
+
+### Root Module (`main.tf`)
+
+Wires all selected service modules together with proper dependency references. For example, the compute module receives VPC and subnet IDs from the network module.
+
+### Environment Configurations
+
+Each environment gets its own directory with `terraform.tfvars` containing environment-appropriate values. This allows you to run `terraform apply` per environment independently.
+
+### CI/CD Pipeline (`.github/workflows/terraform.yml`)
+
+A GitHub Actions workflow that:
+- Runs `terraform fmt -check` and `terraform validate` on every pull request
+- Runs `terraform plan` on PRs targeting the main branch
+- Runs `terraform apply` on merge to main
+- Supports environment-based deployment strategy
+
+### Makefile
+
+Pre-configured targets for common operations:
+
+```bash
+make init          # Initialize Terraform and backend
+make plan          # Run terraform plan
+make apply         # Apply changes
+make destroy       # Destroy all resources
+make fmt           # Format Terraform files
+make validate      # Validate configuration
+make lint          # Run tflint
+```
+
+### Pre-commit Hooks
+
+Configured checks that run before every git commit:
+- `terraform fmt` — Consistent formatting
+- `terraform validate` — Configuration validation
+- `tflint` — Terraform linter
+- `tfsec` — Security scanner
+
+### Auto-generated README
+
+Each generated project includes a README with:
+- Architecture diagram (dynamically generated based on selected services)
+- Quick-start instructions
+- Module documentation
+- Scaling and operational guidance
+
+---
+
+## Module Details
+
+### AWS Modules
+
+| Module | Resources Created |
+|--------|-------------------|
+| **network** | VPC, 2 public subnets, 2 private subnets, Internet Gateway, NAT Gateway, route tables, elastic IP |
+| **compute** | Application Load Balancer, security groups, launch template (Amazon Linux 2023, IMDSv2), Auto Scaling Group, scaling policies |
+| **lambda** | IAM execution role, Lambda function, CloudWatch log group, optional VPC deployment, conditional SQS/RDS access policies |
+| **apigateway** | REST API, `{proxy+}` catch-all resource, Lambda proxy integration, deployment, stage with throttling/logging, CORS support |
+| **database** | RDS PostgreSQL 16.2, DB subnet group, security group, multi-AZ (prod), encryption at rest, SSM parameter for password, auto-scaling storage |
+| **kubernetes** | EKS cluster, managed node group, IAM roles (cluster + node), cluster logging, security group |
+| **monitoring** | SNS topic, CloudWatch alarms (CPU, storage, connections — conditional on compute/database), log groups with retention |
+| **messaging** | SQS queue, dead-letter queue, redrive policy, server-side encryption, IAM access policy |
+| **storage** | S3 bucket, versioning, AES-256 encryption, public access block, lifecycle rules (Intelligent Tiering, Glacier archival) |
+
+### GCP Modules
+
+| Module | Resources Created |
+|--------|-------------------|
+| **network** | VPC, subnets, firewall rules, Cloud NAT, Cloud Router |
+| **compute** | GCE instances, instance groups, load balancer, health checks |
+| **lambda** | Cloud Functions (2nd Gen), service account, GCS source bucket, Cloud Run IAM |
+| **apigateway** | API Gateway, API config (OpenAPI spec), gateway deployment |
+| **database** | Cloud SQL PostgreSQL, private networking, automated backups |
+| **kubernetes** | GKE cluster, node pools, workload identity |
+| **monitoring** | Cloud Monitoring alert policies, notification channels, log sinks |
+| **messaging** | Pub/Sub topics and subscriptions, dead-letter topics |
+| **storage** | GCS buckets, versioning, lifecycle rules, IAM |
+
+### Azure Modules
+
+| Module | Resources Created |
+|--------|-------------------|
+| **network** | VNet, subnets, NSG, NAT Gateway, public IP |
+| **compute** | VM Scale Sets, load balancer, availability sets |
+| **lambda** | Azure Function App (Linux), App Service Plan, Storage Account, Application Insights, managed identity |
+| **apigateway** | API Management service, API definition, proxy operations, backend configuration, CORS policy |
+| **database** | Azure Database for PostgreSQL Flexible Server, private DNS |
+| **kubernetes** | AKS cluster, node pools, managed identity, Azure CNI |
+| **monitoring** | Azure Monitor, alert rules, action groups, Log Analytics workspace |
+| **messaging** | Service Bus namespace, queues, topics, subscriptions |
+| **storage** | Storage Account, blob containers, lifecycle management |
+
+---
+
+## Environment-Aware Configuration
+
+Generated `terraform.tfvars` files are automatically tuned per environment:
+
+| Setting | Dev | Staging | Prod |
+|---------|-----|---------|------|
+| Instance type | `t3.micro` | `t3.small` | `t3.medium` |
+| Min instances | 1 | 1 | 2 |
+| Max instances | 2 | 3 | 6 |
+| Multi-AZ (DB) | No | No | Yes |
+| DB instance class | `db.t3.micro` | `db.t3.small` | `db.r6g.large` |
+| Lambda memory | 128 MB | 256 MB | 512 MB |
+| Lambda timeout | 30s | 60s | 120s |
+| API throttle rate | 100 rps | 500 rps | 2000 rps |
+| Deploy Lambda in VPC | No | No | Yes |
+| Monitoring retention | 7 days | 14 days | 30 days |
+
+---
+
+## Dependencies & Smart Defaults
+
+`tf-starter` enforces module dependencies automatically:
+
+- **Kubernetes** requires **Compute** — EKS needs VPC networking and node instances. If you select Kubernetes without Compute, Compute is auto-enabled.
+- **API Gateway** requires **Lambda** — The API Gateway module is configured as a Lambda proxy integration. Selecting API Gateway without Lambda auto-enables Lambda.
+- **Network** is always included — All modules depend on VPC/subnet infrastructure.
+
+Conditional cross-module integrations:
+- **Lambda** automatically gets IAM policies for **SQS** access if Messaging is selected
+- **Lambda** automatically gets IAM policies for **RDS** access if Database is selected
+- **Monitoring** generates alarms for **Compute** metrics (CPU) and **Database** metrics (storage, connections) only when those modules are selected
+
+---
+
+## Requirements
+
+- **Python** 3.9 or higher
+- **Node.js** 16+ (only if installing via npm)
+- **Terraform** 1.0+ (to use the generated projects)
+
+### Optional (for generated projects)
+
+- [pre-commit](https://pre-commit.com/) — For pre-commit hooks
+- [tflint](https://github.com/terraform-linters/tflint) — Terraform linter
+- [tfsec](https://github.com/aquasecurity/tfsec) — Security scanner
+
+---
+
+## Quick Start
+
+```bash
+# 1. Install
+git clone https://github.com/your-org/tf-starter.git && cd tf-starter
+npm install
+
+# 2. Generate a project
+npx tf-starter --provider aws --project-name my-platform
+
+# 3. Use the generated project
+cd my-platform
+make init
+make plan
+make apply
+```
+
+---
+
+## License
+
+MIT

package/bin/tf-starter.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+/**
+ * tf-starter — Enterprise Terraform IaC Project Generator
+ *
+ * Thin Node.js wrapper that delegates to the Python CLI.
+ * The Python venv is created automatically during `npm install` (postinstall).
+ */
+
+const { spawn } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+const PKG_ROOT = path.resolve(__dirname, "..");
+const VENV_DIR = path.join(PKG_ROOT, ".venv");
+
+// Resolve the Python binary inside the managed venv
+function getVenvPython() {
+  const isWin = process.platform === "win32";
+  const bin = isWin
+    ? path.join(VENV_DIR, "Scripts", "python.exe")
+    : path.join(VENV_DIR, "bin", "python3");
+  return fs.existsSync(bin) ? bin : null;
+}
+
+// Fallback: try system python
+function getSystemPython() {
+  const candidates = process.platform === "win32"
+    ? ["python", "python3"]
+    : ["python3", "python"];
+
+  for (const cmd of candidates) {
+    try {
+      require("child_process").execSync(`${cmd} --version`, { stdio: "ignore" });
+      return cmd;
+    } catch {
+      // not found, try next
+    }
+  }
+  return null;
+}
+
+function main() {
+  let pythonBin = getVenvPython();
+
+  if (!pythonBin) {
+    // Venv not set up — try system python with the module directly
+    pythonBin = getSystemPython();
+    if (!pythonBin) {
+      console.error(
+        "Error: Python 3.9+ is required but was not found.\n" +
+        "Install Python from https://www.python.org/downloads/ and try again.\n" +
+        "Or run: npm run postinstall"
+      );
+      process.exit(1);
+    }
+
+    console.error(
+      "Warning: tf-starter venv not found. Run `npm run postinstall` to set it up.\n" +
+      `Falling back to system Python: ${pythonBin}\n`
+    );
+  }
+
+  // Forward all CLI arguments to the Python entry point
+  const args = ["-m", "tf_starter.cli", ...process.argv.slice(2)];
+
+  const child = spawn(pythonBin, args, {
+    cwd: PKG_ROOT,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      PYTHONPATH: PKG_ROOT,
+      // Ensure the venv's site-packages are on the path
+      VIRTUAL_ENV: VENV_DIR,
+    },
+  });
+
+  child.on("error", (err) => {
+    console.error(`Failed to start Python process: ${err.message}`);
+    process.exit(1);
+  });
+
+  child.on("close", (code) => {
+    process.exit(code ?? 0);
+  });
+}
+
+main();

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "tf-starter",
+  "version": "1.0.0",
+  "description": "Enterprise-grade Terraform Infrastructure-as-Code project generator",
+  "keywords": [
+    "terraform",
+    "infrastructure-as-code",
+    "iac",
+    "aws",
+    "gcp",
+    "azure",
+    "devops",
+    "scaffolding",
+    "generator"
+  ],
+  "author": "DevOps Team",
+  "license": "MIT",
+  "bin": {
+    "tf-starter": "./bin/tf-starter.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "test": "node bin/tf-starter.js --help"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "tf_starter/",
+    "setup.py"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-org/tf-starter"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+/**
+ * postinstall — creates a Python venv and installs tf-starter dependencies.
+ *
+ * Runs automatically after `npm install`.
+ * Can also be triggered manually: `node scripts/postinstall.js`
+ */
+
+const { execSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+const PKG_ROOT = path.resolve(__dirname, "..");
+const VENV_DIR = path.join(PKG_ROOT, ".venv");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function findPython() {
+  const candidates = process.platform === "win32"
+    ? ["python", "python3"]
+    : ["python3", "python"];
+
+  for (const cmd of candidates) {
+    try {
+      const version = execSync(`${cmd} --version`, { encoding: "utf-8" }).trim();
+      // Ensure it's Python 3.9+
+      const match = version.match(/Python (\d+)\.(\d+)/);
+      if (match) {
+        const major = parseInt(match[1], 10);
+        const minor = parseInt(match[2], 10);
+        if (major >= 3 && minor >= 9) {
+          return cmd;
+        }
+      }
+    } catch {
+      // not found
+    }
+  }
+  return null;
+}
+
+function run(cmd, opts = {}) {
+  console.log(`  $ ${cmd}`);
+  execSync(cmd, { stdio: "inherit", cwd: PKG_ROOT, ...opts });
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+function main() {
+  console.log("\n  tf-starter postinstall — setting up Python environment\n");
+
+  // 1. Find Python
+  const python = findPython();
+  if (!python) {
+    console.warn(
+      "  ⚠  Python 3.9+ not found. tf-starter requires Python.\n" +
+      "     Install Python from https://www.python.org/downloads/\n" +
+      "     Then run: npm run postinstall\n"
+    );
+    // Don't fail the npm install — user may install Python later
+    return;
+  }
+
+  const version = execSync(`${python} --version`, { encoding: "utf-8" }).trim();
+  console.log(`  ✔  Found ${version}\n`);
+
+  // 2. Create venv if it doesn't exist
+  if (!fs.existsSync(VENV_DIR)) {
+    console.log("  Creating Python virtual environment...");
+    run(`${python} -m venv "${VENV_DIR}"`);
+    console.log("  ✔  Virtual environment created\n");
+  } else {
+    console.log("  ✔  Virtual environment already exists\n");
+  }
+
+  // 3. Determine pip path
+  const isWin = process.platform === "win32";
+  const pip = isWin
+    ? path.join(VENV_DIR, "Scripts", "pip.exe")
+    : path.join(VENV_DIR, "bin", "pip3");
+
+  // 4. Upgrade pip
+  console.log("  Upgrading pip...");
+  run(`"${pip}" install --upgrade pip --quiet`);
+
+  // 5. Install the package in editable mode
+  console.log("\n  Installing tf-starter and dependencies...");
+  run(`"${pip}" install -e "${PKG_ROOT}" --quiet`);
+
+  console.log("\n  ✔  tf-starter installed successfully!");
+  console.log("  Usage: tf-starter --provider aws --project-name myapp\n");
+}
+
+try {
+  main();
+} catch (err) {
+  console.error(`\n  ⚠  postinstall failed: ${err.message}`);
+  console.error("     You can retry with: npm run postinstall\n");
+  // Don't fail npm install
+}