kibertoad

A pure javascript CRC32 algorithm that plays nice with binary data

LRU and FIFO caches for Client or Server

Fastify CORS

A cron-like and not-cron-like job scheduler for Node.

Plugin for serving static files as fast as possible.

Plugin for fastify to add support for cookies

Important security headers for Fastify

basic websocket support for fastify

Multipart plugin for Fastify

A module for Fastify to parse x-www-form-urlencoded bodies

A batteries-included SQL query & schema builder for PostgresSQL, MySQL, CockroachDB, MSSQL and SQLite3

Serve Swagger-ui for Fastify

Middleware engine for Fastify

Defaults for Fastify that everyone can agree on

Serve Swagger/OpenAPI documentation for Fastify, supporting dynamic generation

A low overhead rate limiter for your routes

Zod Type Provider for Fastify@5

Request-scoped storage support, based on Asynchronous Local Storage, with fallback to cls-hooked for older Node versions

Fastify compression utils

proxy http requests, for Fastify

An SQL-friendly ORM for Node.js

Official Lokalise API 2.0 Node.js client

Require all plugins in a directory

JWT utils for Fastify

Process load measuring plugin for Fastify, with automatic handling of 'Service Unavailable'

forward your HTTP request to another server, for fastify

Server-Sent Events plugin for Fastify

Core forever process monitor

A simple CLI tool for ensuring that a given node script runs continuously (i.e. forever)

Fastify plugin to check environment variables

Fastify Basic auth plugin

Template plugin for Fastify

Run multiple auth functions in Fastify

Express compatibility layer for Fastify

primary logic behind csrf tokens

Perform login using oauth2 protocol

Add accept parser to fastify

In-memory Node.js and browser job scheduler

Plugin to share a common Redis connection across Fastify.

a session plugin for fastify

A plugin for adding CSRF protection to Fastify.

A modern RFC 3986/3987 compliant, scheme extendable URI/IRI parsing/normalizing/resolving/serializing library for JavaScript.

Simple, unobtrusive authentication for Fastify.

Flash message plugin for fastify.

Automatically generate etags for HTTP responses, for Fastify

A Fastify plugin to provide access to URI components

Create a secure stateless cookie session for Fastify

Fastify PostgreSQL connection plugin

Dependency injection support for fastify framework

A Bearer authentication plugin for Fastify

Fastify plugin for scheduling periodic jobs

Wrapper over awilix to support more complex use-cases, such as async init and eager injection

A plugin for Fastify to enable management of cache control headers

Official Fastify plugin for Vite integration.

A plugin for Fastify that provides a map of routes

Library for generating and applying FieldMask

Shared vocabulary, pure logic, and port interfaces for the Agent Architecture Board.

Curated, versioned best-practice prompt fragments injected into agent system prompts.

Valibot wire contract shared between the Agent Architecture Board frontend and backend.

SheetJS Spreadsheet data parser and writer

Asynchronous local storage implementation based on Node.js ALS with fallback to cls-hooked for older Node.js versions

Pricing tables and spend metering for the Agent Architecture Board.

Node.js runtime facade for the Agent Architecture Board: serves the shared @cat-factory/server Hono app via @hono/node-server, wiring Node implementations of the runtime ports (persistence, gateways, model provisioning).

Local-mode runtime facade for the Agent Architecture Board: the @cat-factory/node-server stack with agent jobs run as local Docker/Podman containers and GitHub accessed via a personal access token — a developer can run the whole product on their own machi

Key idea behind API contracts: backend owns entire definition for the route, including its path, HTTP method used and response structure expectations, and exposes it as a part of its API schemas. Then frontend consumes that definition instead of forming f

Opt-in Cloudflare Workers AI model registry for the Agent Architecture Board's AI provisioning facade. Mix into a CompositeModelProvider to add the `workers-ai` provider (in-process binding on the Worker, OpenAI-compatible REST elsewhere).

Agent catalog, routing, prompts and fragment library for the Agent Architecture Board.

Tenancy base services (workspaces and accounts) for the Agent Architecture Board.

