Forem: badcaptain0001

ENVCRYPT: A Zero-Knowledge .env Vault for Fast-Moving Dev Teams

badcaptain0001 — Sat, 28 Feb 2026 14:19:00 +0000

This is a submission for the DEV Weekend Challenge: Community.

The Community

I built this for developers who move fast and pass secrets around constantly across local/dev/staging/prod.

This is especially useful for:

Indie hackers and solo builders
Small startup engineering teams
Students and hackathon teams
Anyone currently storing secrets in plaintext files, chat apps, or notes

The goal was simple: keep the workflow fast, but remove plaintext secret handling.

What I Built

I built ENVCRYPT (Envault), a zero-knowledge environment variable vault.

Core idea

Secrets are encrypted in the browser before storage, so the backend only receives ciphertext.

Main features

Google/GitHub OAuth login
Project-based secret organization
Add single variables or bulk import from .env
Client-side encryption with Argon2id + AES-256-GCM
Ciphertext-only storage (value_encrypted)
In-memory key handling + auto-lock
One-click .env export (decrypted in-browser)

Security model

API rejects plaintext value payloads
Database stores encrypted values only
RLS policies isolate user data
Even with a DB leak, attacker gets ciphertext without your decryption key

Demo

Live app: https://envcrypt.vercel.app/

Code

GitHub repo: https://github.com/badcaptain0001/envault

How I Built It

Stack

Next.js 16 (App Router, TypeScript)
React 19
Tailwind CSS v4 + shadcn/ui
Supabase (Auth + Postgres + RLS)
hash-wasm (Argon2id) + Web Crypto API (AES-256-GCM)
Zustand
Vitest

Implementation highlights

Derive encryption key locally from master password with Argon2id
Encrypt each secret with AES-GCM + random IV
Persist only encrypted payloads
Decrypt only in-browser during explicit export action

GitHub Copilot CLI Challenge Git Workflow Automator

badcaptain0001 — Sun, 15 Feb 2026 01:53:30 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I built Git Workflow Automator (GWA), a terminal-first Python CLI to simplify common Git workflows.

It provides a single interface for:

gwa start (start branch workflow)
gwa commit (commit flow)
gwa sync (sync with remote)
gwa pr (PR workflow)
gwa doctor (diagnostics)

I built this because Git workflows are repetitive and easy to break under pressure.

The goal was to reduce friction and make daily Git operations faster from the terminal.

Demo

GitHub Repo: https://github.com/badcaptain0001/gcli-zero
Video Walkthrough: https://drive.google.com/file/d/1QzVznGCSWH2MQE4eKfd3EW6ZR6hmQhbX/view?usp=sharing
Optional Screenshots:

Run locally:

git clone https://github.com/badcaptain0001/gcli-zero.git
cd gcli-zero
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -U pip setuptools wheel
python -m pip install -e '.[dev]'
pytest -q
gwa --help

My Experience with GitHub Copilot CLI

I used Copilot CLI iteratively while building the project.

Key prompts I used:

Scaffold a Python CLI project from scratch named git-workflow-automator with src package layout, tests folder, pyproject.toml, and a console script named gwa.
Generate minimal starter code for the package and CLI entrypoint using argparse.
Add commands start, commit, sync, pr, and doctor with dry-run support.
Create pydantic-based configuration loading from .gwa.toml with sensible defaults.
Add policy enforcement for branch naming and conventional commit message validation.
Add JSONL audit logging under .git/gwa/audit.jsonl with timestamp, command, status, and metadata.
Create pytest tests for config, policy, audit, and a basic integration flow.
Improve README with installation, usage, and testing instructions.

Copilot CLI sped up scaffolding and first-pass implementation.

I manually reviewed and refined code for behavior, reliability, and test coverage.

Detailed prompt-by-prompt notes are in COPILOT_LOG.md.

I Built a VS Code Extension That Tracks Real Coding Time

badcaptain0001 — Sat, 14 Feb 2026 05:09:34 +0000

I made Lync Life, a VS Code extension + web dashboard that tracks coding time automatically and tries to count only real coding activity (with better idle/suspend handling).
Product: lync.life
What it does:

automatic tracking in VS Code
syncs to cloud dashboard
daily session/time insights
API-key based setup
I’m still improving sync edge cases (reinstall/new key/device scenarios), so I’d love honest feedback from devs:

Does the tracked time feel accurate for your workflow?
Is onboarding clear enough?
What one metric/feature should I build next?
Product: lync.life
Portfolio: https://rishabhsharma.vercel.app/

How to Connect Mongo db with Node JS & Express JS

badcaptain0001 — Sat, 27 Jan 2024 10:59:54 +0000

Setting Up a Node.js Project
Initialize Node.js Project: Create a new folder for your project and run npm init to initialize a new Node.js project.

Install Dependencies

npm install express mongoose

Connecting MongoDB with Mongoose
Set up a basic Express application in your index.js file:

const express = require("express");
const app = express();
const PORT = process.env.PORT || 3000;
require("./dbconnection.js")

app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

Set up a Db connection file dbconnection.js file:

const mongoose = require("mongoose");
const express = require("express");
require("dotenv").config();
const app = express();
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
mongoose.connect(process.env.MONGODB_URI, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

const db = mongoose.connection;
db.once("open", (_) => {
  console.log("Database connected:", process.env.MONGODB_URI);
});

db.on("error", (err) => {
  console.error("connection error:", err);
});

by replacing process.env.MONGODB_URI with you own url

Go to terminal and type npm start

npm start

Congratulatios! you db has been connected now you can start playaround it

How to create a POST api With Mongo DB and Node JS

badcaptain0001 — Wed, 24 Jan 2024 14:24:33 +0000

first you have to build connection with you database for that will create db.js file you have to import this file in you main file named as index.js or server.js file you can see that in bottom code snippets

const mongoose = require("mongoose");
const express = require("express");
require("dotenv").config();
const app = express();
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
mongoose.connect(process.env.MONGODB_URI, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

const db = mongoose.connection;
db.once("open", (_) => {
  console.log("Database connected:", process.env.MONGODB_URI);
});

db.on("error", (err) => {
  console.error("connection error:", err);
});
Create a usermodel.js file in your node js project

const moongoose = require("mongoose");
const userSchema = new moongoose.Schema({
    name: { type: String, required: true },
    email: { type: String, required: true }
    phone: { type: Number, required: true }
    //---- you can add multiple parameters over here
});

module.exports = moongoose.model("user", userSchema);
now will will create a route file where are going to access this schema and build api to store data on database

create a userroutes.js file

const express = require("express");
const router = express.Router();
const user= require("./usermodel.js");

//-------- api structure -------------------
router.post("/adduser", async (req, res) => {
    const { name , email, phone} = req.body;
    try {
        const newUser= new user({
            name,
            email,
            phone
        });
        const savedUser = await newUser.save();
        res.status(200).json(savedUser);
    } catch (err) {
        res.status(500).json(err);
    }
});


module.exports = router; //======>dont for get to add

you might already have this file named as server.js or index.js in your folder stucture where you are going to build you api structure

const express = require("express");
const bodyParser = require("body-parser");
const app = express();
var cors = require("cors");
app.use(express.urlencoded({ extended: true }));
app.use(bodyParser.json());
require("./db");


const User = require("./userroutes.js");


app.use("/api", User);

const server = app.listen(process.env.PORT, () => {
  console.log(`listening on port ${process.env.PORT}!`);
});

server;

so now you can create more apis

Happy Coding !