DEV Community: beladevo

WebMCP is coming — so I’m building webmcp.js

beladevo — Mon, 25 May 2026 07:06:30 +0000

The web was built for humans.

AI agents are not humans.

Today, many agents still use websites like a person would: read the page, inspect the DOM, guess which button to click, fill a form, and hope the UI did not change.

That is useful.

But it is also fragile.

WebMCP points to a different future: websites can expose structured tools directly from the page.

Instead of an agent guessing what a website can do, the website can declare it:

products.search
cart.add
checkout.start
project.create
report.generate
user.invite

These are not random clicks.

They are explicit capabilities with names, descriptions, schemas, and functions.

That is the interesting part.

Not “AI clicks buttons better.”

Something much better:

Websites become understandable and actionable for agents.

Why this matters

If agents become a real interface to software, websites need more than visual UI.

They need an agent-facing surface that is:

clear
typed
validated
safe
testable
connected to the real product flow

WebMCP gives the browser-level direction.

But developers still need a practical layer to use it well.

The missing developer layer

Registering a tool is only the beginning.

The real production questions are:

Is the input valid?
Is this action read-only or dangerous?
Should the user confirm it first?
Can I audit what happened?
Can I test this before exposing it to an agent?
Can I use this cleanly in React or Next.js?

There is a big difference between:

products.search

and:

checkout.start
user.delete
message.send
team.invite

Some tools read data.

Some change state.

Some may cost money.

Some affect other users.

That difference should be part of the developer experience.

What I’m building

I’m building webmcp.js — a TypeScript-first developer layer for WebMCP.
GitHub: https://github.com/beladevo/webmcp.js

Docs: https://webmcp.webml.co.il/

Not a new protocol.

Not a replacement for WebMCP.

A small, practical layer that helps developers expose WebMCP tools with better defaults.

The first focus:

typed tool registration
schema validation
risk levels
permission rules
human confirmation
audit hooks
React / Next.js friendly APIs
testing utilities
clear examples

The API should feel familiar:

mcp.tool("cart.add", {
  description: "Add a product to the user's cart",
  input: z.object({
    productId: z.string(),
    quantity: z.number().min(1),
  }),
  risk: "high",
  requireConfirmation: true,
  run: async ({ productId, quantity }) => {
    return cart.add(productId, quantity);
  },
});

You can explore the project here:

GitHub: https://github.com/beladevo/webmcp.js
Docs: https://webmcp.webml.co.il/
Demo: https://webmcp.webml.co.il/demo

The wrapper is not the point.

The point is the system around the tool:

validation
permissions
confirmation
safe defaults
testing
debugging
developer experience

The purple cow

Most websites today are made for humans only.

The remarkable websites will be different.

They will have two interfaces:

A visual interface for people
A structured interface for agents

That second interface should not be an afterthought.

It should be safe, typed, intentional, and built into the product.

That is the idea behind webmcp.js.

Open source

This space is still early.

That is why I want to build it in public, follow the standard closely, and avoid hype.

The project will be released under the MIT License.

Contributions will be welcome around:

examples
TypeScript API design
permissions and safety
React / Next.js integration
testing utilities
documentation
security review
tracking WebMCP changes

Try it / contribute

The project is open source and available here:

GitHub: https://github.com/beladevo/webmcp.js
Docs: https://webmcp.webml.co.il/
Demo: https://webmcp.webml.co.il/demo

If you’re interested in WebMCP, browser agents, TypeScript API design, permissions, or developer tooling — contributions are welcome.

The goal

Make websites agent-ready without making them unsafe or hard to maintain.

If WebMCP becomes an important bridge between websites and AI agents, developers will need more than a browser API.

They will need a clean, safe, typed, production-minded way to use it.

That is what I want webmcp.js to become.

Redirector OSINT - One-Command Redirect & Logging Tool

beladevo — Fri, 05 Sep 2025 11:55:56 +0000

When doing OSINT or red team work, I always needed a quick way to:

redirect traffic to a target,
log IPs, User-Agents, headers, methods, and timestamps,
and view it all in a clean dashboard.

So I built Redirector OSINT – deployable in 30 seconds with pip or Docker.

pip install redirector-osint redirector run --redirect https://target.com

docker pull beladevos/redirector docker run -p 8000:8000 beladevos/redirector --redirect https://target.com

✅ Auto-refreshing dashboard
✅ Filters & exports (CSV/JSON)
✅ REST API & security features (auth, rate limits)

Use cases: OSINT collection, phishing simulations (defense), red team ops, API testing, analytics.

👉 GitHub: beladevo/redirector

👉 Full write-up: Medium article

[Stop Fighting the Clock] - How to Control Time in Your Tests Without Hacks

beladevo — Sun, 06 Jul 2025 11:25:15 +0000

Hey everyone 👋

I wanted to share a little library I’ve been building lately, called timewarp-sim. If you’ve ever had to test date logic or simulate time passing, you know how frustrating it can be. You either end up waiting forever, fiddling with your system clock, or writing tons of brittle mocks.

timewarp-sim solves this cleanly by giving you a deterministic time machine for your JavaScript and TypeScript code.

✨ What does it do?

✅ Freeze time at a specific moment
✅ Advance time however you like (seconds, hours, even decades)
✅ Travel to any timestamp instantly
✅ Globally mock Date.now() and new Date() so all your dependencies see the same simulated clock
✅ Register hooks to react whenever time changes
✅ Unfreeze and return to real time anytime

💡 Why should you care?

If you work on:

Session or token expiration logic
Caching and TTL validation
Recurring jobs (cron-like scheduling)
Billing or subscription renewals
Reports that aggregate data by date
Anything else where time matters

…this tool can save you hours of debugging and testing.

You no longer have to wait for timeouts to expire or write fragile setTimeout hacks- just jump forward in time with a single line of code.

⚡ Quick Example

import { Timewarp } from "timewarp-sim";

console.log("Real time:", new Date());

Timewarp.freeze();
console.log("Frozen:", Timewarp.now());

Timewarp.enableGlobalMocking();
console.log("Mocked Date.now():", Date.now());

Timewarp.advance(60 * 60 * 1000);
console.log("After 1 hour:", new Date());

Timewarp.travelTo(new Date("2040-01-01T00:00:00Z"));
console.log("Traveled to:", new Date());

Timewarp.unfreeze();
Timewarp.disableGlobalMocking();
console.log("Back to real time:", new Date());

🌟 Get Involved

timewarp-sim is open source, and I’d love to see it grow with help from the community!

👉 ⭐ Star the project on GitHub
👉 Open issues for bugs or feature ideas
👉 Contribute code if you want to make it even better

If you find it useful, share it with your teammates or that friend who still uses setTimeout(999999999) to simulate waiting.