Opt-in GitLab VCS provider for cat-factory. Implements the provider-neutral VcsClient / webhook / provisioning ports against the GitLab REST v4 API and registers itself via registerVcsProvider('gitlab'). Depends only on @cat-factory/kernel + @cat-factory/

Delivery-workflow engine for the Agent Architecture Board (execution, bootstrap, pipelines, board, boardScan, requirements, and composition root).

A simple plugin that enables response validation for Fastify.

Fastify MongoDB connection plugin

Opt-in AWS EKS runner + environment backends for cat-factory. Reuses the native Kubernetes transport/provider behind a SigV4-presigned STS (IAM) apiserver token.

Runtime-neutral HTTP layer for the Agent Architecture Board: the Hono controllers, middleware (auth/authz/CORS/error), request helpers and the gateway seams shared by every deployment facade (Cloudflare Worker, Node service).

Optional consensus-orchestration mechanism (specialist panel / debate / ranked voting) for cat-factory agent steps, with task-estimate gating.

The app-level caching seam for the Agent Architecture Board (docs/initiatives/caching-layer.md): createAppCaches builds the named, typed in-memory read-through caches (layered-loader) the services consume via the kernel AppCaches port, with optional distr

Opt-in Langfuse trace sink for the Agent Architecture Board. The workerd-safe OTLP/HTTP exporter pointed at Langfuse's OpenTelemetry endpoint, so LLM generations and container tool spans stream unchanged on both the Cloudflare Worker and Node facades.

Hand-authored, standardized, graded no-repo fixtures for the Sandbox: inline agent inputs (requirements/clarity/code-review/architecture-proposal review) with expectations rated by trickiness and impact.

Reusable Cloudflare Worker library (Hono + D1) exposing the Agent Architecture Board core: the `createApp()` Hono factory, the default fetch/scheduled/queue handler, and the Durable Object + Workflow classes. Deployments (see deploy/backend) supply the wr

Data loader with support for caching and fallback data sources

Core libraries for Node.js backend services.

Opt-in AWS S3 blob backend for the Agent Architecture Board's binary-artifact storage abstraction. Implements the kernel BinaryBlobBackend port over an S3 bucket.

Opt-in OpenTelemetry (OTLP) trace + metrics publisher for the Agent Architecture Board. Streams LLM generations and container tool spans to any OTLP/HTTP backend — the workerd-safe fetch exporter on the Cloudflare Worker facade, the official @opentelemetr

Fastify Mysql connection plugin

Isomorphic general-purpose TS utils

A Solr client library for indexing, adding, deleting, committing, optimizing and searching documents within an Apache Solr installation (version>=3.2)

A low overhead circuit breaker for your routes

Adds additional functionality on top of zod framework.

Lokalise config for Biome

Opinionated HTTP client for the Node.js backend

This library provides a basic abstraction over BullMQ-powered background jobs. There are two types available:

External-system integration domain logic for the Agent Architecture Board (GitHub, documents, tasks, environments, runners).

Useful utilities, interfaces and base classes for message queue handling. Supports AMQP and SQS with a common abstraction on top currently

Opinionated set of fastify plugins, commonly used in Lokalise

Parallel prompt/model testing surface: versioned prompt candidates, experiment matrices, judge + objective grading. Isolated from the core product so it can be extracted.

This package provides a list of language codes that are supported by CLDR43, and a subset of them supported by Lokalise.

This package adds common utils that are used to work with errors.

This package adds support for generating fastify routes using universal API contracts, created with `@lokalise/api-contracts`

React server side rendering support for Fastify with Next

Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an

This package provides common types and utils for rest calls for a certain service, such as pagination, filtering, etc.

The official @fastify/vite renderer for React

Opt-in AWS Bedrock model registry for the Agent Architecture Board's AI provisioning facade. Mix into a CompositeModelProvider to add the `bedrock` provider.

This library contains common schemas and types that can be used by any service.

The built-in polling-gate suite (CI, merge-conflicts, post-release health + the on-call escalation) for the Agent Architecture Board, authored entirely through the public gate-registry seam — depends only on @cat-factory/kernel + @cat-factory/contracts, n

