extensio-ai: Extensio.ai: The AI Extension Factory That Refuses to Ship Unsafe Code

From prompt to Manifest V3 ZIP, this repo turns browser-extension generation into a controlled pipeline, where sanitization, permission checks, and packaging are part of the product.

8 min read • View on GitHub • More from asim-kazi

A prompt drops into a mechanical press and comes out as a sealed browser-extension package. A guard arm checks the package mid-press, stopping a dangerous component before the archive is finished. The image explains that the project does not just generate code, it governs what can be shipped. — Extensio.ai treats code generation like a production line with a policy gate in the middle.

Key Takeaways

Extensio.ai is interesting because it treats AI output as a governed software artifact, not a chat response.
Its backend uses sanitization and permission checks as both security controls and subscription enforcement.
The product promise is not just generation, but delivery of a Manifest V3 extension as a downloadable ZIP.
The stack looks like a lean AI SaaS blueprint, built for packaging, validation, and fast iteration rather than open-ended agent wandering.

The surprise is not the prompt. It’s the gate.

Most prompt-to-code tools stop at text. Extensio.ai keeps going. The interesting move is in the backend, where generated extension code is inspected before it can become a downloadable artifact. That means the repo is not just an AI wrapper. It is a policy engine around AI output.

Building Extensio.ai — Looking for Contributors & Ideas.

TROJAN (trojanmocx), Developer/Author · Building Extensio.ai — Looking for Contributors & Ideas - DEV Community

That framing matters because browser extensions live inside a privileged environment. A bad permission, a reckless use of eval(), or a sloppy manifest can turn a clever demo into a security problem. Extensio.ai’s core idea is simple: let the model write, but let the platform decide what can ship.

The control layer is the product. The code generation step is only one stage in a longer governed pipeline.

Prompt to ZIP: the product promise

Extensio.ai’s value proposition is not “AI writes a file.” It is “AI writes a Chrome extension that can be packaged and delivered immediately.” That last mile is the point. The repo is building a path from plain-English request to a Manifest V3 ZIP, which is the difference between a toy demo and something a user can install.

Stage	Generic code generator	Extensio.ai
Output	A chat response or code block	A ZIP ready for download
Safety	Usually left to the user	Sanitized before shipping
Permissions	Ignored or user-managed	Checked against subscription tier
Packaging	Manual	Built into the pipeline
Target user	Developers	Non-developers and rapid prototypers

Why the sanitizer matters

The sanitizer is doing more than linting. It is checking for risky JavaScript patterns like eval() and Function(), and it is also enforcing product rules around privileged permissions such as <all_urls>. In other words, the same module is acting like a security filter and a business rule engine.

// Conceptual flow from backend/src/utils/sanitize.js
if (code.includes('eval(') || code.includes('Function(')) {
  throw new Error('Unsafe JavaScript pattern detected');
}

if (manifest.permissions.includes('<all_urls>') && userTier === 'free') {
  throw new Error('Permission requires paid tier');
}

return sanitizedFiles;

That is a smart move because permissions in a Chrome extension are not just technical details. They are the product boundary. By tying them to tier checks, Extensio.ai turns the manifest into a monetization surface without relying only on UI gates.

A close-up conveyor belt moves a ZIP stream through checkpoints labeled by role, with one bad file diverted into a side chute. The visual explains how the generation pipeline filters, packages, and delivers files without staging a full filesystem tree. — The packaging layer is streamlined. Approved files continue, rejected files peel off early, and the final archive is streamed out cleanly.

Inside the generation brain

The generation service is built around a strict file contract. The model is asked for raw JSON where filenames are keys and file contents are values. That matters because extensions are bundles of many small files, not a single blob of code. When the model drifts and adds markdown fences, the backend strips them and keeps moving.

// Conceptual shape of the AI contract
{
  "manifest.json": "{...}",
  "background.js": "...",
  "contentScript.js": "..."
}

That file-first approach is the right abstraction for extension generation. It also makes fallback sanitization practical. If the model gets creative in the wrong way, the backend can normalize the response before it reaches the archive step.

The packaging trick most tools skip

A lot of AI tools stop after synthesis. Extensio.ai keeps going into archive delivery. The zip service streams strings directly into an archive instead of staging a heavy filesystem tree, which keeps the flow lean and reduces cleanup work after download.

That choice tells you a lot about the intended shape of the product. This is not a research sandbox with loose ends. It is trying to behave like a small production SaaS where generation, validation, packaging, and cleanup are one continuous operation.

Layer	What it does	Why it matters
AI service	Turns a prompt into file objects	Creates the extension skeleton
Sanitizer	Rejects unsafe code and gated permissions	Protects users and the platform
Zip service	Streams files into a downloadable archive	Makes the output installable fast
Controller	Coordinates persistence and delivery	Keeps the request lifecycle coherent

What this stack says about the project

React 19, Tailwind CSS v4, Express 5, Sequelize, PostgreSQL, and Gemini point to a lean AI SaaS architecture. The stack is modern, but not flashy for its own sake. It is optimized for a single job: take a request, produce an artifact, store the project state, and hand back something usable.

That is a different posture from a general AI agent platform. Extensio.ai is narrower, and that narrowness is the strength. It has a clear artifact model, a clear safety model, and a clear delivery model.

Approach	Strength	Trade-off
Extensio.ai	Governed extension output	Less flexible than open-ended agents
Generic codegen	Fast broad answers	Weak packaging and safety
Drag-and-drop automation	Low-code orchestration	Not purpose-built for extensions
Manual extension dev	Maximum control	Slowest path to shipping

Who it is for, and what it is not

The target user looks straightforward: non-developers, solo builders, and product people who want an extension without learning Chrome extension internals. It also fits developers who care more about shipping a constrained workflow than inventing one from scratch.

What it is not matters too. This is not a collaborative IDE, not a general-purpose agent runtime, and not a mature extension marketplace. It is a focused factory for one artifact class, with enforcement built into the line.