SIDDARTHA577/envguard-node / .agents/skills/envguard-production-readiness
envguard-production-readiness
VerifiedGuides comprehensive, evidence-based application production readiness assessments across environment configuration, build and tests, security posture, API contracts, database persistence, and operational reliability.
envguard-production-readiness Skill
Guides engineers and AI agents in conducting rigorous, evidence-based application production readiness assessments. Audits real project configurations across environment security, build and test verification, security boundaries, REST/OpenAPI contracts, database persistence, and operational reliability. Distinguishes verified facts, warnings, blocking failures, and unverified assumptions without claiming absolute certification.
When to Trigger
- Evaluating an application, service, or API for deployment readiness before shipping to staging or production.
- Running the standalone EnvGuard Readiness Auditor (
tools/readiness-auditor.mjs) on a local repository. - Generating structured production readiness reports (machine-readable JSON and human-readable Markdown).
- Auditing operational configurations including health checks, graceful shutdown handlers, containerization, and CI/CD pipelines.
- Formulating a prioritized remediation plan for critical deployment blockers and security risks.
When NOT to Trigger
- Designing high-level distributed architecture from scratch before code exists (use
envguard-system-design). - Setting up initial EnvGuard environment validation for the first time (use
envguard-setup). - Conducting focused WCAG screen reader accessibility testing exclusively (use
envguard-accessibility). - Writing raw database migrations or tuning SQL indexes in isolation (use
envguard-database).
Supported Projects & Environments
- Runtimes: Node.js (22.x, 24.x, 26.x), Bun, TypeScript, modern JavaScript (ESM / CommonJS), Python (3.10+), Java (17, 21, 25 LTS), Dart (3.x), Kotlin/Java (Android), Swift (iOS).
- Web, Backend & Mobile Frameworks: Express, Fastify, Next.js, NestJS, React, Vue, Svelte, Django, FastAPI, Flask, Spring Boot (Maven & Gradle), React Native, Expo, Flutter, Android Native, iOS Native.
- Container & Deployment Tech: Docker, Docker Compose, Kubernetes, Gunicorn, Uvicorn, GitHub Actions, GitLab CI.
- Operating Systems: Linux (Ubuntu/Debian), macOS, Windows.
Supported Platform Adapters
The Readiness Analyzer employs modular platform adapters that automatically resolve based on repository artifacts:
- Generic Platform Adapter (
GenericAdapter): Baseline environment security (.env, .gitignore), Containerfile inspection, CI workflow audits, and SARIF static analysis import. - Node.js & TypeScript Adapter (
NodeTypeScriptAdapter): Dependency vulnerability tooling, TypeScript configurations, standard REST server patterns, Prisma/Drizzle/TypeORM migrations and composite indexing, and SQL injection prevention. - Next.js & React Adapter (
NextJsReactAdapter): Server Actions security, client/server boundary leakage prevention (NEXT_PUBLIC_), Image optimization, and React error boundaries. - Python Platform Adapter (
PythonAdapter): Django (manage.py,settings.py), FastAPI, and Flask projects. Checks include:- Packaging and lockfiles (
pyproject.toml,requirements.txt,poetry.lock,uv.lock,Pipfile). - Runtime version constraints (PEP 621
requires-python = ">=3.11"or.python-version). - Production
DEBUG = Falseand cryptographicSECRET_KEYloading from environment. - Host header guardrails (
ALLOWED_HOSTS). - Session and CSRF cookie flags (
SESSION_COOKIE_SECURE,CSRF_COOKIE_SECURE). - SQL injection defenses (prohibits f-string or
%formatting incursor.execute()). - Django
CsrfViewMiddlewareenforcement and CORS origin boundaries. - Database migrations (Django
migrations/and Alembicalembic.ini). - Automated test suite configuration (pytest / unittest).
- Production WSGI/ASGI application servers (Gunicorn / Uvicorn).
- Packaging and lockfiles (
- Java & Spring Boot Adapter (
JavaSpringBootAdapter): Spring Boot applications with Maven (pom.xml) or Gradle (build.gradle,build.gradle.kts). Checks include:- Build descriptors and wrapper scripts (
mvnw,gradlew). - Explicit target Java versions (
<java.version>21</java.version>,sourceCompatibility = '21'). - Spring Actuator endpoint security (flags wildcard
exposure.include=*). - Spring Security authorization rules (flags
anyRequest().permitAll()). - Cryptographic password encoding (flags plaintext
NoOpPasswordEncoder). - Externalized database credentials (flags plaintext
spring.datasource.password). - Safe JPA/Hibernate
ddl-automodes (flags destructivecreate,create-drop, andupdatein favor ofvalidateornone). - Versioned database migration frameworks (Flyway in
db/migrationor Liquibase indb/changelog). - SQL injection defenses (flags raw string concatenation in
createNativeQuery()orcreateQuery()). - Automated JUnit 5 test suites.
- Build descriptors and wrapper scripts (
- React Native & Expo Adapter (
ReactNativeAdapter): React Native and Expo mobile applications. Standardized OWASP MASVS v2.0 mapping:- Hardware-backed key storage (
expo-secure-storeorreact-native-keychainover unencryptedAsyncStorage). - Deep link scheme validation (
prefixesor custom schemes without wildcards). - Origin-restricted WebView configurations (
originWhitelistprohibiting['*']). - Production log stripping (eliminates sensitive
console.login production bundles). - React error boundaries, NetInfo network resilience, and AppState lifecycle listeners.
- Hardware-backed key storage (
- Flutter & Dart Adapter (
FlutterAdapter): Flutter cross-platform applications:- Sound null safety in Dart SDK constraints (
>=3.0.0 <4.0.0) and locked dependencies (pubspec.lock). - Secure token storage (
flutter_secure_storageover cleartextshared_preferences). - Static analysis linter rules (
analysis_options.yamlwithflutter_lints). - Uncaught asynchronous error handlers (
runZonedGuarded/PlatformDispatcher.onError). - State controller resource disposal (
dispose()onTextEditingController,AnimationController,StreamController).
- Sound null safety in Dart SDK constraints (
- Android Native Adapter (
AndroidAdapter): Kotlin and Java Android native applications:- App manifest security:
targetSdk >= 33,android:allowBackup="false",android:usesCleartextTraffic="false", network security config. - Unprotected exported components audit (verifies
android:exported="true"has explicitandroid:permission). - Encrypted token storage (
androidx.security:security-cryptoEncryptedSharedPreferences). - Release signing security (verifies release keystore passwords are not committed in plaintext).
- Code obfuscation and shrinking (
minifyEnabled truewithproguard-rules.pro).
- App manifest security:
- iOS & Apple Native Adapter (
IosAdapter): Swift and Objective-C iOS applications:- Minimum deployment target (
IPHONEOS_DEPLOYMENT_TARGET/Package.swiftplatforms >= iOS 15.0). - App Transport Security (ATS) enforcement (flags
NSAllowsArbitraryLoads = true). - iOS Keychain Services token storage (
SecItemAdd/SecItemCopyMatchingover cleartextUserDefaults). - Apple Privacy Manifest compliance (
PrivacyInfo.xcprivacywith declared tracking and required reason APIs). - Objective, honest test evaluation: Marks native macOS
xcodebuildasNOT_RUNon non-macOS runners with explicit prerequisite guidance.
- Minimum deployment target (
Required Tools & Permissions
- Tools: File reader, file writer, command runner (
read_file,write_file,run_command). - Permissions: Project workspace read-only permission by default. Explicit authorization (
--allow-exec) required to execute local build, test, or lint commands. - Subprocess Safeguards: Command timeouts (10s default), sanitized stdout/stderr, non-elevated privileges.
Expected Inputs
- Target project repository root directory.
- Optional scope parameter specifying categories:
discovery,env,build_test,security,api,database,deployment,accessibility,performance. - Execution authorization grant (
--allow-exec) if dynamic command verification is requested by the user.
Step-by-Step Workflow
Step 1: Pre-Flight Safety & Authorization Check
- Confirm the target directory is safe and contained within the authorized project root (prevent path traversal).
- Determine execution mode:
- Default (Read-Only): Static inspection of configurations, manifests, schemas, and source code. Test/build execution is reported as
NOT_RUN. - Authorized (
--allow-exec): Explicitly permitted execution of declaredpackage.jsonscripts (build,test,typecheck,lint) with bounded timeouts.
- Default (Read-Only): Static inspection of configurations, manifests, schemas, and source code. Test/build execution is reported as
- Rule: Never run arbitrary untrusted scripts, database drop commands, or unapproved network requests.
Step 2: Execute Readiness Scan
- Locate the readiness auditor script in your workspace:
- If installed via skill pack (.agents):
node .agents/skills/envguard-production-readiness/scripts/readiness-auditor.mjs - If installed via Antigravity/Claude (skills):
node skills/envguard-production-readiness/scripts/readiness-auditor.mjs - If running in EnvGuard repository checkout:
node tools/readiness-auditor.mjs
- If installed via skill pack (.agents):
- Preview planned commands and potential effects without execution:
node .agents/skills/envguard-production-readiness/scripts/readiness-auditor.mjs scan --project ./my-app --preview-commands - Run standard read-only assessment:
node .agents/skills/envguard-production-readiness/scripts/readiness-auditor.mjs scan --project ./my-app --format both --output-dir ./reports - Import external SAST / CodeQL results via SARIF:
node .agents/skills/envguard-production-readiness/scripts/readiness-auditor.mjs scan --project ./my-app --sarif ./results.sarif --format both --output-dir ./reports - Run authorized verification in container isolation or with explicit host trust:
node .agents/skills/envguard-production-readiness/scripts/readiness-auditor.mjs scan --project ./my-app --allow-exec --trust-project --format both --output-dir ./reports
Step 3: Nine Modular Assessment Dimensions
- Project Discovery: Detects manifest (
package.json), runtime versions (engines.node,.nvmrc), lockfiles (package-lock.json,pnpm-lock.yaml), and frameworks. - Environment Configuration: Verifies template presence (
.env.example),.gitignoreexclusions for.env, startup schema validation (guard()), and flags hardcoded secrets. - Build & Test Readiness: Verifies passing status for build, test, lint, and typecheck scripts. When unapproved, marks as
NOT_RUN. - Security Readiness: Audits automated dependency update tooling (Dependabot/Renovate), sensitive logging patterns, security headers (
helmet), CORS, cookie security (httpOnly,secure,sameSite), hardcoded JWT secrets, multi-tenant query isolation, administrative route authorization, and SARIF static analysis import. - API Contract Readiness: Validates OpenAPI 3.x schema structure, RFC 7807/9457 Problem Details error models, RESTful URL naming, collection pagination limits, rate limiting middleware, and mutation idempotency.
- Database Readiness: Checks for database driver/ORM presence, versioned schema migrations with rollback support (
migrations/*.down.sql), foreign key relation indexes, and parameterized query enforcement against raw SQL injection. - Deployment & Operations: Verifies containerization (
Dockerfile), health check routes (/health), graceful shutdown signal listeners (SIGTERM), and CI workflows. - Accessibility & Frontend: Detects accessibility tooling (
eslint-plugin-jsx-a11y,axe-core), route error boundaries (error.tsx), accessible form feedback, and flags screen reader navigation asMANUAL_REVIEW. - Performance Readiness: Identifies load test scripts (k6) and flags live synthetic traffic generation as
NOT_RUN.
Step 4: Interpret Standardized Findings
Analyze findings categorized by the standardized status taxonomy:
- PASS: Verified passing criteria backed by static evidence or successful command execution.
- FAIL: Concrete blocking defect (e.g. failing test suite, unignored
.envfile, malformed OpenAPI spec). - WARNING: Potential architectural risk or missing convention (e.g. missing
/healthroute, unconfigured Dependabot). - NOT_RUN: Check intentionally skipped due to lack of execution authorization or unavailable staging infrastructure.
- MANUAL_REVIEW: Finding requiring human inspection (e.g. database failover policy, keyboard screen-reader testing).
- NOT_APPLICABLE: Check irrelevant to project type (e.g. frontend checks on headless worker microservices).
Step 5: Route Findings to Specialized EnvGuard Skills
Connect identified issues with focused EnvGuard skills for specialized remediation:
- Environment variable leaks or missing templates -> Route to
envguard-auditorenvguard-setuporenvguard-review. - Failing CI/CD pipelines -> Route to
envguard-ci. - OpenAPI schema violations or missing RFC 7807 models -> Route to
envguard-api-design. - Logic bugs, memory leaks, or test gaps -> Route to
envguard-code-review. - UI token inconsistency or layout defects -> Route to
envguard-ui-design. - WCAG keyboard trap or contrast failures -> Route to
envguard-accessibility. - Backend route structure or graceful shutdown -> Route to
envguard-backend. - Database schema migration planning -> Route to
envguard-database.
Validation Steps
- Verify that both machine-readable JSON (
readiness-report.json) and Markdown (readiness-report.md) reports are generated. - Ensure that zero real passwords, tokens, or environment values are printed in logs or reports.
- Verify that
NOT_RUNchecks are never falsely classified asPASS. - Confirm that no overall "readiness percentage" is fabricated.
Expected Outputs
readiness-report.json: Versioned JSON assessment conforming tocatalog/readiness-report.schema.json.readiness-report.md: Structured Markdown report including Executive Summary, Blockers, Warnings, Passed Checks, Manual Review Items, and Prioritized Remediation Plan.- Concrete terminal summary with clean exit code behavior (0 = all passing/warnings, 2 = blocking failures exist).
Failure Handling
- If target project
package.jsonis missing or malformed, record a criticalDISC-001failure and evaluate remaining files rather than crashing. - If a project command times out during
--allow-exec, capture timeout evidence and record aFAILstatus without hanging the process.
Safety & Privacy Boundaries
- NEVER inspect private
.envfiles or display real environment variable secrets. - NEVER execute production database migrations or connect to live customer databases during readiness analysis.
- NEVER run high-load performance traffic tests against production environments.
- Subprocess execution is strictly gated behind explicit
--allow-execauthorization.
Example User Prompts
- "Analyze my full-stack application for production readiness with envguard-production-readiness"
- "Run the readiness auditor on our backend API in read-only mode and list all blocking issues"
- "Generate a complete production readiness report with authorized test execution using --allow-exec"
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit. | Stars: 466k | Updated | Claude CodeCodex | Verified | Install |
| rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure. | Stars: 466k | Updated | Claude CodeCodex | Verified | Install |
| rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics. | Stars: 466k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first. | Stars: 192k | Updated | Claude CodeCodex | Verified | Install |