This package adds common utils that provide IDs compatible with CockroachDB UUID type.

SNS adapter for message-queue-toolkit

Library for handling retry logic with undici HTTP client

SNS/SQS/S3 emulator

Useful utilities, interfaces and base classes for message queue handling. Supports AMQP and SQS with a common abstraction on top currently

Reusable testing utilities that are potentially relevant for both backend and frontend

This library contains schemas, types and API contracts related to: * Users * Projects * Tasks * StyleGuides * Workspaces * Permissions * Subscriptions * Usage metrics (`getBillingMetrics`) * Suggested contributors

Very opinionated DI framework for fastify, built on top of awilix

This package provides a pre-configured OpenTelemetry setup for Fastify applications with automatic instrumentation.

TypeScript/JavaScript client for the cat-factory public API (/api/v1): typed models and resource clients generated from the published OpenAPI spec, over a hand-written fetch transport with bearer auth, bounded retries, keyset auto-pagination and an SSE re

SQS adapter for message-queue-toolkit

Fastify plugin for elastic search

This package adds common utils that are used to work with healthchecks.

# Usage

Model Context Protocol server for the cat-factory public API (/api/v1): a thin facade that exposes the published operations as MCP tools, generated from the same OpenAPI spec the SDKs are, over the hand-written @cat-factory/sdk transport.

Fastify plugin that allows to add custom health checks in your server

Test framework for CLI utilities

Shared TypeScript configuration for Lokalise projects.

Lokalise Connector API schemas and contracts

This package provides utils to work with non-translatable markup.

Shared schemas of data storage service, moved to a separate package so it can be injected without the service

Content Type App Engine service contracts

This library contains schemas and types related to Translations workflow events.

Very opinionated TypeScript library for managing AWS configuration, resource naming, tagging, event routing, and integration with @message-queue-toolkit/sns and @message-queue-toolkit/sqs.

Fast, GMX-V compliant word and character counter. Can count both logographic and non-logographic languages correctly. Also supports generic counting for cases when language is unknown.

This package contains a set of utilities to work with Prometheus metrics.

React bindings for @modular-react/core: hooks, contexts, error boundaries, and scoped stores.

Utilities for collecting metrics in message-queue-toolkit

