132 lines
4.4 KiB
TypeScript
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);
|
|
});
|
|
}
|