open-index/open-npm huggingface dataset:
npm package: @questpie/probe
Description: Dev testing CLI for AI coding agents
Author: QUESTPIE
Latest version: 0.2.1

# QUESTPIE Probe

Dev testing CLI for AI coding agents. Orchestrates dev servers, aggregates logs, controls browsers, sends HTTP requests, records and replays tests.

**[Documentation](https://probe.questpie.com/docs)** | **[GitHub](https://github.com/questpie/probe)**

## Install

```bash
# Install the CLI
bun add -g @questpie/probe

# Install the AI skill (for Claude Code, Cursor, Windsurf)
bunx skills add questpie/probe
```

## Quick Start

```bash
# Initialize config
qprobe init

# Start a server with ready detection
qprobe start server "bun dev" --ready "ready on" --port 3000

# Check health
qprobe health http://localhost:3000/api/health

# Make HTTP requests
qprobe http GET /api/users --status 200
qprobe http POST /api/users -d '{"name":"test"}' --jq ".id"

# Read logs
qprobe logs server --grep "ERROR"
qprobe logs --all --level error

# Browser control
qprobe browser open http://localhost:3000
qprobe browser snapshot -i
qprobe browser click @e1
qprobe browser fill @e2 "hello"

# Record & replay
qprobe record start "login-flow"
qprobe record stop
qprobe replay "login-flow"

# Compose (from qprobe.config.ts)
qprobe compose up
qprobe compose status
qprobe compose down

# Assertions
qprobe assert status 200 /api/health
qprobe assert no-errors
```

## Commands

| Command | Description |
|---------|-------------|
| `qprobe start` | Start a background process with ready detection |
| `qprobe stop` | Stop a process (SIGTERM → SIGKILL) |
| `qprobe restart` | Restart with saved config |
| `qprobe ps` | List running processes |
| `qprobe health` | Poll URL until it responds |
| `qprobe logs` | Read logs with grep, level, follow |
| `qprobe http` | HTTP requests with assertions |
| `qprobe check` | Quick health + status overview |
| `qprobe compose` | Manage service stack from config |
| `qprobe browser` | 27 browser control subcommands |
| `qprobe record` | Record browser actions |
| `qprobe replay` | Replay as Playwright tests |
| `qprobe recordings` | Manage recordings |
| `qprobe assert` | Run assertions |
| `qprobe init` | Scaffold config |

## Config

```typescript
// qprobe.config.ts
import { defineConfig } from '@questpie/probe'

export default defineConfig({
  services: {
    db: {
      cmd: 'docker compose up postgres',
      ready: 'ready to accept connections',
      health: 'http://localhost:5432',
    },
    server: {
      cmd: 'bun dev',
      ready: 'ready on http://localhost:3000',
      port: 3000,
      health: '/api/health',
      depends: ['db'],
    },
  },
  browser: {
    driver: 'agent-browser',
    baseUrl: 'http://localhost:3000',
  },
  http: {
    baseUrl: 'http://localhost:3000',
  },
})
```

## License

MIT
npm package: @questpie/vite-plugin-iconify
Description: Vite plugin that auto-bundles only the Iconify icons you use
Latest version: 0.0.1

# @questpie/vite-plugin-iconify

Vite plugin that **automatically bundles only the Iconify icons you actually use**. Zero config, zero flash, zero API calls.

## How it works

1. **Scans** your source files for icon references like `"ph:check"`, `"mdi:home"`, `"tabler:star"`
2. **Extracts** only those icons from `@iconify/json` (200k+ icons from 150+ sets)
3. **Generates** a virtual module that calls `addCollection()` to preload them
4. **HMR** — add a new icon, save, it's bundled automatically

Result: `@iconify/react` renders inline SVGs instantly. No API calls, no layout shift, no flash of missing icons.

## Setup

```bash
bun add -d @questpie/vite-plugin-iconify @iconify/json
```

```ts
// vite.config.ts
import { iconifyPreload } from "@questpie/vite-plugin-iconify";

export default defineConfig({
  plugins: [
    iconifyPreload(),
    // ... other plugins
  ],
});
```

```ts
// app.tsx or entry point
import "virtual:iconify-preload";
```

That's it. Use `@iconify/react` as normal:

```tsx
import { Icon } from "@iconify/react";

<Icon icon="ph:check" width={16} height={16} />
<Icon icon="mdi:home" />
<Icon icon="tabler:star-filled" />
```

## Options

```ts
iconifyPreload({
  // Glob patterns for files to scan (default: src/**/*.{ts,tsx,js,jsx})
  scan: ["src/**/*.{ts,tsx}", "packages/admin/src/**/*.{ts,tsx}"],

  // Always include these icons (for truly dynamic icon names)
  include: ["ph:spinner", "ph:spinner-gap"],
})
```

## How icon detection works

The plugin scans for string literals matching the pattern `"prefix:icon-name"` in your source files. This covers:

- `<Icon icon="ph:check" />` — JSX props
- `icon: "ph:article"` — object literals (e.g. server config)
- `c.icon("ph:layout")` — function arguments
- `"mdi:home"` — any string literal

**Won't detect:** dynamically constructed names like `` `ph:${variable}` ``. Use the `include` option for those.

## Why not unplugin-icons?

`unplugin-icons` requires changing your icon syntax to component imports:

```tsx
// unplugin-icons — requires import per icon
import IconCheck from "~icons/ph/check";
<IconCheck />
```

This plugin keeps the standard `@iconify/react` string-based API:

```tsx
// @questpie/vite-plugin-iconify — string-based, no imports
<Icon icon="ph:check" />
```

String-based icon names are essential when icons come from server config, database fields, or any runtime source. This just gives us option to preload the icons we know we'll use, while still allowing dynamic usage when needed.
npm package: @quetils/set
Description: Set plugin that make object from query string
Author: kern.yoo
Latest version: 1.0.4

# `@quetils/set`

Query string split & set object

## Install

```bash
# npm
npm i @quetils/set

# yarn
yarn add @quetils/set
```

## Usage

```javascript
const set = require('@quetils/set');
```
npm package: @quetils/split
Description: quetils split query strings
Author: kern.yoo
Latest version: 1.0.4

# `@quetils/split`

Split query string return `array`

## Install

```bash
# npm
npm i @quetils/split

# yarn
yarn add @quetils/split
```

## Usage

```javascript
const split = require('@quetils/split');

const url = 'localhost:8080/test?test1=1&test2=2';
split(url); // ['test1=1', 'test2=2']

```
npm package: @quetra/core
Description: Types, rule engine, and Ed25519 signing for QuetraAI mandate governance
Latest version: 0.3.1

# @quetra/core

[![npm version](https://img.shields.io/npm/v/@quetra/core.svg)](https://www.npmjs.com/package/@quetra/core)
[![license](https://img.shields.io/npm/l/@quetra/core.svg)](https://opensource.org/licenses/MIT)

Types, policy evaluation engine, and Ed25519 mandate signing for [QuetraAI](https://quetra.dev) — the programmable mandate layer for AI agent spending.

## Install

```bash
npm install @quetra/core
```

## What's Inside

### Types

All core interfaces for the QuetraAI governance model:

- `Organization`, `Agent`, `Mandate`, `MandateBudget`, `OnChainConfig`
- `MandateRule` — union of 7 rule types (category, vendor allowlist/blocklist, time window, rate limit, approval threshold, custom JSONLogic)
- `MandateToken`, `TransactionRecord`, `EvaluationContext`, `EvaluationResult`, `RuleEvaluation`
- `WebhookEventType`, `WebhookEvent`

### Rule Engine

Evaluate payment requests against mandate policies. All rules use AND logic — every rule must pass for approval.

```typescript
import { evaluateMandate } from '@quetra/core';

const result = evaluateMandate(mandate, {
  amount: 500, // $5.00 in cents
  currency: 'USDC',
  vendor: 'api.datavendor.com',
  category: 'research',
  timestamp: new Date(),
  recentTransactionCount: 3,
});

console.log(result.decision); // 'approved' | 'rejected'
console.log(result.evaluations); // per-rule results
```

**Rule types:** `category`, `vendor_allowlist`, `vendor_blocklist`, `time_window`, `rate_limit`, `approval_threshold`, `custom` (JSONLogic).

### Cryptographic Signing

Ed25519 key generation, mandate signing, and token verification via `@noble/ed25519`.

```typescript
import { generateKeyPair, signMandate, createMandateToken, verifyMandateToken } from '@quetra/core';

// Generate org key pair
const { publicKey, privateKey } = await generateKeyPair();

// Sign a mandate
const signature = await signMandate(mandate, privateKey);

// Create a portable token (agent carries this)
const token = await createMandateToken(mandate, privateKey);

// Verify token authenticity
const verified = await verifyMandateToken(token, publicKey);
```

## Requirements

- Node.js >= 20
- ESM only (`"type": "module"`)

## Related Packages

- [`@quetra/sdk`](https://www.npmjs.com/package/@quetra/sdk) — Client SDK for AI agents
- [`@quetra/mcp`](https://www.npmjs.com/package/@quetra/mcp) — MCP server for Claude and other MCP-compatible agents

## License

MIT
npm package: @quetzallabs/generator-i18n-core
Description: The core i18n Quetzal package
Author: John Thompson
Latest version: 0.0.0

# generator-i-18-n-core [![NPM version][npm-image]][npm-url] [![Build Status][travis-image]][travis-url] [![Dependency Status][daviddm-image]][daviddm-url]
> The core i18n Quetzal package

## Installation

First, install [Yeoman](http://yeoman.io) and generator-i-18-n-core using [npm](https://www.npmjs.com/) (we assume you have pre-installed [node.js](https://nodejs.org/)).

```bash
npm install -g yo
npm install -g @quetzallabs/generator-i18n-core
```

Then generate your new project:

```bash
yo @quetzallabs/i18n-core
```

## Getting To Know Yeoman

 * Yeoman has a heart of gold.
 * Yeoman is a person with feelings and opinions, but is very easy to work with.
 * Yeoman can be too opinionated at times but is easily convinced not to be.
 * Feel free to [learn more about Yeoman](http://yeoman.io/).

## License

 © [Quetzal Labs, Inc.](https://getquetzal.com)


[npm-image]: https://badge.fury.io/js/generator-i-18-n-core.svg
[npm-url]: https://npmjs.org/package/generator-i-18-n-core
[travis-image]: https://travis-ci.com//generator-i-18-n-core.svg?branch=master
[travis-url]: https://travis-ci.com//generator-i-18-n-core
[daviddm-image]: https://david-dm.org//generator-i-18-n-core.svg?theme=shields.io
[daviddm-url]: https://david-dm.org//generator-i-18-n-core
npm package: @quetzallabs/i18n
Description: Quetzal Labs i18n Utilities Package
Author: Quetzal Labs, Inc.
Latest version: 0.1.22

# Welcome to Quetzal!

This package contains all the utilities you need to get started using Quetzal.

To install: `npm install --save @quetzallabs/i18n`

Once installed, run `npx quetzal-setup`

Read more about how to use this package at: https://quetzal.mintlify.app/getting-started

This package relies on the next-intl provider to put translations into your app: https://www.npmjs.com/package/next-intl

Be sure to include this provider within your next application, and to put the next-intl plugin in your next config file

## The t function

Text in your application is translated by wrapping it in a t function. This function is built on the next-intl t function: https://next-intl-docs.vercel.app/docs/usage/messages

### For components:

import { useI18n } from "@quetzallabs/i18n";
const { t } = useI18n();

### For server-side:

import { getI18nUtils } from "@quetzallabs/i18n";
const { t } = await getI18nUtils();

Example usage:

t("This text will be translated to multiple locales by Quetzal")

Once your application has some of its text in t functions, you can run `npx quetzal-process-translations`. This command will send new text to be translated and fetch text that has been translated already.

This command should be executed before every build to ensure up-to-date translations are included.
npm package: @quetzallabs/i18n-core
Description: Quetzal Labs i18n Utilities Package
Author: Quetzal Labs, Inc.
Latest version: 0.2.4

# Welcome to Quetzal!

To install: `npm install --save @quetzallabs/i18n-core`

Once installed, run `npx quetzal-setup`

Then, modify quetzal.config.json to include the proper paths and parser

Read more about how to use this package at: https://quetzal.mintlify.app/getting-started

## CLI

Run `npx quetzal-process-translations` to extract text from your app, send them to Quetzal, and retrieve completed translations
npm package: @quetzallabs/i18n-next
Description: Quetzal Labs i18n Utilities Package
Author: Quetzal Labs, Inc.
Latest version: 0.2.1

# Welcome to Quetzal!

This package contains all the utilities you need to get started using Quetzal.

To install: `npm install --save @quetzallabs/i18n`

Once installed, run `npx quetzal-setup`

Read more about how to use this package at: https://quetzal.mintlify.app/getting-started

This package relies on the next-intl provider to put translations into your app: https://www.npmjs.com/package/next-intl

Be sure to include this provider within your next application, and to put the next-intl plugin in your next config file

## The t function

Text in your application is translated by wrapping it in a t function. This function is built on the next-intl t function: https://next-intl-docs.vercel.app/docs/usage/messages

### For components:

import { useI18n } from "@quetzallabs/i18n-next";
const { t } = useI18n();

### For server-side:

import { getI18nUtils } from "@quetzallabs/i18n-next";
const { t } = await getI18nUtils();

Example usage:

t("This text will be translated to multiple locales by Quetzal")

Once your application has some of its text in t functions, you can run `npx quetzal-process-translations`. This command will send new text to be translated and fetch text that has been translated already.

This command should be executed before every build to ensure up-to-date translations are included.
npm package: @quetzallabs/i18n-react-native
Description: Quetzal Labs i18n Utilities Package for React Native
Author: Quetzal Labs, Inc.
Latest version: 0.1.14

# Welcome to Quetzal!

This package contains all the utilities you need to get started using Quetzal.

To install: `npm install --save @quetzallabs/i18n-react-native`

Once installed, run `npx quetzal-setup`

Read more about how to use this package at: https://quetzal.mintlify.app/quickstart

This package relies on the use-intl provider to put translations into your app: https://www.npmjs.com/package/use-intl

The use-intl provider needs to be provided messages and a desired locale, which can be done with:

import { getLocaleAndMessages } from "@quetzallabs/i18n-react-native";
const { locale, messages } = await getLocaleAndMessages();

## The t function

Text in your application is translated by wrapping it in a t function. This function is built on the next-intl t function: https://next-intl-docs.vercel.app/docs/usage/messages

### For components:

import { useI18n } from "@quetzallabs/i18n-react-native";
const { t } = useI18n();

### For server-side:

import { getI18nUtils } from "@quetzallabs/i18n-react-native";
const { t } = await getI18nUtils();

Example usage:

t("This text will be translated to multiple locales by Quetzal")

Once your application has some of its text in t functions, you can run `npx quetzal-process-translations`. This command will send new text to be translated and fetch text that has been translated already.

This command should be executed before every build to ensure up-to-date translations are included.
npm package: @queue-it/akamai-connector
Description: The package enables you to add traffic management support to your website. The Connector Implementation Guide can be found via the Queue-it GO Platform | Help | Connector Integration Documentation. In order to get access please reach out to your Queue-it 
Latest version: 5.0.4

# Queue-it Connector for Akamai
The package enables you to add traffic management support to your website. The Connector Implementation Guide can be found via the Queue-it GO Platform | Help | Connector Integration Documentation. In order to get access please reach out to your Queue-it representative.
npm package: @queue-it/cloudflare
Description: KnownUserV3.Cloudflare
Author: Queue-it
Latest version: 1.2.3

# KnownUser.V3.Cloudflare
The Queue-it Security Framework is used to ensure that end users cannot reach to your protected backend routes without passing the virtual queue by performing a server-side validation before processing a request. This approach is using [Cloudflare Workers](https://developers.cloudflare.com/workers/] ) and [Cloudflare Workers KV](https://developers.cloudflare.com/workers/kv/) to integrate a Cloudflare protected WebServer with [Queue-it](https://queue-it.com/). This repository is containing a JavaScript file `queueitknownuser.bundle.js` you add as a Worker to your Cloudflare distribution to protect your traffic going through Cloudflare. 
## Introduction
When a user makes a request to your backend Cloudflare will trigger queue-it Worker, the  script validates the request and if it is needed, it will redirect the user to the queue. After waiting in the queue, the queue engine will redirect the user back to your end attaching a query string parameter (`queueittoken`) containing some information about the user to the URL.
The most important fields of the `queueittoken` are:

- q - the users' unique queue identifier
- ts - a timestamp of how long this redirect is valid
- h - a hash of the token

After the user is returned from the queue, the Worker script will let the user continue his request to your backend (without redirecting to the queue since the request has a valid queueittoken as querystring).

## Instruction
*  Browse to Cloudflare dashboard -> Workers -> Workers KV and add a new KV, name it `IntegrationConfigKV`
*  Download and unzip the `worker.zip` file from the latest release.
*  Browse to  Cloudflare dashboard -> Workers -> Launch Editor -> Add script and paste the `queueitknownuser.bundle.js` file. 
*  Go to the added script select the Resources tab -> KV Namespaces click Add Binding and for VARIABLE NAME enter `IntegrationConfigKV` and for NAMESPACE you should be able to select `IntegrationConfigKV` which you had added before
*  Add routes you need to be protected by Queue-it (e.g. PROTECTED.YOURDOMAIN.COM/*)
*  Search for `QUEUEIT_CUSTOMERID` and `QUEUEIT_SECRETKEY` in `queueitknownuser.bundle.js` replace their values with your customerId and secretKey found in Go Queue-It self-service platform (I have done it for you in the attached file, so it is not needed here)
*  Setup the Publish web endpoint (e.g. PROTECTED.YOURDOMAIN.COM/?_push_queueit_config)  in Integration -> Overview -> Settings 
*  Setup Trigger and Action in Go Queue-it and once ready click Integration -> Overview -> Show/Hide Instructions and click the Push Now button
>Please contact [queue-it support](https://support.queue-it.com/hc/en-us) for further information and instructions.
npm package: @queuerd/sdk
Description: Official Queuerd SDK for queue status and guard integrations.
Latest version: 0.2.0

# @queuerd/sdk

Official Queuerd SDK for queue status checks and request guards.

## Install

```bash
npm install @queuerd/sdk
```

## Usage

```ts
import { withQueue, getQueueStatus } from "@queuerd/sdk"

const guard = withQueue({
  domain: "store.example.com",
  apiBaseUrl: "https://app.queuerd.com",
})

const status = await getQueueStatus({
  domain: "store.example.com",
  visitorId: "visitor_123",
  apiBaseUrl: "https://app.queuerd.com",
})
```
npm package: @queuert/dashboard
Description: Embeddable web dashboard for Queuert job queue observation
Author: kvet
Latest version: 0.10.0

# @queuert/dashboard

[![npm version](https://img.shields.io/npm/v/@queuert/dashboard.svg)](https://www.npmjs.com/package/@queuert/dashboard)
[![license](https://img.shields.io/github/license/kvet/queuert.svg)](https://github.com/kvet/queuert/blob/main/LICENSE)
[![stars](https://img.shields.io/github/stars/kvet/queuert.svg)](https://github.com/kvet/queuert)
[![last commit](https://img.shields.io/github/last-commit/kvet/queuert.svg)](https://github.com/kvet/queuert/commits)

> **Experimental** — API may change between minor versions.

Embeddable web dashboard for [Queuert](https://github.com/kvet/queuert) — a TypeScript library for database-backed job queues. Provides a web UI for listing, filtering, inspecting, triggering, and deleting job chains and jobs.

## Installation

```bash
npm install @queuert/dashboard
# or
pnpm add @queuert/dashboard
# or
yarn add @queuert/dashboard
```

**Peer dependencies:** `queuert`

## Documentation

- [Dashboard Guide](https://kvet.github.io/queuert/integrations/dashboard/)
- [API Reference](https://kvet.github.io/queuert/reference/dashboard/)
- [Full Documentation](https://kvet.github.io/queuert/)
npm package: @queuert/nats
Description: NATS notify adapter for Queuert job queue system
Author: kvet
Latest version: 0.10.0

# @queuert/nats

[![npm version](https://img.shields.io/npm/v/@queuert/nats.svg)](https://www.npmjs.com/package/@queuert/nats)
![experimental](https://img.shields.io/badge/status-experimental-orange.svg)
[![license](https://img.shields.io/github/license/kvet/queuert.svg)](https://github.com/kvet/queuert/blob/main/LICENSE)
[![stars](https://img.shields.io/github/stars/kvet/queuert.svg)](https://github.com/kvet/queuert)
[![last commit](https://img.shields.io/github/last-commit/kvet/queuert.svg)](https://github.com/kvet/queuert/commits)

> **Experimental** — API may change between minor versions. For production use, consider [@queuert/redis](https://github.com/kvet/queuert/tree/main/packages/redis).

NATS notify adapter for [Queuert](https://github.com/kvet/queuert) — a TypeScript library for database-backed job queues.

## Installation

```bash
npm install @queuert/nats
# or
pnpm add @queuert/nats
# or
yarn add @queuert/nats
```

**Peer dependencies:** `queuert`, `nats` (^2.8.0)

## Documentation

- [Notify Adapters Guide](https://kvet.github.io/queuert/integrations/notify-adapters/)
- [API Reference](https://kvet.github.io/queuert/reference/nats/)
- [Full Documentation](https://kvet.github.io/queuert/)
npm package: @queuert/otel
Description: OpenTelemetry observability adapter for Queuert job queue system
Author: kvet
Latest version: 0.10.0

# @queuert/otel

[![npm version](https://img.shields.io/npm/v/@queuert/otel.svg)](https://www.npmjs.com/package/@queuert/otel)
[![license](https://img.shields.io/github/license/kvet/queuert.svg)](https://github.com/kvet/queuert/blob/main/LICENSE)
[![stars](https://img.shields.io/github/stars/kvet/queuert.svg)](https://github.com/kvet/queuert)
[![last commit](https://img.shields.io/github/last-commit/kvet/queuert.svg)](https://github.com/kvet/queuert/commits)

OpenTelemetry observability adapter for [Queuert](https://github.com/kvet/queuert) — a TypeScript library for database-backed job queues. Provides distributed tracing and metrics for monitoring your job queues.

## Installation

```bash
npm install @queuert/otel
# or
pnpm add @queuert/otel
# or
yarn add @queuert/otel
```

**Peer dependencies:** `queuert`, `@opentelemetry/api` (^1.0.0)

## Documentation

- [Observability Guide](https://kvet.github.io/queuert/integrations/observability/)
- [Metrics Reference](https://kvet.github.io/queuert/advanced/otel-metrics/)
- [Tracing Reference](https://kvet.github.io/queuert/advanced/otel-tracing/)
- [API Reference](https://kvet.github.io/queuert/reference/otel/)
- [Full Documentation](https://kvet.github.io/queuert/)
npm package: @queuert/postgres
Description: PostgreSQL adapter for Queuert job queue system
Author: kvet
Latest version: 0.10.0

# @queuert/postgres

[![npm version](https://img.shields.io/npm/v/@queuert/postgres.svg)](https://www.npmjs.com/package/@queuert/postgres)
[![license](https://img.shields.io/github/license/kvet/queuert.svg)](https://github.com/kvet/queuert/blob/main/LICENSE)
[![stars](https://img.shields.io/github/stars/kvet/queuert.svg)](https://github.com/kvet/queuert)
[![last commit](https://img.shields.io/github/last-commit/kvet/queuert.svg)](https://github.com/kvet/queuert/commits)

PostgreSQL state adapter and notify adapter for [Queuert](https://github.com/kvet/queuert) — a TypeScript library for database-backed job queues.

## Installation

```bash
npm install @queuert/postgres
# or
pnpm add @queuert/postgres
# or
yarn add @queuert/postgres
```

**Peer dependencies:** `queuert`

## Documentation

- [State Adapters Guide](https://kvet.github.io/queuert/integrations/state-adapters/)
- [Notify Adapters Guide](https://kvet.github.io/queuert/integrations/notify-adapters/)
- [API Reference](https://kvet.github.io/queuert/reference/postgres/)
- [Full Documentation](https://kvet.github.io/queuert/)
npm package: @queuert/redis
Description: Redis notify adapter for Queuert job queue system
Author: kvet
Latest version: 0.10.0

# @queuert/redis

[![npm version](https://img.shields.io/npm/v/@queuert/redis.svg)](https://www.npmjs.com/package/@queuert/redis)
[![license](https://img.shields.io/github/license/kvet/queuert.svg)](https://github.com/kvet/queuert/blob/main/LICENSE)
[![stars](https://img.shields.io/github/stars/kvet/queuert.svg)](https://github.com/kvet/queuert)
[![last commit](https://img.shields.io/github/last-commit/kvet/queuert.svg)](https://github.com/kvet/queuert/commits)

Redis notify adapter for [Queuert](https://github.com/kvet/queuert) — a TypeScript library for database-backed job queues.

## Installation

```bash
npm install @queuert/redis
# or
pnpm add @queuert/redis
# or
yarn add @queuert/redis
```

**Peer dependencies:** `queuert`

## Documentation

- [Notify Adapters Guide](https://kvet.github.io/queuert/integrations/notify-adapters/)
- [API Reference](https://kvet.github.io/queuert/reference/redis/)
- [Full Documentation](https://kvet.github.io/queuert/)
npm package: @queuert/sqlite
Description: SQLite adapter for Queuert job queue system
Author: kvet
Latest version: 0.10.0

# @queuert/sqlite

[![npm version](https://img.shields.io/npm/v/@queuert/sqlite.svg)](https://www.npmjs.com/package/@queuert/sqlite)
![experimental](https://img.shields.io/badge/status-experimental-orange.svg)
[![license](https://img.shields.io/github/license/kvet/queuert.svg)](https://github.com/kvet/queuert/blob/main/LICENSE)
[![stars](https://img.shields.io/github/stars/kvet/queuert.svg)](https://github.com/kvet/queuert)
[![last commit](https://img.shields.io/github/last-commit/kvet/queuert.svg)](https://github.com/kvet/queuert/commits)

> **Experimental** — API may change between minor versions. For production use, consider [@queuert/postgres](https://github.com/kvet/queuert/tree/main/packages/postgres).

SQLite state adapter for [Queuert](https://github.com/kvet/queuert) — a TypeScript library for database-backed job queues.

## Installation

```bash
npm install @queuert/sqlite
# or
pnpm add @queuert/sqlite
# or
yarn add @queuert/sqlite
```

**Peer dependencies:** `queuert`

## Documentation

- [State Adapters Guide](https://kvet.github.io/queuert/integrations/state-adapters/)
- [API Reference](https://kvet.github.io/queuert/reference/sqlite/)
- [Full Documentation](https://kvet.github.io/queuert/)
npm package: @queuetue/feathers-authentication-key
Description: Api Key authentication strategy for @feathers/authentication - based on https://github.com/feathersjs/authentication-local
Author: Scott Russell
Latest version: 1.0.2

# @queuetue/feathers-authentication-local

> Api Key authentication strategy for feathers-authentication using Passport without all the boilerplate.

## Installation

```
npm install @queuetue/feathers-authentication-local --save
```

Create an api-key service, and use entries like
{
  _id: "my_api_key",
  userId: "5a6a6bbdc0a6ab23ad868049"
}

Change 'userId' to match auth entity name - profileId, accountId, etc.

## Quick example

### Server
```js
const feathers = require('@feathersjs/feathers');
const authentication = require('feathers-authentication');
const apiKey = require('@queuetue/feathers-authentication-key');
const app = feathers();

// Setup authentication
app.configure(authentication(settings));
app.configure(apiKey());

// Setup a hook to only allow valid JWTs or successful
// apiKey auth to authenticate and get new JWT access tokens

app.service('authentication').hooks({
  before: {
    create: [
      authentication.hooks.authenticate(['apiKey', 'jwt'])
    ]
  }
});
```

### Client
```js
const io = require('socket.io-client');
const feathers = require('@feathersjs/feathers');
const auth = require('@feathersjs/authentication-client');
const socketio = require('@feathersjs/socketio-client');

const feathersClient = feathers();

const socket = io(process.env.CNX_FEATHERS_BASEURL, {
    transports: ['websocket'],
    forceNew: true,
    extraHeaders: {
        Authorization: 'feathers-jwt'
    }
});

feathersClient.configure(socketio(socket));

feathersClient.configure(
    auth({
        strategy: 'apiKey',
    }
    )
);

feathersClient.authenticate({ strategy: 'apiKey', apiKey:'my_api_key' })
    .then((response)=>{
        console.log(feathersClient.passport.verifyJWT(response.accessToken));
    })

```

## License

Copyright (c) 2018

Licensed under the [MIT license](LICENSE).