Welcome to **Louis**. This project, built by [Lokalise](https://www.lokalise.com), is a ReactJS implementation of the Louis Design System. It contains the core components to start building your React application with Lokalise's look and feel.

A simple Fastify plugin to ignore favicon requests

AWS S3-based message store implementation for message-queue-toolkit

A flexible, type-safe authentication library for Fastify applications built with TypeScript. This library provides a clean abstraction for JWT-based authentication with support for multiple authentication strategies and token verification methods.

Utility library with the client for communication with Expert API

This package contains core websocket system events and tools that can be used by backend and frontend services

Fauxqs resource setup config for programmatic usage

API schemas for Lokalise Translation Memory service

Utilities to measure text for Lokalise — character count and translatable word count — with pluggable counting rules. Runs in both the browser and Node.

This library contains common API schemas and types shared across Autopilot services.

This library provides objects, types and zod schemas for NextGen tenant to work with Maestro

Validation utilities

This library provides common definitions for Maestro.

Container payload: a thin TypeScript wrapper that runs the Pi coding agent against a cloned repo and opens a PR. Runs in the Cloudflare Container (and, in local native mode, as a host process); carries no secrets.

SNS/SQS remote invalidation adapter for layered-loader

API contracts and shared schemas for the Projects Engine service

Serializer according to the accept header

React binding facade over @modular-frontend/core. Re-exports the framework-neutral primitives (types, slots, navigation, validation, journey contracts, store) for modular React applications.

Core types and utilities for defining modules using TanStack Router. Provides `defineModule`, `createSharedHooks`, scoped stores, and all shared type definitions.

Application assembly layer for modular-react (TanStack Router integration). Takes modules and configuration, produces a running app — either with the library-owned router (`resolve()`) or wrapped around TanStack Router file-based mode / TanStack Start (`r

SDK for file-storage-service

Typed, serializable workflows that compose multiple modules. A journey declares entry/exit transitions between modules and owns shared state; modules stay journey-unaware.

Source of truth for design tokens at Lokalise.

FIXME: describe why it is here, not a separate repo, not a Harmony package, not combined with packages/backend-plugins/populate-expert-user/clients/BackendExpertHttpClient, not combined with Lokalise Node.js API client

Opinionated HTTP client for the frontend

This library contains schemas and types related to Translations workflow events.

This library contains API contracts, schemas and types related to the translation domain. This includes: * AI Configuration * Translation Quality Score

Framework-neutral journey engine: runtime, validation, persistence, authoring helpers, handles, and types for typed, serializable multi-module workflows. No UI-framework dependency — the outlet and hooks live in a binding package.

REST API client for the Lokalise Translation Memory service

Originally designed as Swagger definition generator for Objection.js models. Since then scope was extended to also cover Swagger-compatible snippets generation from plain JSON Schema entries as well as set of conversions that are useful for model and sche

REST API client for the Lokalise Polyglot service

This package provides reusable helpers for Prisma query builder.

This library contains API contracts, schemas, and types related to the Content Exchange domain.

The built-in generative binary integrations (Nano Banana, Google's Gemini image models) plus the authoring seam a deployment defines its own with, written entirely through the public BinaryGeneratorRegistry seam: depends only on @cat-factory/kernel + @cat

Fastify plugin for opensearch

Building blocks for writing your own HEADLESS acceptance suite against a live cat-factory deployment: the scenario driver, the resumable ledger and progress journal, a prerequisite gate whose refusals carry rendered remedies, waits that state their last o

Bull-board is a dashboard which provided a UI built on top of BullMQ or BullMQ Pro to help you visualize your queues and their jobs. It gives you the possibility of visualizing what's happening with each job in your queues, their status and some actions t

Redis adapter for SSE rooms in opinionated-machine

Execute chunked blocking operations in a way that won't cause event loop starvation

Build a deployable static catalog UI for modular-react modules and journeys. Scans configured directories, harvests descriptors, and emits a self-contained SPA you can host on any static server.

Hono adapter for @toad-contracts: mount fully typed, self-validating routes from standard-schema contracts

This library provides shared objects, types and zod schemas for Maestro

The Cloudflare OS Gatekeeper machinery for cat-factory as an installable library: policy-compiled Cap'n Web capabilities over the /api/v1 operation table, per-actor API-key minting, a verified outbound-webhook receiver and the approval inbox that answers

Lightweight library for determining types of variables based on battle-tested implementation from lodash but having a fraction of overall size.

test utils

Framework-neutral primitives for modular frontend applications: module descriptors, slots, navigation, validation, journey contracts, and a lightweight store. No UI-framework dependency — components are carried as opaque values.

Testing utilities for TanStack Router modules. Render modules in isolation with mocked dependencies.

Policy-annotated operation table for the cat-factory public API (/api/v1): per-operation scope floors, mutation and transport metadata, and invoke thunks over @cat-factory/sdk, generated from the same OpenAPI spec the SDKs are. Built for credential-holdin

Build search queries for objection.js models using HTTP query parameters.

A flexible, production-ready polling library with configurable retry strategies and TypeScript support.

Kafka adapter for message-queue-toolkit

Event schemas for Lokalise Translation Memory service

FIXME: describe why it is here, not a separate repo, not a Harmony package, not combined with packages/backend-plugins/populate-expert-user/clients/BackendExpertHttpClient, not combined with Lokalise Node.js API client.

Bootstrap CLI for the Agent Architecture Board: scaffold a local-mode deployment (Node/local backend + frontend SPA) on your own machine — generates the crypto secrets, populates and gitignores the .env files, and mints a GitHub/GitLab personal access tok

Shareable eslint config for frontend codebases

Nuxt 4 integration for @modular-vue: a Nuxt module plus a runtime installer that grafts module routes onto Nuxt's vue-router and installs the modular contexts on the Nuxt Vue app.

vue-router core for @modular-vue modules: defineModule with createRoutes(): RouteRecordRaw[], defineSlots, shared composables, scoped stores, and the RouteMeta convention.

This package provides reusable helpers for Drizzle ORM.

Vue 3 journeys for @modular-vue: JourneyProvider, instance composables (useJourneyState / useActiveLeafJourneyInstance), and the journeys registry plugin over @modular-frontend/journeys-engine.

vue-router runtime for @modular-vue modules: createRegistry with module registration, dependency validation, lifecycle hooks, plugin machinery, and manifest resolution.

Useful utilities for Knex.js

provide stats for routes using perf_hooks, for fastify

Validation middleware that validates request/response against provided swagger spec

Throttle responses in fastify

Opinionated wretch-based HTTP client driven by @toad-contracts standard-schema contracts

AMQP adapter for message-queue-toolkit

This is a collection of reporters to use with our Playwright test frameworks.

The official @fastify/vite renderer for Vue

ESLint plugin for Lokalise

Transform low-level OData AST from [@balena/odata-parser](https://github.com/balena-io-modules/odata-parser) into high-level, service-ready structures.

Fastify plugin to interact with Apache Kafka.

Event bus based on MobX pub/sub model.

Memory and event loop testing for Node.js — heap monitoring, event loop delay and utilization tracking, object lifecycle verification, stream buffer assertions, and comparative profiling

Fastify plugin for ensuring existence of defined AWS S3 buckets on the application startup

Vue 3 bindings for @modular-frontend/core: store composables, scoped stores, and injection-key contexts for modules, navigation, and slots.

## Project Purpose

This library contains schemas and types related to In & Out workflow events.

Parametrized CRUD repository abstraction for Knex.js

Plugin to share a common valkey connection across Fastify.

Testing utilities for mocking @toad-contracts HTTP responses with mockttp and msw

Knex adapter for Casbin

This library contains schemas and types related to Portal API.

Fastify plugin for Zipkin distributed tracing system.

ToadStack config for Biome

Ragnarok API contracts

The official @fastify/vite renderer for HTMX

Queue name, message schema, and a ready-made publisher for Audi's audit-events SQS command queue, for services that publish audit log events.

Google Cloud Storage-based message store implementation for message-queue-toolkit

Support for fastify routes returning functional structures, such as fp-ts Either, Task, TaskEither or plain javascript parameterless functions

Redis-based message deduplication store for message-queue-toolkit

Benchmarking library for Node.js that emphasizes convenience of use

> **Deprecated** — this package is a re-export barrel kept for backward compatibility only. > New consumers should depend directly on the focused packages instead: > > - **`@lokalise/content-conversion-api-schemas`** — domain/API schemas (frontend-safe

Config management for the frontend

Mass loading of files, supporting JSON and YAML parsing

Wrapper that makes testing using Nock mock record/replay functionality easier. By default does not create mocks for local calls (localhost/127.0.0.1) when recording, allows and passes through local calls when replaying.

This config is great for packages that need to build both CJS and ESM builds.

`fastify-schedule@1.1.0` has been deprecated. Please use `@fastify/schedule@2.0.0` instead.

query paramter constructor for objection-find

Use the Hotwire pattern with Fastify

Google Cloud Pub/Sub adapter for message-queue-toolkit

This library contains schemas and types related to Portal events

This package provides a pre-configured Datadog APM setup for Fastify applications using the native `dd-trace` library, with support for auto-instrumentation, runtime metrics, profiling, and log injection.

This library exposes several fastify plugins that rely on @fastify/request-context (ALS) to work.

Lightweight Express middleware that allows the validation of incoming parameters.

Library for sequentially deleting all rows from a given list of DB tables.

Handle requests using the fetch standard

Common interfaces for Composed Connector adapters

Connector shell module with controllers for Lokalise Content Engine connectors

Message schemas for events that more than one Lokalise service consumes, so that publisher and consumers share one definition instead of each keeping a hand-maintained copy.

Test helper for managing and cleaning up your S3 buckets in tests

Combines separate OpenAPI fragments into single specification file