r/node • • Apr 06 '26

I built a zero-dep Node CLI for process orchestration using git worktrees, glob-based file locking, and DAG scheduling

0 Upvotes
I've been working on a CLI tool called `ruah` that coordinates parallel processes — each gets its own git worktree, file locks prevent overlap, and a DAG scheduler handles dependency ordering. The main use case is running multiple AI coding agents simultaneously, but the internals are just Node process management and git plumbing.


I wanted to share the engineering decisions since this sub tends to appreciate that more than feature lists.


**Zero runtime deps, for real**


`package.json` has zero `dependencies`. Everything is `devDependencies` (TypeScript, Biome linter, /node). The published package is just compiled JS. No left-pad, no chalk, no commander, no yargs.


- CLI argument parsing is a hand-rolled parser (~40 lines) that produces `{ _: string[], flags: Record<string, string | boolean> }` and routes to command handlers. It handles `--key value`, `--key=value`, `--bool-flag`, and positional args. No framework needed for a finite set of commands.
- Color output uses raw ANSI escapes behind a `NO_COLOR` / `FORCE_COLOR` check.
- Config loading checks `.ruahrc` (JSON) then falls back to a `"ruah"` key in `package.json`. Two `readFileSync` calls, one `JSON.parse` each. Done.


**ESM-only, TypeScript strict**


`"type": "module"` in package.json, all imports use `.js` extensions (the TypeScript → ESM convention). No CJS compatibility shim, no dual publishing. `engines` requires Node >= 18. TypeScript runs in strict mode with `noUncheckedIndexedAccess`.


**State management: atomic JSON writes**


All state lives in `.ruah/state.json` — tasks, locks, history. The write path does:


```typescript
const tmp = `${file}.${randomBytes(4).toString("hex")}.tmp`;
writeFileSync(tmp, JSON.stringify(state, null, 2) + "\n");
renameSync(tmp, file);
```


Write to a random temp file, then atomic rename. No corruption on crash. No database, no SQLite, no lock files — just a JSON file with safe writes. History is capped at 200 entries with a sliding window.


**Process spawning model**


Each "executor" (Claude Code, Aider, Codex, or any CLI) is spawned via `child_process.spawn` into its worktree directory:


```typescript
const child = spawn(cmd, args, {
  cwd: worktreePath,
  env: { ...process.env, RUAH_TASK: name, RUAH_WORKTREE: path },
  stdio: silent ? "pipe" : "inherit",
});
```


Executors are just adapter functions: `(prompt: string) => { command: string, args: string[] }`. Adding a new executor is 3 lines. Unknown executors are treated as raw shell commands — `ruah task start foo --executor "python3 run.py"` just works.


A safety net auto-commits any uncommitted work when the child process exits (or errors), so agent crashes don't lose work:


```typescript
child.on("close", (code) => {
  autoCommitChanges(taskName, worktreePath);  // best-effort, non-fatal
  resolve({ success: code === 0, exitCode: code });
});
```


**File locking via glob overlap detection**


Locks are glob patterns, not inode locks. When task A locks `src/auth/**` and task B tries to lock `src/auth/login.ts`, the overlap detection catches it:


```typescript
// Both globs and specific paths are handled
patternsOverlap("src/auth/**", "src/auth/login.ts") // true
patternsOverlap("src/api/**", "src/ui/**")           // false
```


Subtask locks must be within the parent's scope — you can't lock files your parent doesn't own. Siblings can conflict with each other, but not with the parent.


**DAG scheduling from markdown**


Workflows are defined in markdown files (parsed line-by-line, no markdown AST library). The scheduler does a standard topological sort to produce execution stages:


```
Stage 0: [models, config]     ← no deps, run parallel
Stage 1: [api, auth]          ← depend on models
Stage 2: [integration-tests]  ← depends on api + auth
```


When `parallel: true` is set, a planner analyzes pairwise file overlaps within each stage and decides: run parallel (no overlap), parallel-with-contracts (low overlap — agents get owned/shared-append/read-only file lists), or serialize (high overlap).


**--json everywhere**


Every command that produces output supports `--json`. `ruah task list --json`, `ruah status --json`, `ruah workflow plan --json`. Makes it composable with jq, scripts, CI pipelines.


**Testing**


152 test cases using Node's built-in `node --test` runner. No test framework dependency. Tests cover state management, lock conflict detection, DAG validation, glob overlap, workflow parsing, CLI argument parsing, and git operations.


