avifenesh/glide-mq/glide-mq-migrate-bee

Name: glide-mq-migrate-bee
Author: avifenesh

Claude Code and agent skill by avifenesh/glide-mq

Trust tier 2

community

Source check pending

Checking that the SKILL.md file is still in the repository.

Use when moving a Node.js project from Bee-Queue to glide-mq: converting the chained job builder to options, splitting Queue and Worker, and mapping settings, methods and events.

Install

npx vskill@latest install avifenesh/glide-mq/glide-mq-migrate-bee

SKILL.md

Migrate from Bee-Queue to glide-mq

Bee-Queue uses one Queue class for producing and consuming, a chained job builder, and unnamed jobs. glide-mq separates Queue (or Producer) from Worker, takes job options as an object, and requires a job name. The tables below map every setting, method and event; the steps show each conversion. Work through them, then run the project's tests.

The payoff is what Bee-Queue does not have: priorities, flows and DAGs, schedulers, rate limiting, batch workers, broadcast, cluster mode and IAM auth (see What You Gain).

Breaking Changes Summary

Feature	Bee-Queue	glide-mq
Queue + Worker	Single `Queue` class	Separate `Queue` (producer) and `Worker` (consumer)
Job creation	`queue.createJob(data).save()` (chained)	`queue.add(name, data, opts)` (single call)
Job name	Not used - no name parameter	Required first argument to `queue.add()`
Job options	Chained: `.timeout(ms).retries(n)`	Options object: `{ attempts, backoff, delay }`
Retries	`.retries(n)`	`{ attempts: n }` (different name!)
Processing	`queue.process(concurrency, handler)`	`new Worker(name, handler, { concurrency })`
Connection	`redis: { host, port }` or a redis URL	`connection: { addresses: [{ host, port }] }`
Progress	`job.reportProgress(anyJSON)`	`job.updateProgress(number \	object)` (number 0-100 or object)
Per-job events	`job.on('succeeded', ...)`	`QueueEvents` class (centralized)
Stall detection	Manual `checkStalledJobs()`	Automatic on Worker
Batch save	`queue.saveAll(jobs)`	`queue.addBulk(jobs)`
Producer-only	`{ isWorker: false }`	`Producer` class or just `Queue`

Queue Settings Mapping

Bee-Queue Setting	Default	glide-mq Equivalent	Notes
`redis`	`{}`	`connection: { addresses: [...] }`	Array of `{ host, port }` objects
`isWorker`	`true`	Use `Producer` or `Queue` class	Separate classes replace flag
`getEvents`	`true`	Use `QueueEvents` class	Separate class for event subscription
`sendEvents`	`true`	`events: true` on Worker	Controls lifecycle event emission
`storeJobs`	`true`	Always true	glide-mq always stores jobs
`ensureScripts`	`true`	Automatic	Server Functions loaded automatically
`activateDelayedJobs`	`false`	Automatic	Server-side delayed job activation
`removeOnSuccess`	`false`	`{ removeOnComplete: true }`	Per-job option on `queue.add()`
`removeOnFailure`	`false`	`{ removeOnFail: true }`	Per-job option on `queue.add()`
`stallInterval`	`5000`	`lockDuration` on Worker	Lock-based stall detection
`nearTermWindow`	`20min`	N/A	Valkey-native delayed processing
`delayedDebounce`	`1000`	N/A	Server-side scheduling
`prefix`	`'bq'`	`prefix` on Queue	Default: `'glide'`
`quitCommandClient`	`true`	Automatic	Handled by graceful shutdown
`redisScanCount`	`100`	N/A	Different key strategy

Queue Method Mapping

Bee-Queue Method	glide-mq Equivalent	Notes
`queue.createJob(data)`	`queue.add(name, data, opts)`	Name is required; returns Job not builder
`queue.process(n, handler)`	`new Worker(name, handler, { concurrency: n })`	Separate class
`queue.checkStalledJobs(interval)`	Automatic on Worker	No manual call needed
`queue.checkHealth()`	`queue.getJobCounts()`	Returns `{ waiting, active, completed, failed, delayed }`
`queue.close()`	`gracefulShutdown([...])`	Or individual `.close()` calls
`queue.ready()`	`worker.waitUntilReady()`	On Worker, not Queue
`queue.isRunning()`	`worker.isRunning()`	On Worker
`queue.getJob(id)`	`queue.getJob(id)`	Same API
`queue.getJobs(type, page)`	`queue.getJobs(type, start, end)`	Range-based pagination
`queue.removeJob(id)`	`(await queue.getJob(id)).remove()`	Via Job instance
`queue.saveAll(jobs)`	`queue.addBulk(jobs)`	Different input format
`queue.destroy()`	`queue.obliterate()`	Removes all queue data

Event Mapping

Bee-Queue Event	Source	glide-mq Equivalent	Source
`queue.on('ready')`	Queue	`worker.waitUntilReady()`	Worker
`queue.on('error', err)`	Queue	`worker.on('error', err)`	Worker
`queue.on('succeeded', job, result)`	Queue (local)	`worker.on('completed', job, result)`	Worker
`queue.on('retrying', job, err)`	Queue (local)	`worker.on('failed', job, err)`	Worker (with retries remaining)
`queue.on('failed', job, err)`	Queue (local)	`worker.on('failed', job, err)`	Worker
`queue.on('stalled', jobId)`	Queue	`worker.on('stalled', jobId)`	Worker
`queue.on('job succeeded', id, result)`	Queue (PubSub)	`events.on('completed', { jobId })`	QueueEvents
`queue.on('job failed', id, err)`	Queue (PubSub)	`events.on('failed', { jobId })`	QueueEvents
`queue.on('job retrying', id, err)`	Queue (PubSub)	No direct equivalent	Use `events.on('failed')` + retry check
`queue.on('job progress', id, data)`	Queue (PubSub)	`events.on('progress', { jobId, data })`	QueueEvents
`job.on('succeeded', result)`	Job	`events.on('completed', { jobId })`	QueueEvents (filter by jobId)
`job.on('failed', err)`	Job	`events.on('failed', { jobId })`	QueueEvents (filter by jobId)
`job.on('progress', data)`	Job	`events.on('progress', { jobId })`	QueueEvents (filter by jobId)

