@omnixal/openclaw-nats-plugin 0.2.4 → 0.2.6

package/sidecar/src/router/router.controller.ts

@@ -2,6 +2,7 @@ import {
   Controller,
   Get,
   Post,
+  Patch,
   Delete,
   Body,
   Param,
@@ -12,7 +13,11 @@ import {
 } from '@onebun/core';
 import { RouterService } from './router.service';
 import { ApiKeyMiddleware } from '../auth/api-key.middleware';
-import { createRouteBodySchema, type CreateRouteBody } from '../validation/schemas';
+import {
+  createRouteBodySchema, type CreateRouteBody,
+  updateRouteBodySchema, type UpdateRouteBody,
+  isValidAgentSubject,
+} from '../validation/schemas';
 
 @Controller('/api/routes')
 @UseMiddleware(ApiKeyMiddleware)
@@ -32,8 +37,10 @@ export class RouterController extends BaseController {
     const routes = await this.routerService.listRoutes();
     const now = Date.now();
     const result = routes.map(r => ({
+      id: r.id,
       pattern: r.pattern,
       target: r.target,
+      priority: r.priority,
       enabled: r.enabled,
       lastDeliveredAt: r.lastDeliveredAt?.toISOString() ?? null,
       lastEventSubject: r.lastEventSubject ?? null,
@@ -44,18 +51,21 @@ export class RouterController extends BaseController {
   }
 
   @Get()
-  async getRoutes(@Query() query: Record<string, string>): Promise<OneBunResponse> {
+  async getRoutes(
+    @Query('pattern') pattern?: string,
+    @Query('target') target?: string,
+  ): Promise<OneBunResponse> {
     const filters: { pattern?: string; target?: string } = {};
-    if (query?.pattern) filters.pattern = query.pattern;
-    if (query?.target) filters.target = query.target;
+    if (pattern) filters.pattern = pattern;
+    if (target) filters.target = target;
     const routes = await this.routerService.listRoutes(filters);
     return this.success(routes);
   }
 
   @Post()
   async createRoute(@Body(createRouteBodySchema) body: CreateRouteBody): Promise<OneBunResponse> {
-    if (!body.pattern.startsWith('agent.events.')) {
-      return this.error('pattern must start with agent.events.', 400, 400);
+    if (!isValidAgentSubject(body.pattern)) {
+      return this.error('pattern must start with "agent.events." followed by at least one token and must not end with "."', 400, 400);
     }
     const { route, created } = await this.routerService.subscribe(
       body.pattern,
@@ -65,6 +75,18 @@ export class RouterController extends BaseController {
     return this.success({ ...route, created });
   }
 
+  @Patch('/:id')
+  async updateRoute(
+    @Param('id') id: string,
+    @Body(updateRouteBodySchema) body: UpdateRouteBody,
+  ): Promise<OneBunResponse> {
+    const updated = await this.routerService.updateById(id, body);
+    if (!updated) {
+      return this.error('Route not found', 404, 404);
+    }
+    return this.success(updated);
+  }
+
   @Delete('/:id')
   async deleteRoute(@Param('id') id: string): Promise<OneBunResponse> {
     const deleted = await this.routerService.deleteById(id);

package/sidecar/src/router/router.repository.ts

@@ -49,6 +49,14 @@ export class RouterRepository extends BaseService {
     return { route: result, created };
   }
 
+  async updateById(id: string, fields: Partial<Pick<DbEventRoute, 'target' | 'priority' | 'enabled'>>): Promise<DbEventRoute | null> {
+    const [result] = await this.db.update(eventRoutes)
+      .set(fields)
+      .where(eq(eventRoutes.id, id))
+      .returning();
+    return result ?? null;
+  }
+
   async recordDelivery(routeId: string, subject: string): Promise<void> {
     await this.db.update(eventRoutes)
       .set({

package/sidecar/src/router/router.service.ts

@@ -54,6 +54,10 @@ export class RouterService extends BaseService {
     });
   }
 
+  async updateById(id: string, fields: { target?: string; priority?: number; enabled?: boolean }): Promise<DbEventRoute | null> {
+    return this.repo.updateById(id, fields);
+  }
+
   async recordDelivery(routeId: string, subject: string): Promise<void> {
     await this.repo.recordDelivery(routeId, subject);
   }

package/sidecar/src/scheduler/scheduler.controller.ts

@@ -4,10 +4,18 @@ import {
   UseMiddleware, Subscribe, OnQueueReady,
   type Message,
   type OneBunResponse,
+  OnQueueError,
+  OnMessageReceived,
+  OnMessageProcessed,
+  OnMessageFailed,
 } from '@onebun/core';
 import { SchedulerService } from './scheduler.service';
 import { ApiKeyMiddleware } from '../auth/api-key.middleware';
-import { createCronBodySchema, type CreateCronBody } from '../validation/schemas';
+import {
+  createCronBodySchema, type CreateCronBody,
+  updateCronBodySchema, type UpdateCronBody,
+  isValidAgentSubject,
+} from '../validation/schemas';
 
 @Controller('/api/cron')
 @UseMiddleware(ApiKeyMiddleware)
@@ -18,13 +26,21 @@ export class SchedulerController extends BaseController {
 
   @OnQueueReady()
   async onQueueReady(): Promise<void> {
+    this.logger.info('Queue connected, starting scheduler');
+    this.scheduler.markQueueReady();
     await this.scheduler.restoreJobs();
   }
 
+  @OnQueueError()
+  handleError(error: Error) {
+    this.logger.error('Queue error (publish stopped)', error);
+    this.scheduler.markQueueReady(false);
+  }
+
   @Post()
   async createJob(@Body(createCronBodySchema) body: CreateCronBody): Promise<OneBunResponse> {
-    if (!body.subject.startsWith('agent.events.')) {
-      return this.error('subject must start with agent.events.', 400, 400);
+    if (!isValidAgentSubject(body.subject)) {
+      return this.error('subject must start with "agent.events." followed by at least one token and must not end with "."', 400, 400);
     }
     const job = await this.scheduler.add({
       name: body.name,
@@ -42,6 +58,19 @@ export class SchedulerController extends BaseController {
     return this.success(jobs);
   }
 
+  @Patch('/:name')
+  async updateJob(
+    @Param('name') name: string,
+    @Body(updateCronBodySchema) body: UpdateCronBody,
+  ): Promise<OneBunResponse> {
+    if (body.subject !== undefined && !isValidAgentSubject(body.subject)) {
+      return this.error('subject must start with "agent.events." followed by at least one token and must not end with "."', 400, 400);
+    }
+    const updated = await this.scheduler.update(name, body);
+    if (!updated) return this.error('Job not found', 404, 404);
+    return this.success(updated);
+  }
+
   @Patch('/:name/toggle')
   async toggleJob(@Param('name') name: string): Promise<OneBunResponse> {
     const result = await this.scheduler.toggle(name);

package/sidecar/src/scheduler/scheduler.module.ts

@@ -1,11 +1,12 @@
 import { Module } from '@onebun/core';
 import { PublisherModule } from '../publisher/publisher.module';
+import { LogModule } from '../logs/log.module';
 import { SchedulerRepository } from './scheduler.repository';
 import { SchedulerService } from './scheduler.service';
 import { SchedulerController } from './scheduler.controller';
 
 @Module({
-  imports: [PublisherModule],
+  imports: [PublisherModule, LogModule],
   controllers: [SchedulerController],
   providers: [SchedulerRepository, SchedulerService],
   exports: [SchedulerService],

package/sidecar/src/scheduler/scheduler.repository.ts

@@ -44,6 +44,14 @@ export class SchedulerRepository extends BaseService {
     return result;
   }
 
+  async updateByName(name: string, fields: Partial<Pick<DbCronJob, 'expr' | 'subject' | 'payload' | 'timezone' | 'enabled'>>): Promise<DbCronJob | null> {
+    const [result] = await this.db.update(cronJobs)
+      .set(fields)
+      .where(eq(cronJobs.name, name))
+      .returning();
+    return result ?? null;
+  }
+
   async deleteByName(name: string): Promise<boolean> {
     const result = await this.db.delete(cronJobs)
       .where(eq(cronJobs.name, name)).returning();

package/sidecar/src/scheduler/scheduler.service.ts

@@ -1,6 +1,7 @@
 import { Service, BaseService, QueueService } from '@onebun/core';
 import { SchedulerRepository } from './scheduler.repository';
 import { PublisherService } from '../publisher/publisher.service';
+import { LogService } from '../logs/log.service';
 import { ulid } from 'ulid';
 
 interface AddJobInput {
@@ -13,10 +14,13 @@ interface AddJobInput {
 
 @Service()
 export class SchedulerService extends BaseService {
+  private _queueReady = false;
+
   constructor(
     private repo: SchedulerRepository,
     private queueService: QueueService,
     private publisher: PublisherService,
+    private logService: LogService,
   ) {
     super();
   }
@@ -25,17 +29,27 @@ export class SchedulerService extends BaseService {
     return this.queueService.getScheduler();
   }
 
+  markQueueReady(isReady = true): void {
+    this._queueReady = isReady;
+  }
+
   async restoreJobs(): Promise<void> {
-    const jobs = await this.repo.findAllEnabled();
-    for (const job of jobs) {
-      this.scheduler.addCronJob(
-        job.name,
-        job.expr,
-        `scheduler.fire.${job.name}`,
-      );
-    }
-    if (jobs.length > 0) {
-      this.logger.info(`Restored ${jobs.length} cron jobs from DB`);
+    try {
+      const jobs = await this.repo.findAllEnabled();
+      for (const job of jobs) {
+        this.scheduler.addCronJob(
+          job.name,
+          job.expr,
+          `scheduler.fire.${job.name}`,
+        );
+      }
+      if (jobs.length > 0) {
+        this.logger.info(`Restored ${jobs.length} cron jobs from DB`);
+      } else {
+        this.logger.info('No cron jobs found in DB');
+      }
+    } catch (err) {
+      this.logger.error('Failed to restore cron jobs', err);
     }
   }
 
@@ -65,6 +79,33 @@ export class SchedulerService extends BaseService {
     return job;
   }
 
+  async update(name: string, fields: { cron?: string; subject?: string; payload?: unknown; timezone?: string; enabled?: boolean }) {
+    const updates: Record<string, unknown> = {};
+    if (fields.cron !== undefined) updates.expr = fields.cron;
+    if (fields.subject !== undefined) updates.subject = fields.subject;
+    if (fields.payload !== undefined) updates.payload = fields.payload;
+    if (fields.timezone !== undefined) updates.timezone = fields.timezone;
+    if (fields.enabled !== undefined) updates.enabled = fields.enabled;
+
+    if (Object.keys(updates).length === 0) {
+      return this.repo.findByName(name);
+    }
+
+    const updated = await this.repo.updateByName(name, updates as any);
+    if (!updated) return null;
+
+    // Re-register in runtime scheduler if expr or enabled changed
+    if (this.scheduler.hasJob(name)) {
+      this.scheduler.removeJob(name);
+    }
+    if (updated.enabled) {
+      this.scheduler.addCronJob(name, updated.expr, `scheduler.fire.${name}`);
+    }
+
+    this.logger.info(`Cron job '${name}' updated`);
+    return updated;
+  }
+
   async remove(name: string): Promise<boolean> {
     const deleted = await this.repo.deleteByName(name);
     if (this.scheduler.hasJob(name)) {
@@ -79,6 +120,8 @@ export class SchedulerService extends BaseService {
       const runtime = this.scheduler.getJob(job.name);
       return {
         ...job,
+        lastRunAt: job.lastRunAt?.getTime() ?? null,
+        createdAt: job.createdAt.getTime(),
         nextRun: runtime?.nextRun ?? null,
         isRunning: runtime?.isRunning ?? false,
       };
@@ -109,30 +152,53 @@ export class SchedulerService extends BaseService {
     return this.repo.findByName(name);
   }
 
+  private buildCronPayload(job: { name: string; payload: unknown }, manual: boolean): Record<string, unknown> {
+    const base = (job.payload && typeof job.payload === 'object' && !Array.isArray(job.payload))
+      ? (job.payload as Record<string, unknown>)
+      : {};
+    return { ...base, _cron: { jobName: job.name, firedAt: new Date().toISOString(), ...(manual ? { manual: true } : {}) } };
+  }
+
   async fireNow(name: string): Promise<boolean> {
     const job = await this.repo.findByName(name);
     if (!job) return false;
 
-    const base = (job.payload && typeof job.payload === 'object' && !Array.isArray(job.payload))
-      ? (job.payload as Record<string, unknown>)
-      : {};
-    const payload = { ...base, _cron: { jobName: job.name, firedAt: new Date().toISOString(), manual: true } };
-    await this.publisher.publish(job.subject, payload);
-    await this.repo.updateLastRun(name);
-    this.logger.info(`Cron job '${name}' manually fired -> ${job.subject}`);
-    return true;
+    if (!this._queueReady) {
+      this.logger.warn(`Cron job '${name}' fire skipped — queue not ready`);
+      return false;
+    }
+
+    try {
+      const payload = this.buildCronPayload(job, true);
+      await this.publisher.publish(job.subject, payload);
+      await this.repo.updateLastRun(name);
+      await this.logService.logCronFire(job.id, job.subject, true);
+      this.logger.info(`Cron job '${name}' manually fired -> ${job.subject}`);
+      return true;
+    } catch (err) {
+      await this.logService.logError('cron', job.id, job.subject, err);
+      throw err;
+    }
   }
 
   async handleFire(jobName: string): Promise<void> {
     const job = await this.repo.findByName(jobName);
     if (!job || !job.enabled) return;
 
-    const base = (job.payload && typeof job.payload === 'object' && !Array.isArray(job.payload))
-      ? (job.payload as Record<string, unknown>)
-      : {};
-    const payload = { ...base, _cron: { jobName: job.name, firedAt: new Date().toISOString() } };
-    await this.publisher.publish(job.subject, payload);
-    await this.repo.updateLastRun(job.name);
-    this.logger.debug(`Cron fired: ${job.name} -> ${job.subject}`);
+    if (!this._queueReady) {
+      this.logger.warn(`Cron fire skipped for '${jobName}' — queue not ready`);
+      return;
+    }
+
+    try {
+      const payload = this.buildCronPayload(job, false);
+      await this.publisher.publish(job.subject, payload);
+      await this.repo.updateLastRun(job.name);
+      await this.logService.logCronFire(job.id, job.subject, false);
+      this.logger.debug(`Cron fired: ${job.name} -> ${job.subject}`);
+    } catch (err) {
+      await this.logService.logError('cron', job.id, job.subject, err);
+      this.logger.error(`Cron fire failed: ${job.name}`, err);
+    }
   }
 }

package/sidecar/src/validation/schemas.ts

@@ -35,3 +35,30 @@ export const createCronBodySchema = type({
 });
 
 export type CreateCronBody = typeof createCronBodySchema.infer;
+
+export const updateRouteBodySchema = type({
+  'target?': 'string',
+  'priority?': 'number',
+  'enabled?': 'boolean',
+});
+
+export type UpdateRouteBody = typeof updateRouteBodySchema.infer;
+
+export const updateCronBodySchema = type({
+  'cron?': 'string',
+  'subject?': 'string',
+  'payload?': 'unknown',
+  'timezone?': 'string',
+  'enabled?': 'boolean',
+});
+
+export type UpdateCronBody = typeof updateCronBodySchema.infer;
+
+/** Validate that subject has content after 'agent.events.' prefix and doesn't end with '.' */
+export function isValidAgentSubject(subject: string): boolean {
+  if (!subject.startsWith('agent.events.')) return false;
+  const rest = subject.slice('agent.events.'.length);
+  if (rest.length === 0) return false;
+  if (rest.endsWith('.')) return false;
+  return true;
+}