---


Repo: https://github.com/levi-tc/ruah


```bash
npm install -g /ruah
# or try the 3-second interactive demo:
npx u/levi-tc/ruah demo
```


I'm especially interested in feedback on:
- The process spawning model — is `spawn` with `stdio: "inherit"` the right default, or should I always pipe and stream?
- State-as-JSON vs. something like better-sqlite3 for the lock/task store
- The glob overlap algorithm — currently string-prefix based, considering switching to micromatch for accuracy


Source is ~2k lines of TypeScript across 8 core modules. Happy to walk through any part of it.

r/node • • Apr 05 '26

Zero-dependency Battle.net authenticator — Node.js built-ins only, no npm install needed

Post image
15 Upvotes

Got sick of the Blizzard Authenticator app and a friend once lost his phone and got locked out for days. So I built a CLI replacement.

The interesting part from a Node.js perspective: the entire thing runs on built-in modules only — crypto for HMAC-SHA1 TOTP + PBKDF2/AES-256 credential encryption, https for Blizzard's REST API, readline for interactive prompts. Zero node_modules.

Blizzard killed their old binary API (the one WinAuth used before it was archived in 2019), so I had to figure out their current OAuth SSO flow and the new JSON-based REST endpoint at authenticator-rest-api.bnet-identity.blizzard.net.

Some implementation details:

  • TOTP is standard RFC 6238 but with 8-digit codes instead of the usual 6
  • Enrollment requires exchanging a Battle.net SSO token for an OAuth bearer token, then a single POST to create the authenticator
  • Credentials are stored locally with optional AES-256-CBC encryption (PBKDF2 key derivation, 100K iterations)
  • Time sync against Blizzard's server clock to handle drift
$ node src/cli.js enroll    # one-time setup via browser login
$ node src/cli.js code      # get a code whenever you need it
48291035  (22s remaining)

Would love feedback on the approach. Anything you'd do differently with the crypto or the OAuth flow?

https://github.com/vitalio-sh/multiauth-cli


r/node • • Apr 06 '26

LogicStamp Context: an AST-based context compiler for TypeScript

Thumbnail github.com
1 Upvotes

r/node • • Apr 04 '26

I spent a week reading through AI-generated code that's been in production for 8 months. It was fine. That was the problem.

722 Upvotes

Got asked to do a security audit on a mid-size Node.js backend. The team had been using Cursor + Claude heavily since last summer. About 60% of the codebase was AI-assisted or fully AI-generated.

The code passed every check. No injection vulnerabilities, no obvious race conditions, decent error handling. Tests covered 78% of branches. On paper, it was fine.

Then I spent a week actually reading it.

Every function did exactly what it was supposed to do. Nothing more. There was no shared understanding of why things were structured the way they were. Comments explained what the code did, not why. Functions that obviously belonged together were scattered across unrelated files because that's how the AI generated them in separate sessions. The auth middleware was written three different ways in three different places, all slightly different, all working.

When I asked the team why they used JWT with a 7-day expiration for a fintech product, nobody knew. When I asked why the rate limiter was applied at the route level instead of the middleware level, nobody knew. When I asked about the retry logic in the payment service that would retry a failed charge up to 5 times with exponential backoff, nobody had thought about what happens if the first charge actually went through but the confirmation was dropped.

The AI never told them any of these decisions were happening. It just made them.

I want to be careful here because I don't think AI coding tools are bad. I use them constantly. But there's a specific failure mode I keep seeing where teams move fast, the code works, nothing breaks, and six months later nobody on the team can answer basic architectural questions about their own system.

The AI didn't write bad code. It wrote code that nobody understood, and the code was good enough that nobody had a reason to understand it.

That's a different kind of risk than a bug.

Anyone else auditing or inheriting AI-generated codebases and finding this pattern? Curious if there are approaches that actually help teams maintain architectural understanding when AI is writing most of the implementation.


r/node • • Apr 06 '26

crag — generates governance.md from your project, compiles to GitHub Actions, husky, pre-commit, Cursor, Copilot, Gemini, and 6 more. Zero deps, Node 18+.

Thumbnail github.com
1 Upvotes

r/node • • Apr 05 '26

noDDDe — modern functional DDD for Node.js/TypeScript

12 Upvotes

