Files
waggle-os/packages/worker/src/index.ts
Oleg Maslov b20b138fe4 moving
2026-09-02 10:14:22 +02:00

132 lines
4.4 KiB
TypeScript

import { Worker } from 'bullmq';
import { resolve } from 'node:path';
import { pathToFileURL } from 'node:url';
import { createDb } from '../../server/src/db/connection.js';
import { agentJobs } from '../../server/src/db/schema.js';
import { eq } from 'drizzle-orm';
import { JobProcessor, type JobData } from './job-processor.js';
import Redis from 'ioredis';
import { chatHandler } from './handlers/chat-handler.js';
import { taskHandler } from './handlers/task-handler.js';
import { groupHandler } from './handlers/group-handler.js';
import { createCronHandler } from './handlers/cron-handler.js';
import { createWaggleHandler } from './handlers/waggle-handler.js';
import { JobService } from '../../server/src/services/job-service.js';
const REDIS_URL = process.env.REDIS_URL ?? 'redis://localhost:6381';
function requireDatabaseUrl(): string {
const url = process.env.DATABASE_URL;
if (!url) throw new Error('DATABASE_URL environment variable is required');
return url;
}
export function createWorker(redisUrl = REDIS_URL, databaseUrl?: string, queueName = 'waggle-jobs') {
const resolvedDbUrl = databaseUrl ?? requireDatabaseUrl();
const db = createDb(resolvedDbUrl);
const processor = new JobProcessor();
const redisPub = new Redis(redisUrl);
const jobService = new JobService(db, redisUrl, queueName);
// Register job handlers
processor.register('chat', chatHandler);
processor.register('task', taskHandler);
processor.register('waggle', createWaggleHandler({
enqueueWorker: async ({ teamId, userId, task, role, context }) => {
const childJob = await jobService.createJob(teamId, userId, 'chat', {
message: task,
role,
...(context ? { context } : {}),
});
return childJob.id;
},
}));
processor.register('group', groupHandler);
processor.register('cron', createCronHandler((job, handlerDb) => processor.process(job, handlerDb)));
const url = new URL(redisUrl);
const worker = new Worker<JobData>(queueName, async (job) => {
// Update status to running
await db.update(agentJobs)
.set({ status: 'running', startedAt: new Date() })
.where(eq(agentJobs.id, job.data.jobId));
try {
const result = await processor.process(job, db);
// Update status to completed
await db.update(agentJobs)
.set({ status: 'completed', completedAt: new Date(), output: result })
.where(eq(agentJobs.id, job.data.jobId));
// Publish progress to Redis (includes teamId for gateway routing)
await redisPub.publish(`job:${job.data.jobId}:progress`, JSON.stringify({
status: 'completed',
output: result,
userId: job.data.userId,
teamId: job.data.teamId,
}));
return result;
} catch (error: unknown) {
const message = error instanceof Error ? error.message : String(error);
await db.update(agentJobs)
.set({ status: 'failed', completedAt: new Date(), output: { error: message } })
.where(eq(agentJobs.id, job.data.jobId));
throw error;
}
}, {
connection: {
host: url.hostname,
port: parseInt(url.port || '6379'),
},
concurrency: 5,
});
// Clean up shared Redis publisher when worker closes
worker.on('closed', () => {
redisPub.quit().catch(() => {});
jobService.close().catch(() => {});
});
return { worker, processor, db, redisPub, jobService };
}
// Start if run directly
export function isDirectModule(entryPath: string | undefined, moduleUrl: string): boolean {
return entryPath !== undefined && pathToFileURL(resolve(entryPath)).href === moduleUrl;
}
type ShutdownSignalTarget = {
once(signal: 'SIGTERM' | 'SIGINT', listener: () => void): unknown;
};
export function installShutdownHandlers(
worker: Pick<Worker, 'close'>,
signalTarget: ShutdownSignalTarget = process,
): () => Promise<void> {
let shutdownPromise: Promise<void> | undefined;
const shutdown = () => {
shutdownPromise ??= worker.close();
return shutdownPromise;
};
signalTarget.once('SIGTERM', shutdown);
signalTarget.once('SIGINT', shutdown);
return shutdown;
}
if (isDirectModule(process.argv[1], import.meta.url)) {
const { worker } = createWorker();
installShutdownHandlers(worker);
console.log('Waggle agent worker started, waiting for jobs...');
worker.on('completed', (job) => {
console.log(`Job ${job.id} completed`);
});
worker.on('failed', (job, err) => {
console.error(`Job ${job?.id} failed:`, err.message);
});
}