Fixing a Critical CLI Crash: How a One‑Line Import Bug Broke Every Bazable Command

Agentfield247 — Tue, 18 Aug 2026 08:47:06 +0000

This is a submission for DEV's Summer Bug Smash: Clear the Lineup powered by Sentry.

Project Overview

Bazable is a Git-native API contract management CLI that scans your codebase, builds an API contract automatically, and enforces it across your team with cloud sync, mock servers, and backend code generation. It supports JavaScript, TypeScript, HTML, and presets for Python, PHP, Go, Ruby.

Bug Fix or Performance Improvement

After adding the Language Server Protocol (bazable lsp) feature, every command in Bazable crashed on startup with:

Error [ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath './node.js' is not defined by "exports"

This meant users could not run even bazable --version because the broken LSP import was loaded when the CLI booted. The fix was to change the import from vscode-languageserver/node.js to vscode-languageserver/node. This one-line correction restored full CLI functionality and made the LSP server start correctly.

Code

Agentfield247 / bazable

Git‑native API contract management CLI. Bazable reads your codebase (frontend, backend, or both), builds an API contract automatically, and enforces it across your team with cloud sync, mock servers, and backend code generation.

Bazable

Git‑native API contract management CLI.
Bazable reads your codebase (frontend, backend, or both), builds an API contract automatically, and enforces it across your team with cloud sync, mock servers, and backend code generation.

Why Bazable?

Extract APIs automatically from any language (JS/TS/HTML + presets for Python, PHP, Go, Ruby)
Catch breaking changes before they reach production – dead URLs, payload type mismatches, over‑fetching
No manual configuration – Bazable auto‑detects your API wrappers (like fetchLedgerAPI, apiClient) and even follows variable assignments
Cloud sync with device‑code auth – push from backend, sync to frontend, no passwords needed
Mock server, TypeScript types, and backend scaffolding – generate an entire Express/Hono API from your contract
AI‑powered – explain endpoints, propose schema changes, accept them, and generate forms with a single command. MCP server included for AI coding agents.
Full documentation: https://bazable.mintlify.app

Quick Start

npm install -g bazable-api
cd your-project-folder
bazable init

…

View on GitHub

My Improvements

The bug was subtle: in ES modules, you cannot import a CommonJS subpath using a .js extension when the package's exports field doesn't define it. By removing the extension and using the documented node subpath, the CLI started without errors. I also added --stdio to the LSP command so the server works in manual test mode when an editor doesn't supply connection arguments. These improvements were published in Bazable v1.2.0 and immediately resolved the crash for all users.

We built a CLI that turns frontend code into API contracts, mock servers, and database schemas

Agentfield247 — Mon, 17 Aug 2026 15:01:32 +0000

We didn’t set out to build a whole product.
We just kept running into the same problem over and over: frontend code and backend APIs would drift apart, and nobody noticed until something broke in production.

So we built Bazable: a single command‑line tool that reads your frontend code, builds an API contract automatically, and then uses that same contract to enforce safety, spin up mock servers, generate types, and even create database schemas.

How it started

Me and my cofounder were working on a pretty large admin panel for our startup product. The backend dev would change a response shape. The frontend team wouldn’t know. A few days later, something would silently break.

The usual fix was:

Notice the bug.

Dig through network tabs.

Compare code with backend docs.

Realise the docs were outdated too.

That got old fast.

We thought: what if the frontend itself could tell us what APIs it expects?

So we wrote a CLI that scans your code, finds every fetch, axios, or custom API call, and builds a bazable.config.json file from it.

That file became the contract.

What Bazable actually does

It reads your code, not your docs
You run:

bazable extract --payloads

It scans your entire project – JS, TS, HTML, even Python and PHP if you use presets – and finds every API call.

It even notices custom wrappers like fetchLedgerAPI or apiClient, because let’s be honest, nobody uses raw fetch everywhere.

The result is a contract file that lists every endpoint, its HTTP method, and the shape of the data you’re sending and receiving.

No more manual documentation that’s out of date the moment you write it.

Once you have a contract, you can run:

bazable inspect

It checks your code against the contract and catches things like:

Dead URLs – you’re calling an endpoint that isn’t in the contract.

Payload mismatches – you’re sending "123" when the contract expects a number.

Over‑fetching – the API returns 10 fields, but you’re only using 2.

It can even auto‑fix some mismatches with

bazable inspect --fix.

It tests all your APIs in one command

bazable test --mock --all

Bazable will hit every contracted endpoint and report which ones are alive and which ones are broken.

It can also use real authentication (email/password or token), so you can test protected endpoints without writing a single line of test code.

It generates frontend and backend code

This is where it gets fun.

From the same contract, you can generate:

TypeScript types –

bazable types

A typed API client –

bazable client

React + Tailwind forms –

bazable gen ui POST /v1/users

Express/Hono backend routers –

bazable gen backend

Prisma models or Supabase SQL –

bazable gen db

So a frontend developer can generate the exact form they need. A backend developer can generate the exact database schema. Everyone stays in sync.

It syncs contracts across your team

If you work on a team, Bazable Cloud lets you push and pull contracts.

Backend dev runs bazable push.
Frontend dev runs bazable sync.
No more Slack messages like “I changed the API, I am sure... don't worry”.

You can even watch for changes automatically:

bazable watch

It polls the cloud and auto‑fixes your frontend code when the backend contract changes. That feels like magic the first time you see it.

It’s AI‑ready and agent‑friendly

Bazable now supports:

bazable explain POST /v1/users

– AI explains what an endpoint does in plain English.

bazable propose "add a phone field"

– AI suggests a schema change.

bazable accept <id>

– approve and apply that change.

And if you use AI coding agents like Cursor or Claude Code, Bazable can generate context files (.cursorrules, .mcp.json) so the AI always respects your API contract instead of hallucinating endpoints.

Why it’s different from Postman / Swagger / etc.

Most API tools start from documentation or manually‑written collections.
Bazable starts from real code.

That means:

It’s always up to date.
It works with existing projects instantly.
It doesn’t require a separate team to maintain specs.
It runs entirely in your terminal – no GUI required, no cloud account needed.

And the whole thing is open source and free.

You can try it right now.

npm install -g bazable-api

Links

Documentation: https://bazable.mintlify.app

GitHub: https://github.com/Agentfield247/bazable

npm: https://www.npmjs.com/package/bazable-api

Kindly Star the Repo and drop feedbacks at my mail
*the247th@gmail.com *

DEV Community: Agentfield247