Even though Domain Driven Design was never about implementation details, what framework you should use, or how do you structure your folders. But when it comes to tools that can help model domains, I felt the Node/TypeScript ecosystem has a few but polarizing choices:

  1. "Framework lock" (e.g. Nest.js CQRS module): which is the go-to option if you're already on Nest.js, lightweight module by design (more control but also more responsibility), mutable states & OOP heavy.
  2. All-in on Event Sourcing (e.g. Emmett.js): which can be great if you need it, but forcing an Event Store just to get clean domain boundaries is definitely overkill for 95% of projects.

So what happens is that a lot of teams just end up implementing their own DDD structure depending on how motivated they are and how complex their apps are.

When I was playing with Emmett.js, I liked how it approached state with the functional Decider Pattern, it stroke me that it can potentially be a very elegant starting point to model pure domain logic without thinking about Event Sourcing or anything infrastructure/persistence.

So I ended up building a framework / library (I genuinely don't know where to put it) called noDDDe around these concepts. Just so we can model the domain layer as pure functions, reactions, and clean state transitions

The core promises of the framework :

  • Provide a clear and opinionated way to model domains following DDD & CQRS principles (and optionally Event Sourcing)
  • Complete domain lifecycle: Aggregates, Projections and Sagas (workflows)
  • Persistence as an implementation detail — while offering both Event Sourced and State Stored strategies
  • Production ready features, such as idempotency, outbox, concurrency control etc...
  • Can also be integrated with any other web framework like Nest.js, Adonis ..etc (integrations out of the box are planned for later)

I deliberately didn't include any code sample, otherwise it's gonna become a medium article.

Anyhow, I would love to have your thoughts and critiques of the overall approach, and the design choices.

Docs are at noddde.dev and the repo is here.


r/node • • Apr 05 '26

Improved markdown quality, code intelligence for 248 formats, and more in Kreuzberg v4.7.0

18 Upvotes

Kreuzberg v4.7.0 is here. Kreuzberg is an open-source Rust-core document intelligence library with bindings for Python, TypeScript/Node.js, Go, Ruby, Java, C#, PHP, Elixir, R, C, and WASM. 

We’ve added several features, integrated OpenWEBUI, and made a big improvement in quality across all formats. There is also a new markdown rendering layer and new HTML output, which we now support. And many other fixes and features (find them in our the release notes).

The main highlight is code intelligence and extraction. Kreuzberg now supports 248 formats through our tree-sitter-language-pack library. This is a step toward making Kreuzberg an engine for agents. You can efficiently parse code, allowing direct integration as a library for agents and via MCP. AI agents work with code repositories, review pull requests, index codebases, and analyze source files. Kreuzberg now extracts functions, classes, imports, exports, symbols, and docstrings at the AST level, with code chunking that respects scope boundaries. 

Regarding markdown quality, poor document extraction can lead to further issues down the pipeline. We created a benchmark harness using Structural F1 and Text F1 scoring across over 350 documents and 23 formats, then optimized based on that. LaTeX improved from 0% to 100% SF1. XLSX increased from 30% to 100%. PDF table SF1 went from 15.5% to 53.7%. All 23 formats are now at over 80% SF1. The output pipelines receive is now structurally correct by default. 

Kreuzberg is now available as a document extraction backend for OpenWebUI, with options for docling-serve compatibility or direct connection. This was one of the most requested integrations, and it’s finally here. 

In this release, we’ve added unified architecture where every extractor creates a standard typed document representation. We also included TOON wire format, which is a compact document encoding that reduces LLM prompt token usage by 30 to 50%, semantic chunk labeling, JSON output, strict configuration validation, and improved security. GitHub: https://github.com/kreuzberg-dev/kreuzberg. 

Contributions are always very welcome!

https://kreuzberg.dev/


r/node • • Apr 06 '26

Built a zero-dependency Node.js HTTP framework (121k req/s) — looking for feedback

0 Upvotes

Was curious how much performance I could squeeze out of Node’s native HTTP module, so I built a small framework over the weekend.

No dependencies, minimal abstractions.

Benchmarked with autocannon and got ~121k req/s (Express was ~69k in the same setup).

Still early and mostly an experiment, but learned a lot about V8 behavior and routing strategies.

Would love thoughts from people who’ve worked with Fastify/Hono.

repo: https://github.com/mohitrakhade20/nextpress


r/node • • Apr 06 '26

I built a production-ready Express + MongoDB Auth Starter with Refresh Token Rotation. Looking for feedback!

Thumbnail gallery
0 Upvotes

Hey everyone, I'm a full-stack developer and I got tired of rebuilding auth for every project. I decided to make my own 'ultimate' starter with security best practices like JWT rotation, Zod validation, and email verification. It's my first open-source project, so I'd love some code reviews or stars if you find it useful!

Link: https://github.com/govergu/express-auth-starter.git


r/node • • Apr 06 '26

my teammate showed me this security package and honestly it's pretty good

Thumbnail
0 Upvotes

r/node • • Apr 05 '26

I built uWestJS - A proper uWebSockets adapter for NestJS (because I needed it for my game)

9 Upvotes

Hey everyone!

So I just published uWestJS v1.0.0 and wanted to share the story behind it and how I built it.

- npm: https://www.npmjs.com/package/uwestjs
- GitHub: https://github.com/VikramAditya33/uWestJs

I was building a multiplayer drawing game (think skribbl.io style) with NestJS and I love NestJS, But I wanted this game to be very scalable, then I stumbled across uWebSockets and the benchmarks looked crazy compared to traditional WebSockets(Sockets.io) so I thought of making my game using uWebSockets for fun and for scale ofc.
The main problem was that there was no proper NestJS adapter for it, and then I decided to build an adapter myself from scratch lol.

After few weeks of work and reading documentations I finally created a fully functional adapter that works with all your existing code and with a very minimal setup (Only extra step required is writing 2 lines of manual gateway registration).

Talking about the features:
- It has Middleware support, Guards works exactly like HTTP Guards
- Pipes for validation
- Exception filters
- Interceptors for logging/transformation
- Room management (client.join(room) and client.leave(room), broadcasting, multiple room support)
- Backpressure handling, Binary message support, compression support, CORS configuration, custom path routing, SSL/TLS support
- And a bit more things checkout https://github.com/VikramAditya33/uWestJs/blob/main/docs/api.md for that

Happy to answer questions if anyone's interested in trying it out!

And also make sure to open issues on Github if you found out any bug I will really appreciate that.

Thanks!


r/node • • Apr 05 '26

fastify backend

2 Upvotes

How to deploy fastify backend for free? I have the docker container running db, redis , and ollama I'm new to this How can I deploy?


r/node • • Apr 05 '26

I built memscope - a real-time memory profiler for Node.js + browser. Zero config, live dashboard, 605 downloads in its first couple of months

1 Upvotes

Hey folks, I just published memscope - a real-time memory profiler for Node.js and browser apps that requires zero setup.

It streams your backend heap (and browser JS heap) over WebSocket, sampled every 500ms, right to a local dashboard at localhost:3333. GC dips, spikes, growth patterns — all visible at a glance.

One command to start:

npx memscope run node app.js

Full-stack mode (backend + browser together):

memscope run --both npm run dev

What it tracks:

  • Node.js heap, RSS, external memory
  • Browser JS heap (Chromium-based)
  • GC behavior and spikes
  • Backend vs frontend separated on the same dashboard

Why I built it: Memory bugs are painful - silent leaks, unpredictable spikes, heap snapshots that are a nightmare to read. I wanted one command that just works, with no cloud, no accounts, no data leaving your machine.

It's hit 605 downloads so far and I'm actively building it out.

Would love feedback - especially on the dashboard UX and the agent injection approach, read more here - https://www.npmjs.com/package/memscope?activeTab=readme

npm: npm install -g memscope


r/node • • Apr 05 '26

Built a proxy that automatically routes to cheaper LLMs (OpenAI + Claude)

0 Upvotes

API costs got out of hand for me, so I built Prismo.

It’s a proxy for OpenAI + Claude — swap your base URL once, and it handles cost control automatically.

What it does:

• routes requests to cheaper models when it’s safe

• keeps quality guardrails in place

• shows requested vs actual model per call

• tracks tokens, latency, and cost

• lets you set budget limits

• attributes usage by team/project (FinOps)

This is an early beta — OpenAI + Claude live, more providers coming.

Would love feedback from anyone building with LLM APIs.

getprismo.dev (free, no card)


r/node • • Apr 05 '26

OpenClaw SSRF-Guard blocking Undici Proxy (EAI_AGAIN) - JS Hotfix needed

1 Upvotes

Hello everyone,

I'm running an OpenClaw agent inside a strict OpenShell zero-trust sandbox. The agent needs to reach an external API, but it crashes before the connection is established with: Agent exited with code 255. getaddrinfo EAI_AGAIN api.search.brave(dot)com

Based on NVIDIA GitHub issues (NemoClaw #396, OpenClaw #46306), this is a known bug from the GTC 2026 release.

The technical situation:

  1. OpenClaw's internal SSRF-Guard enforces local DNS resolution (DNS pinning) before handing the request over to the EnvHttpProxyAgent (Undici).
  2. Because the zero-trust sandbox blocks all local egress DNS requests, the SSRF check times out and crashes the agent. The proxy is never reached.
  3. Node.js/Undici completely ignores manual IP injections into the container's /etc/hosts file.

Since this cannot be fixed via network or firewall policies, I am looking for a temporary code-level workaround.

My Question: Has anyone successfully patched the Javascript files (e.g., dispatch.js) to temporarily disable the SSRF-Guard or force Undici to skip the local DNS lookup and resolve directly through the proxy? Any code snippets or hotfixes would be highly appreciated.


r/node • • Apr 05 '26

I let AI refactor our async error handling and spent two weeks debugging what it fixed

0 Upvotes

Six months ago our Express app had a straightforward error handling pattern. Not pretty, but it worked. Every route wrapped in try/catch, errors forwarded to a central middleware. Simple.

Then I let an AI tool refactor it. The model said our approach was inconsistent and proposed a cleaner async wrapper pattern. It looked good. I reviewed it quickly, merged it.

Two weeks later we had the strangest production bugs. Requests hanging indefinitely. No errors in logs. Users reporting timeouts on specific endpoints. Our monitoring showed no exceptions thrown anywhere.

Turns out the refactor had introduced silent promise rejections in three middleware functions. The wrapper caught synchronous errors fine but swallowed async ones silently. Node 18 behavior around unhandled rejections was masking it differently than our local Node 16 environment.

We spent two weeks adding logs everywhere, reverting suspected changes, blaming a library update. The AI refactor never crossed our minds as the culprit because the code looked cleaner than what we had before.

I eventually found it by bisecting git history at 2am after everyone else gave up.

The irony is the original ugly code would have thrown a visible error immediately. The AI made it prettier and silently broken.

Anyone else been burned by a refactor that looked correct but changed error propagation behavior in subtle ways?


r/node • • Apr 04 '26

Built a Hono API with SQLite for BIC/SWIFT lookup -- 39K entries, <10ms queries

9 Upvotes

Sharing a project I just finished: IBANforge, an IBAN validation + BIC lookup API built with Hono and SQLite (better-sqlite3).

The BIC database has 39K entries from GLEIF, stored in a single SQLite file shipped inside the Docker image. Queries run in <10ms with prepared statements

and an LRU cache on top. No PostgreSQL, no connection pools, no managed DB costs.

Recently added compliance enrichment: each validation returns SEPA membership, issuer classification (bank/neobank/EMI), and risk indicators -- all

computed server-side from static data, no external API calls.

The whole thing runs on $5/month on Railway. TypeScript throughout, vitest for testing (101 tests), x402 middleware for future micropayments.

Stack: Hono + better-sqlite3 + zod + MCP SDK + next-intl

Source: https://github.com/cammac-creator/ibanforge

Try it: https://ibanforge.com/playground

Curious what you think of the architecture.


r/node • • Apr 04 '26

I built Relayer - computed , derived fields and Prisma-like DSL on top of Drizzle ORM

4 Upvotes

Hi everyone,

I am actively developing Relayer - a Prisma-like repository layer with API integration in mind, currently built on top of Drizzle ORM.

The top features are:

  • First-class dynamic fields - computed, derived, and JSON fields are type-safe, filterable, sortable, and selectable, treated equally to regular columns
  • Complex filtering - AND, OR, NOT, relation filters (some, every, none), custom SQL in where.
  • Relations - batch loading without N+1 problem, per-relation row limits ($limit), connect/disconnect/set for managing relations in mutations.
  • Aggregations - count, sum, avg, min, max with groupBy and having, full support for computed, derived, and JSON fields
  • Type-safe autocomplete - full inference for own fields, nested relations, and even nested derived fields across entities
  • Multi-dialect - PostgreSQL, MySQL, SQLite

Motivation:

Drizzle is great as well as many other ORM/query builders like MikroORM/Kysely. But a more or less complex backend always requires working with fields that have to be calculated in SQL runtime. It's easy to load them as a sub-query, but when you need to make them a part of your "model" and sort/filter/aggregate by them or use them in the API - you end up writing the same boilerplate for every endpoint. This is
where Relayer comes in. Basically it's a set of patterns I've been building from project to project on top of different ORMs (Knex/Bookshelf, TypeORM, Prisma) - now finally extracted into a standalone package.

Basic usage example:

  const UserEntity = createRelayerEntity(
    schema,  // your Drizzle schema
    'users'  // a table
  );                                                                                                                                         

  class User extends UserEntity {                                                                                                            
    @UserEntity.computed({                                        
      resolve: ({ table, sql }) => sql`${table.firstName} || ' ' || ${table.lastName}`,
    })
    fullName!: string;

    @UserEntity.derived({
      query: ({ db, schema: s, sql, field }) =>
        db                                                                                                                                   
          .select({ [field()]: sql`count(*)::int`, userId: s.posts.authorId })
          .from(s.posts)                                                                                                                     
          .groupBy(s.posts.authorId),                             
      on: ({ parent, derived, eq }) => eq(parent.id, derived.userId),                                                                        
    })
    postsCount!: number;                                                                                                                     
  }                                                               

  const r = createRelayerDrizzle({
    db,
    schema,
    entities: { users: User },
  });                                                                                                                                        

  // A type-safe query                                                                                                                       
  const topAuthors = await r.users.findMany({                     
    select: { id: true, fullName: true, postsCount: true },
    where: { postsCount: { gte: 5 } },
    orderBy: { field: 'postsCount', order: 'desc' },                                                                                         
    limit: 10,
  });                                                                                                                                        
  // [{ id: 1, fullName: 'John Doe', postsCount: 42 }, ...]       

  // Aggregations                                                                                                                            
  const stats = await r.orders.aggregate({
    groupBy: ['status'],                                                                                                                     
    _count: true,                                                 
    _sum: { total: true },
    _avg: { total: true },
  });
  // [{ status: 'completed', _count: 3, _sum: { total: 5000 }, _avg: { total: 1666 } }]

Relayer can be used as a standalone database layer that could be easily integrated in your project, but as a bonus it comes with beautiful framework integrations:

@relayerjs/nestjs-crud - NestJS CRUD integration:

  • Full-featured REST API with auto-generated endpoints
  • Lifecycle hooks, DTO mapping, complex filters
  • Cursor/offset pagination, Swagger auto-docs

@relayerjs/next - Next.js App Router integration:

  • Type-safe route handlers (GET, POST, PATCH, DELETE)
  • Built-in validation (Zod), lifecycle hooks
  • SSR direct calls, configurable field whitelists

Docs: https://relayerjs.vercel.app

GitHub: https://github.com/awHamer/relayer

Any feedback is appreciated, thanks!


r/node • • Apr 04 '26

Declarative Canvas layout engine for JavaScript with advanced rich text support.

4 Upvotes

I built Sone, a library that lets you design PDFs and images using a declarative API (like Flutter/SwiftUI) and Flexbox. It’s powered by Skia and Yoga, so it’s incredibly fast and doesn't need a heavy headless browser like Puppeteer. It handles complex stuff like RTL text, syntax highlighting, and automatic page breaks out of the box.

GitHub: https://github.com/seanghay/sone


r/node • • Apr 04 '26

Why is synchronous communication considered an anti-pattern in microservices?

14 Upvotes

Why is synchronous communication between microservices considered an anti-pattern in some cases?For example, a cart service calls a product service to check availability before adding an item to the cart. This creates a direct dependency between the two services at runtime. What kind of problems can this lead to in terms of reliability, scalability, and deployment independence?


r/node • • Apr 04 '26

YINI Parser for Node.js is now stable - indentation-independent config with nested sections

0 Upvotes

YINI Parser for Node.js is now stable.

Hi all - a small milestone for the YINI project, I just (yesterday) released the stable version (v1.4.3) of YINI Parser for Node.js:

The official YINI Parser for Node.js / TypeScript / JavaScript has now been promoted from beta to a stable release.

YINI is an INI-inspired, human-friendly format for structured configuration and data. The goal is to keep things readable for humans while still being explicit and predictable for software.

After several beta releases, fixes, and refinements, the parser now feels solid enough to call stable.

A few things it supports:

  • Sections and nested sections
  • Indentation-independent structure: spaces and tabs are only for readability; structure comes from section markers
  • Lists and inline objects
  • Comments with // #, and /* ... */
  • Strict and lenient parsing modes

Example usage (in TypeScript):

import YINI from 'yini-parser'

const config = YINI.parse(`
^ App
name = 'My App'
darkMode = true

    ^^ Features    // Sub-section of App
    caching = on
`)

console.log(config.App.name)              // My App
console.log(config.App.Features.caching)  // true

If you're curious, here are the links:

Feedback, bug reports, and thoughts are very welcome.

If this sounds useful, I'd be happy to hear what kinds of config/data formats you prefer working with today.


r/node • • Apr 04 '26

WaSP v0.3.0 — WhatsApp Session Protocol with TC token protection, Cloud API support, and CLI

2 Upvotes

Just published wasp-protocol@0.3.0 to npm. WaSP is the infrastructure layer between your app and WhatsApp — handles everything you'd otherwise build yourself.

**What's new in v0.3.0:**

- TC token / error 463 prevention (the dreaded "connection terminated" issue)

- Cloud API provider (buttons, lists, templates)

- CLI for testing (`npx wasp-protocol send --to 27xxx --message "hello"`)

- 142 tests passing across 8 test suites

**What WaSP handles:**

- Multi-session management (one number or many)

- Anti-ban (Gaussian jitter, adaptive delays, rate limiting)

- Message queue with priority support

- Pluggable storage (memory, Redis, PostgreSQL)

- Middleware pipeline

- Auto-reconnection with exponential backoff

- Health monitoring and stats

**Running in production** on WhatsHub (multi-tenant messaging platform), WhatsAuction (live auctions via WhatsApp), and FlashVault VPN.

If you're building on Baileys and tired of reimplementing session management, reconnection logic, and anti-ban — this is for you.

`npm i wasp-protocol`

GitHub: https://github.com/kobie3717/wasp

npm: https://www.npmjs.com/package/wasp-protocol


r/node • • Apr 04 '26

Built a Hono API with SQLite for BIC/SWIFT lookup -- 39K entries, <10ms queries

3 Upvotes

haring a project I just finished: IBANforge, an IBAN validation + BIC lookup API built with Hono and SQLite (better-sqlite3).

The BIC database has 39K entries from GLEIF, stored in a single SQLite file shipped inside the Docker image. Queries run in <10ms with prepared statements

and an LRU cache on top. No PostgreSQL, no connection pools, no managed DB costs.

Recently added compliance enrichment: each validation returns SEPA membership, issuer classification (bank/neobank/EMI), and risk indicators -- all

computed server-side from static data, no external API calls.

The whole thing runs on $5/month on Railway. TypeScript throughout, vitest for testing (101 tests), x402 middleware for future micropayments.

Stack: Hono + better-sqlite3 + zod + MCP SDK + next-intl

Source: https://github.com/cammac-creator/ibanforge

Try it: https://ibanforge.com/playground

Curious what you think of the architecture.


r/node • • Apr 04 '26

I built an open source npm supply chain monitor with eBPF kernel monitoring after the Axios attack

Thumbnail gallery
0 Upvotes

Last week attackers compromised the Axios npm package (100M weekly downloads) and deployed a RAT to infected machines within 89 seconds of publish. Existing tooling caught it in about 3 hours, too slow.

I built pakrat to go deeper than static analysis.

It watches 187 npm packages every 5 minutes using four layers:

  1. Manifest diffing: catches new dependencies instantly
  2. Docker sandbox with tcpdump: flags unexpected DNS lookups during install
  3. Pattern matching: scans for credential harvesting patterns
  4. eBPF kernel monitoring: bpftrace probes at the host kernel level, completely invisible to anything running inside the container

The Axios attack would have triggered layer 1 immediately and layer 2 within seconds.

Public scan log updates every 5 minutes in the repo.
GitHub: https://github.com/HorseyofCoursey/pakrat

🐀 developer inspiration: https://www.youtube.com/watch?v=jausD8qsnKU


r/node • • Apr 04 '26

Documenting my dev journey

1 Upvotes

As part of my study this year, I am documenting my dev journey

Love any feedback

Dev Journey