Eanvi

EANVI is a developer-first environment variable and secret management platform. It gives engineering teams a shared, encrypted system of record for secrets across local development, CI/CD, and production — without committing .env files or pasting production keys into chat.

The core product idea: the format of a dotenv file is fine; the distribution model is not. Teams still pass keys through Slack, email, shared drives, and drifting gitignored files. Host dashboards (e.g. deploy-time env UIs) are not a team system of record. EANVI fills that gap with per-environment encrypted storage, version history, org RBAC, CLI sync, audit logs, and machine access via API keys / SDK.

Positioning metaphor: treat .env as a local checkout, not the canonical store. Pull what you need; keep production keys out of git, Slack, and Downloads folders.

Typical team secret workflows fail in predictable ways:

• Secrets are copied between people and environments with no ownership or history
• Local and production values drift silently
• Reveal/access is rarely audited
• CI and local machines each invent their own copy of the same keys
• “Just use the host dashboard” only helps at deploy time, not for day-to-day collaboration

EANVI was built so secrets live in one encrypted workspace, with roles, environments, CLI sync, and an audit trail.

1. Secret management

• Create, update, delete, duplicate, and restore secrets
• Values encrypted at rest (AES-256-GCM); lists show masked values by default
• Explicit reveal (audited) for plaintext access
• Metadata: descriptions, tags
• Per-secret version history with restore of prior values

2. Environments

• Isolated secret sets per project: development, staging, production, testing, custom
• Archive / restore / duplicate environments
• Local overrides cannot silently overwrite production because environments are independent

3. Team collaboration

• Organizations (workspaces) as the tenant boundary
• Email invites; leave / ownership transfer
• Roles: Owner, Admin, Collaborator, Member
• Project visibility: private / internal

4. CLI sync (eanvi)

Developer workflow mirrors git-like checkout semantics:

Optimistic concurrency on push (base version checks) reduces silent overwrite races.

5. Audit logs

Immutable activity for secrets, reveals, members, billing, and sensitive ops — filterable, with plan-based retention (e.g. 7 / 30 / 90 days).

6. Import / export

Migrate from .env, JSON, or YAML with conflict preview; export masked or revealed as needed.

Additional platform modules

• Auth: email/password, GitHub & Google OAuth, magic link, verify email, password reset, invite accept
• API keys: machine tokens (eanvi_sk_...) for CLI / CI / SDK
• Global search: projects, secret keys (not values), members, orgs, audit — Cmd+K
• Notifications: in-app (Ably realtime) + email (Resend) for secret/member/security/billing events
• Billing: Free / Pro / Team via Paddle (checkout, webhooks, seats, invoices); billing accounts can be personal or company and span orgs
• Marketing + docs: landing, features, pricing, about, FAQ, blog, legal, in-app markdown docs
• Sessions / security: tracked sessions (device/IP), revoke, security-alert emails

User
 └── Member → Organization (workspace)
                └── Project
                     └── Environment
                          └── Secret
                               └── SecretVersion

BillingAccount (PERSONAL | COMPANY)
 └── Subscription / seats / invoices
 └── one or more Organizations (plan limits inherited)

Supporting entities: invites, audit logs, API keys, notifications, billing account members, webhook events.

Local binding: .eanvi/config.json ties a working directory to project + environment + env file path. Credentials live under ~/.eanvi/ for CLI sessions.

Monorepo (npm workspaces + Turborepo):

Request flow (layered):

UI → Feature modules → Hooks / Server Actions / API client
  → Route handlers
  → Services → Repositories → Prisma → PostgreSQL

Pages do not import Prisma directly. Cross-cutting concerns live under server/ (auth, encryption, permissions, email, realtime, Paddle, validation).

Feature modules under apps/web/features/{name}/ typically include components, hooks, actions, schemas, services, repositories, types, and constants.

App Router groups: marketing, auth, dashboard, plus domain-grouped app/api/* (orgs, projects, secrets, CLI, billing, realtime, etc.).

Dependency direction: config → ui & sdk → web; cli → sdk only (no React/Prisma in public clients).

• Encryption: AES-256-GCM; stored as base64(iv + authTag + ciphertext); HKDF-derived master key; rotation support via a new master key env; secret values never appear in list/audit as plaintext
• Multi-tenant RBAC: org-scoped data, active-org context, permission helpers for org/project/env/secret/audit/billing
• Dual access paths: browser sessions (Auth.js / NextAuth v5 + Prisma adapter) and machine auth (Bearer / x-eanvi-api-key)
• Reveal is explicit and audited — masked by default in UI and CLI list
• Realtime notifications via Ably; transactional email via Resend + React Email
• SaaS billing with Paddle (HMAC-verified webhooks, seat quantity)
• Production DB path: Neon serverless Postgres with Prisma adapter; local Docker Postgres for development
• Deploy story: multi-stage Docker (Next standalone), GitHub Actions CI (lint, typecheck, build)

• Free — limited orgs/projects/envs/secrets, short audit retention, CLI/API
• Pro — higher/unlimited project & env limits, version history, import/export, longer audit
• Team — seat-based billing, multi-workspace governance, longest audit retention

(Exact limits are defined in marketing/billing plan constants and may evolve.)

As the sole engineer on this project, ownership spanned:

1. Product design — positioning, UX copy, Free/Pro/Team packaging, CLI-as-checkout mental model
2. System design — multi-tenant org model, billing account above orgs, encryption module, layered service/repository architecture
3. Full-stack web app — dashboard, marketing site, docs, Auth.js flows, search, notifications, settings
4. Secrets domain — environments, versioning, reveal/audit, import/export
5. Public developer surface — TypeScript SDK + CLI with sync/diff/concurrency
6. Monetization — Paddle checkout, webhooks, seats, plan limits
7. Design system — shared @eanvi/ui, brand lockup rules, semantic tokens
8. Ops foundations — Prisma schema, Docker, CI, env/encryption key surface