@omnixal/openclaw-nats-plugin 0.2.0 → 0.2.2

package/sidecar/src/db/migrations/0004_familiar_zaladane.sql

@@ -0,0 +1,17 @@
+CREATE TABLE `cron_jobs` (
+	`id` text PRIMARY KEY NOT NULL,
+	`name` text NOT NULL,
+	`expr` text NOT NULL,
+	`subject` text NOT NULL,
+	`payload` text,
+	`timezone` text DEFAULT 'UTC' NOT NULL,
+	`enabled` integer DEFAULT true NOT NULL,
+	`last_run_at` integer,
+	`created_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `cron_jobs_name_unique` ON `cron_jobs` (`name`);--> statement-breakpoint
+CREATE INDEX `cron_jobs_name_idx` ON `cron_jobs` (`name`);--> statement-breakpoint
+ALTER TABLE `event_routes` ADD `last_delivered_at` integer;--> statement-breakpoint
+ALTER TABLE `event_routes` ADD `last_event_subject` text;--> statement-breakpoint
+ALTER TABLE `event_routes` ADD `delivery_count` integer DEFAULT 0 NOT NULL;

package/sidecar/src/db/migrations/meta/0004_snapshot.json

@@ -0,0 +1,306 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "e31f4610-cdfc-459e-b947-8363975599a0",
+  "prevId": "cb92737c-c257-4b58-bbf0-798ab1494961",
+  "tables": {
+    "cron_jobs": {
+      "name": "cron_jobs",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "expr": {
+          "name": "expr",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "subject": {
+          "name": "subject",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload": {
+          "name": "payload",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "timezone": {
+          "name": "timezone",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'UTC'"
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "last_run_at": {
+          "name": "last_run_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "cron_jobs_name_unique": {
+          "name": "cron_jobs_name_unique",
+          "columns": [
+            "name"
+          ],
+          "isUnique": true
+        },
+        "cron_jobs_name_idx": {
+          "name": "cron_jobs_name_idx",
+          "columns": [
+            "name"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "dedup_events": {
+      "name": "dedup_events",
+      "columns": {
+        "event_id": {
+          "name": "event_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "subject": {
+          "name": "subject",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "seen_at": {
+          "name": "seen_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "dedup_events_seen_at_idx": {
+          "name": "dedup_events_seen_at_idx",
+          "columns": [
+            "seen_at"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "event_routes": {
+      "name": "event_routes",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "pattern": {
+          "name": "pattern",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "target": {
+          "name": "target",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'main'"
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "priority": {
+          "name": "priority",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 5
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_delivered_at": {
+          "name": "last_delivered_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_event_subject": {
+          "name": "last_event_subject",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "delivery_count": {
+          "name": "delivery_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "event_routes_pattern_unique": {
+          "name": "event_routes_pattern_unique",
+          "columns": [
+            "pattern"
+          ],
+          "isUnique": true
+        },
+        "event_routes_pattern_idx": {
+          "name": "event_routes_pattern_idx",
+          "columns": [
+            "pattern"
+          ],
+          "isUnique": false
+        },
+        "event_routes_target_idx": {
+          "name": "event_routes_target_idx",
+          "columns": [
+            "target"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "pending_events": {
+      "name": "pending_events",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "session_key": {
+          "name": "session_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "subject": {
+          "name": "subject",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload": {
+          "name": "payload",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "priority": {
+          "name": "priority",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 5
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "delivered_at": {
+          "name": "delivered_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

package/sidecar/src/db/migrations/meta/_journal.json

@@ -29,6 +29,13 @@
       "when": 1773938595817,
       "tag": "0003_wet_deathbird",
       "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "6",
+      "when": 1773965190659,
+      "tag": "0004_familiar_zaladane",
+      "breakpoints": true
     }
   ]
 }

package/sidecar/src/db/schema.ts

@@ -28,6 +28,9 @@ export const eventRoutes = sqliteTable('event_routes', {
   enabled:   integer('enabled', { mode: 'boolean' }).notNull().default(true),
   priority:  integer('priority').notNull().default(5),
   createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+  lastDeliveredAt: integer('last_delivered_at', { mode: 'timestamp_ms' }),
+  lastEventSubject: text('last_event_subject'),
+  deliveryCount: integer('delivery_count').notNull().default(0),
 }, (table) => [
   index('event_routes_pattern_idx').on(table.pattern),
   index('event_routes_target_idx').on(table.target),
@@ -35,3 +38,20 @@ export const eventRoutes = sqliteTable('event_routes', {
 
 export type DbEventRoute = typeof eventRoutes.$inferSelect;
 export type NewEventRoute = typeof eventRoutes.$inferInsert;
+
+export const cronJobs = sqliteTable('cron_jobs', {
+  id:        text('id').primaryKey(),
+  name:      text('name').notNull().unique(),
+  expr:      text('expr').notNull(),
+  subject:   text('subject').notNull(),
+  payload:   text('payload', { mode: 'json' }).$type<unknown>(),
+  timezone:  text('timezone').notNull().default('UTC'),
+  enabled:   integer('enabled', { mode: 'boolean' }).notNull().default(true),
+  lastRunAt: integer('last_run_at', { mode: 'timestamp_ms' }),
+  createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+}, (table) => [
+  index('cron_jobs_name_idx').on(table.name),
+]);
+
+export type DbCronJob = typeof cronJobs.$inferSelect;
+export type NewCronJob = typeof cronJobs.$inferInsert;

package/sidecar/src/health/health.service.ts

@@ -49,7 +49,7 @@ export class HealthService extends BaseService {
       pendingCount,
       uptimeSeconds: Math.floor((Date.now() - this.startedAt) / 1000),
       config: {
-        streams: ['agent_events', 'agent_dlq'],
+        streams: ['agent_events', 'agent_dlq', 'scheduler_internal'],
         consumerName: this.config.get('consumer.name'),
         dedupTtlSeconds: this.config.get('dedup.ttlSeconds'),
       },

package/sidecar/src/index.ts

@@ -35,6 +35,12 @@ const app = new OneBunApplication(AppModule, {
           retention: 'limits',
           maxAge: SEVEN_DAYS_NS,
         },
+        {
+          name: 'scheduler_internal',
+          subjects: ['scheduler.>'],
+          retention: 'limits',
+          maxAge: 24 * 60 * 60 * 1e9, // 1 day
+        },
       ],
       consumerConfig: {
         ackWait: ackWaitMs * 1_000_000, // ms → ns

package/sidecar/src/metrics/metrics.controller.ts

@@ -0,0 +1,16 @@
+import { Controller, BaseController, Get, UseMiddleware } from '@onebun/core';
+import { ApiKeyMiddleware } from '../auth/api-key.middleware';
+import { MetricsService } from './metrics.service';
+
+@Controller('/api/metrics')
+@UseMiddleware(ApiKeyMiddleware)
+export class MetricsController extends BaseController {
+  constructor(private metrics: MetricsService) {
+    super();
+  }
+
+  @Get('/')
+  getAll() {
+    return this.success(this.metrics.getAll());
+  }
+}

package/sidecar/src/metrics/metrics.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@onebun/core';
+import { MetricsService } from './metrics.service';
+import { MetricsController } from './metrics.controller';
+
+@Module({
+  controllers: [MetricsController],
+  providers: [MetricsService],
+  exports: [MetricsService],
+})
+export class MetricsModule {}

package/sidecar/src/metrics/metrics.service.ts

@@ -0,0 +1,64 @@
+import { Service, BaseService } from '@onebun/core';
+
+export interface SubjectMetric {
+  subject: string;
+  published: number;
+  consumed: number;
+  lastPublishedAt: number | null;
+  lastConsumedAt: number | null;
+}
+
+interface CounterEntry {
+  count: number;
+  lastAt: number;
+}
+
+@Service()
+export class MetricsService extends BaseService {
+  private published = new Map<string, CounterEntry>();
+  private consumed = new Map<string, CounterEntry>();
+
+  recordPublish(subject: string): void {
+    const entry = this.published.get(subject);
+    const now = Date.now();
+    if (entry) {
+      entry.count++;
+      entry.lastAt = now;
+    } else {
+      this.published.set(subject, { count: 1, lastAt: now });
+    }
+  }
+
+  recordConsume(subject: string): void {
+    const entry = this.consumed.get(subject);
+    const now = Date.now();
+    if (entry) {
+      entry.count++;
+      entry.lastAt = now;
+    } else {
+      this.consumed.set(subject, { count: 1, lastAt: now });
+    }
+  }
+
+  getAll(): SubjectMetric[] {
+    const subjects = new Set<string>([
+      ...this.published.keys(),
+      ...this.consumed.keys(),
+    ]);
+
+    const result: SubjectMetric[] = [];
+    for (const subject of subjects) {
+      const pub = this.published.get(subject);
+      const con = this.consumed.get(subject);
+      result.push({
+        subject,
+        published: pub?.count ?? 0,
+        consumed: con?.count ?? 0,
+        lastPublishedAt: pub?.lastAt ?? null,
+        lastConsumedAt: con?.lastAt ?? null,
+      });
+    }
+
+    return result.sort((a, b) => a.subject.localeCompare(b.subject));
+  }
+}

package/sidecar/src/publisher/publisher.module.ts

@@ -1,8 +1,10 @@
 import { Module } from '@onebun/core';
 import { PublisherService } from './publisher.service';
 import { PublisherController } from './publisher.controller';
+import { MetricsModule } from '../metrics/metrics.module';
 
 @Module({
+  imports: [MetricsModule],
   controllers: [PublisherController],
   providers: [PublisherService],
   exports: [PublisherService],

package/sidecar/src/publisher/publisher.service.ts

@@ -1,15 +1,20 @@
 import { Service, BaseService, QueueService } from '@onebun/core';
 import { createEnvelope, type EnvelopeMeta } from './envelope';
+import { MetricsService } from '../metrics/metrics.service';
 
 @Service()
 export class PublisherService extends BaseService {
-  constructor(private queueService: QueueService) {
+  constructor(
+    private queueService: QueueService,
+    private metrics: MetricsService,
+  ) {
     super();
   }
 
   async publish(subject: string, payload: unknown, meta?: EnvelopeMeta): Promise<void> {
     const envelope = createEnvelope(subject, payload, meta);
     await this.queueService.publish(subject, envelope);
+    this.metrics.recordPublish(subject);
     this.logger.debug(`Published to ${subject}`, { id: envelope.id });
   }
 }

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

@@ -10,17 +10,9 @@ import {
   UseMiddleware,
   type OneBunResponse,
 } from '@onebun/core';
-import { type } from 'arktype';
 import { RouterService } from './router.service';
 import { ApiKeyMiddleware } from '../auth/api-key.middleware';
-
-const createRouteBody = type({
-  pattern: 'string',
-  'target?': 'string',
-  'priority?': 'number',
-});
-
-type CreateRouteBody = typeof createRouteBody.infer;
+import { createRouteBodySchema, type CreateRouteBody } from '../validation/schemas';
 
 @Controller('/api/routes')
 @UseMiddleware(ApiKeyMiddleware)
@@ -35,6 +27,22 @@ export class RouterController extends BaseController {
     return this.success(status);
   }
 
+  @Get('/health')
+  async getRoutesHealth(): Promise<OneBunResponse> {
+    const routes = await this.routerService.listRoutes();
+    const now = Date.now();
+    const result = routes.map(r => ({
+      pattern: r.pattern,
+      target: r.target,
+      enabled: r.enabled,
+      lastDeliveredAt: r.lastDeliveredAt?.toISOString() ?? null,
+      lastEventSubject: r.lastEventSubject ?? null,
+      deliveryCount: r.deliveryCount ?? 0,
+      lagMs: r.lastDeliveredAt ? now - r.lastDeliveredAt.getTime() : null,
+    }));
+    return this.success(result);
+  }
+
   @Get()
   async getRoutes(@Query() query: Record<string, string>): Promise<OneBunResponse> {
     const filters: { pattern?: string; target?: string } = {};
@@ -45,16 +53,16 @@ export class RouterController extends BaseController {
   }
 
   @Post()
-  async createRoute(@Body(createRouteBody) body: CreateRouteBody): Promise<OneBunResponse> {
+  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);
     }
-    const route = await this.routerService.subscribe(
+    const { route, created } = await this.routerService.subscribe(
       body.pattern,
       body.target ?? 'main',
       body.priority ?? 5,
     );
-    return this.success(route);
+    return this.success({ ...route, created });
   }
 
   @Delete('/:id')

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

@@ -1,5 +1,5 @@
 import { Service, BaseService } from '@onebun/core';
-import { DrizzleService, eq } from '@onebun/drizzle';
+import { DrizzleService, eq, sql } from '@onebun/drizzle';
 import { eventRoutes, type DbEventRoute, type NewEventRoute } from '../db/schema';
 
 @Service()
@@ -9,16 +9,18 @@ export class RouterRepository extends BaseService {
   }
 
   async findAll(filters?: { pattern?: string; target?: string }): Promise<DbEventRoute[]> {
-    let query = this.db.select().from(eventRoutes);
+    // drizzle type limitation: chained .where()/.orderBy() loses type info
+    let query = this.db.select().from(eventRoutes) as any;
     if (filters?.pattern) {
-      query = query.where(eq(eventRoutes.pattern, filters.pattern)) as any;
+      query = query.where(eq(eventRoutes.pattern, filters.pattern));
     } else if (filters?.target) {
-      query = query.where(eq(eventRoutes.target, filters.target)) as any;
+      query = query.where(eq(eventRoutes.target, filters.target));
     }
-    return query.orderBy(eventRoutes.priority) as any;
+    return query.orderBy(eventRoutes.priority);
   }
 
   async findEnabled(): Promise<DbEventRoute[]> {
+    // drizzle type limitation: chained .where()/.orderBy() loses type info
     return this.db.select().from(eventRoutes)
       .where(eq(eventRoutes.enabled, true))
       .orderBy(eventRoutes.priority) as any;
@@ -29,6 +31,34 @@ export class RouterRepository extends BaseService {
     return created;
   }
 
+  async upsert(route: NewEventRoute): Promise<{ route: DbEventRoute; created: boolean }> {
+    const [result] = await this.db
+      .insert(eventRoutes)
+      .values(route)
+      .onConflictDoUpdate({
+        target: eventRoutes.pattern,
+        set: {
+          target: sql`excluded.target`,
+          priority: sql`excluded.priority`,
+          enabled: sql`excluded.enabled`,
+        },
+      })
+      .returning();
+
+    const created = result.createdAt.getTime() === route.createdAt!.getTime();
+    return { route: result, created };
+  }
+
+  async recordDelivery(routeId: string, subject: string): Promise<void> {
+    await this.db.update(eventRoutes)
+      .set({
+        lastDeliveredAt: new Date(),
+        lastEventSubject: subject,
+        deliveryCount: sql`${eventRoutes.deliveryCount} + 1`,
+      })
+      .where(eq(eventRoutes.id, routeId));
+  }
+
   async deleteById(id: string): Promise<boolean> {
     const result = await this.db.delete(eventRoutes).where(eq(eventRoutes.id, id)).returning();
     return result.length > 0;
@@ -40,7 +70,9 @@ export class RouterRepository extends BaseService {
   }
 
   async count(): Promise<number> {
-    const rows = await this.db.select().from(eventRoutes);
-    return rows.length;
+    const result = await this.db
+      .select({ count: sql<number>`count(*)` })
+      .from(eventRoutes);
+    return result[0]?.count ?? 0;
   }
 }

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

@@ -39,8 +39,12 @@ export class RouterService extends BaseService {
     return this.repo.findAll(filters);
   }
 
-  async subscribe(pattern: string, target: string = 'main', priority: number = 5): Promise<DbEventRoute> {
-    return this.repo.create({
+  async subscribe(
+    pattern: string,
+    target: string = 'main',
+    priority: number = 5,
+  ): Promise<{ route: DbEventRoute; created: boolean }> {
+    return this.repo.upsert({
       id: ulid(),
       pattern,
       target,
@@ -50,6 +54,10 @@ export class RouterService extends BaseService {
     });
   }
 
+  async recordDelivery(routeId: string, subject: string): Promise<void> {
+    await this.repo.recordDelivery(routeId, subject);
+  }
+
   async unsubscribe(pattern: string): Promise<boolean> {
     return this.repo.deleteByPattern(pattern);
   }