Per-job events (job.on(...)) do not exist in glide-mq. Use QueueEvents and filter by jobId, or use queue.addAndWait() for request-reply patterns.

Step-by-Step Conversion

1. Connection

typescript

// BEFORE (Bee-Queue)
const Queue = require('bee-queue');
const queue = new Queue('tasks', {
  redis: { host: 'localhost', port: 6379 },
});
// AFTER (glide-mq)
import { Queue, Worker } from 'glide-mq';
const connection = { addresses: [{ host: 'localhost', port: 6379 }] };
const queue = new Queue('tasks', { connection });

2. Job Creation (Biggest Change)

Bee-Queue uses chained builder with no job name. glide-mq uses a single call with a required name.

typescript

// BEFORE (Bee-Queue) - chained builder, no name
const job = await queue
  .createJob({ email: 'user@example.com' })
  .retries(3)
  .backoff('exponential', 1000)
  .delayUntil(Date.now() + 60000)
  .setId('unique-123')
  .save();
// AFTER (glide-mq) - options object, name required
await queue.add(
  'send-email',
  { email: 'user@example.com' },
  {
    attempts: 3, // NOT "retries" - different name!
    backoff: { type: 'exponential', delay: 1000 },
    delay: 60000,
    jobId: 'unique-123',
  },
);

3. Worker

typescript

// BEFORE (Bee-Queue)
queue.process(10, async (job) => {
  return { processed: true };
});
queue.on('succeeded', (job, result) => console.log('Done:', result));
// AFTER (glide-mq) - separate Worker class
const worker = new Worker(
  'tasks',
  async (job) => {
    return { processed: true };
  },
  { connection, concurrency: 10 },
);
worker.on('completed', (job, result) => console.log('Done:', result));

4. Batch Save

typescript

// BEFORE (Bee-Queue)
const jobs = items.map((item) => queue.createJob(item));
await queue.saveAll(jobs);
// AFTER (glide-mq) - each entry needs a name
await queue.addBulk(
  items.map((item) => ({
    name: 'process',
    data: item,
  })),
);

5. Producer-Only

typescript

// BEFORE (Bee-Queue) - disable worker mode
const queue = new Queue('tasks', {
  isWorker: false,
  getEvents: false,
  sendEvents: false,
  redis: { host: 'localhost', port: 6379 },
});
// AFTER (glide-mq) - Producer class
import { Producer } from 'glide-mq';
const producer = new Producer('tasks', { connection });
await producer.add('job-name', data);
await producer.close();

6. Progress Reporting

typescript

// BEFORE (Bee-Queue) - arbitrary JSON
queue.process(async (job) => {
  job.reportProgress({ percent: 50, message: 'halfway' });
  return result;
});
// AFTER (glide-mq) - number (0-100) or object
const worker = new Worker(
  'tasks',
  async (job) => {
    await job.updateProgress(50);
    await job.updateProgress({ page: 3, total: 10 }); // objects also supported
    await job.log('halfway done'); // structured info goes to job.log()
    return result;
  },
  { connection },
);

7. Stall Detection

typescript

// BEFORE (Bee-Queue) - manual setup required
const queue = new Queue('tasks', { stallInterval: 5000 });
queue.checkStalledJobs(5000); // must call manually!

This is the start of the file. Read the full SKILL.md on GitHub.

Security

Security scanPassed, 100 of 100Pattern checks on the skill's files.
Model reviewPassed

See the full security report

Quality evaluation

Task evaluationNot runNo evaluation yet. Run one in Skill Studio.

See evaluation results

Source

SKILL.md in the repositoryCheckingskills/glide-mq-migrate-bee/SKILL.md

Popularity

Repository stars: 80
Repository forks: 1
Repository npm downloads, 7 days: 253
7-day trend score: 37

Stars and forks are for the whole GitHub repository, not this skill alone. Downloads are for the repository's npm package. Refreshed 28 Apr 2026, 6 months ago.

Works with

Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.

Claude Code
Cursor
GitHub Copilot
Windsurf
Codex
Gemini CLI
Cline
Amp
Roo Code
Goose
Continue
Kilo Code
Junie
Trae
OpenHands
Qwen Code
AI Agent
Tabnine Chat
Sourcegraph Cody
Amazon Q
Firebase Genkit
Sweep
Devin
Phind
Mentat
Claude Desktop
Aider
GPT Pilot
Plandex
bolt.new
v0
Replit Agent
Anse
TypingMind
BetterChatGPT
LibreChat
Warp AI
Pieces
Fig AI

Embed badge

[![vskill VERIFIED](https://verified-skill.com/api/v1/skills/avifenesh/glide-mq/glide-mq-migrate-bee/badge)](https://verified-skill.com/skills/avifenesh/glide-mq/glide-mq-migrate-bee)

Something wrong with this skill or its page? Tell us.