@omnixal/openclaw-nats-plugin 0.2.3 → 0.2.5

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

@@ -0,0 +1,389 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "c4dc18d6-4faf-4c65-98fc-5d5d25e45cab",
+  "prevId": "e31f4610-cdfc-459e-b947-8363975599a0",
+  "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": {}
+    },
+    "execution_logs": {
+      "name": "execution_logs",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "entity_type": {
+          "name": "entity_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "entity_id": {
+          "name": "entity_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "subject": {
+          "name": "subject",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "detail": {
+          "name": "detail",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "success": {
+          "name": "success",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "execution_logs_entity_idx": {
+          "name": "execution_logs_entity_idx",
+          "columns": [
+            "entity_type",
+            "entity_id"
+          ],
+          "isUnique": false
+        },
+        "execution_logs_created_at_idx": {
+          "name": "execution_logs_created_at_idx",
+          "columns": [
+            "created_at"
+          ],
+          "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

@@ -36,6 +36,13 @@
       "when": 1773965190659,
       "tag": "0004_familiar_zaladane",
       "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "6",
+      "when": 1774274478663,
+      "tag": "0005_strong_supernaut",
+      "breakpoints": true
     }
   ]
 }

package/sidecar/src/db/schema.ts

@@ -55,3 +55,20 @@ export const cronJobs = sqliteTable('cron_jobs', {
 
 export type DbCronJob = typeof cronJobs.$inferSelect;
 export type NewCronJob = typeof cronJobs.$inferInsert;
+
+export const executionLogs = sqliteTable('execution_logs', {
+  id:         text('id').primaryKey(),
+  entityType: text('entity_type').notNull(), // 'route' | 'cron'
+  entityId:   text('entity_id').notNull(),
+  action:     text('action').notNull(), // 'delivery' | 'fire' | 'error' | 'skip'
+  subject:    text('subject').notNull(),
+  detail:     text('detail'), // nullable JSON — error or meta
+  success:    integer('success', { mode: 'boolean' }).notNull().default(true),
+  createdAt:  integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+}, (table) => [
+  index('execution_logs_entity_idx').on(table.entityType, table.entityId),
+  index('execution_logs_created_at_idx').on(table.createdAt),
+]);
+
+export type DbExecutionLog = typeof executionLogs.$inferSelect;
+export type NewExecutionLog = typeof executionLogs.$inferInsert;

package/sidecar/src/logs/log.controller.ts

@@ -0,0 +1,50 @@
+import {
+  Controller, Get, Query,
+  BaseController,
+  type OneBunResponse,
+} from '@onebun/core';
+import { LogService } from './log.service';
+
+@Controller('/api/logs')
+export class LogController extends BaseController {
+  constructor(private logService: LogService) {
+    super();
+  }
+
+  @Get()
+  async getLogs(
+    @Query('entityType') entityType?: string,
+    @Query('entityId') entityId?: string,
+    @Query('limit') limitStr?: string,
+    @Query('offset') offsetStr?: string,
+    @Query('success') successStr?: string,
+    @Query('action') action?: string,
+    @Query('subject') subjectLike?: string,
+  ): Promise<OneBunResponse> {
+    if (!entityType || !entityId) {
+      return this.error('entityType and entityId are required', 400, 400);
+    }
+
+    const limit = Math.min(Number(limitStr) || 50, 200);
+    const offset = Number(offsetStr) || 0;
+    const success = successStr === 'true' ? true : successStr === 'false' ? false : undefined;
+
+    const result = await this.logService.getLogsForEntity(entityType, entityId, {
+      limit,
+      offset,
+      success,
+      action: action || undefined,
+      subjectLike: subjectLike || undefined,
+    });
+    return this.success(result);
+  }
+
+  @Get('/recent')
+  async getRecentLogs(
+    @Query('limit') limitStr?: string,
+  ): Promise<OneBunResponse> {
+    const limit = Math.min(Number(limitStr) || 20, 100);
+    const logs = await this.logService.getRecentLogs(limit);
+    return this.success(logs);
+  }
+}

package/sidecar/src/logs/log.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@onebun/core';
+import { LogRepository } from './log.repository';
+import { LogService } from './log.service';
+import { LogController } from './log.controller';
+
+@Module({
+  controllers: [LogController],
+  providers: [LogRepository, LogService],
+  exports: [LogService],
+})
+export class LogModule {}

package/sidecar/src/logs/log.repository.ts

@@ -0,0 +1,78 @@
+import { Service, BaseService } from '@onebun/core';
+import { DrizzleService, eq, and, desc, sql } from '@onebun/drizzle';
+import { executionLogs, type DbExecutionLog, type NewExecutionLog } from '../db/schema';
+
+export interface LogFilters {
+  entityType: string;
+  entityId: string;
+  success?: boolean;
+  action?: string;
+  subjectLike?: string;
+}
+
+@Service()
+export class LogRepository extends BaseService {
+  constructor(private db: DrizzleService) {
+    super();
+  }
+
+  async insert(log: NewExecutionLog): Promise<void> {
+    await this.db.insert(executionLogs).values(log);
+  }
+
+  private buildWhereConditions(filters: LogFilters) {
+    const conditions = [
+      eq(executionLogs.entityType, filters.entityType),
+      eq(executionLogs.entityId, filters.entityId),
+    ];
+    if (filters.success !== undefined) {
+      conditions.push(eq(executionLogs.success, filters.success));
+    }
+    if (filters.action) {
+      conditions.push(eq(executionLogs.action, filters.action));
+    }
+    if (filters.subjectLike) {
+      conditions.push(sql`${executionLogs.subject} LIKE ${'%' + filters.subjectLike + '%'}`);
+    }
+    return and(...conditions);
+  }
+
+  async findByEntity(
+    filters: LogFilters,
+    limit: number = 50,
+    offset: number = 0,
+  ): Promise<DbExecutionLog[]> {
+    return this.db
+      .select()
+      .from(executionLogs)
+      .where(this.buildWhereConditions(filters))
+      .orderBy(desc(executionLogs.createdAt))
+      .limit(limit)
+      .offset(offset) as any;
+  }
+
+  async countByEntity(filters: LogFilters): Promise<number> {
+    const result = await this.db
+      .select({ count: sql<number>`count(*)` })
+      .from(executionLogs)
+      .where(this.buildWhereConditions(filters));
+    return result[0]?.count ?? 0;
+  }
+
+  async findRecent(limit: number = 20): Promise<DbExecutionLog[]> {
+    return this.db
+      .select()
+      .from(executionLogs)
+      .orderBy(desc(executionLogs.createdAt))
+      .limit(limit) as any;
+  }
+
+  async deleteOlderThan(cutoffMs: number): Promise<number> {
+    const cutoff = new Date(Date.now() - cutoffMs);
+    const result = await this.db
+      .delete(executionLogs)
+      .where(sql`${executionLogs.createdAt} < ${cutoff.getTime()}`)
+      .returning();
+    return result.length;
+  }
+}

package/sidecar/src/logs/log.service.ts

@@ -0,0 +1,116 @@
+import { Service, BaseService } from '@onebun/core';
+import { LogRepository } from './log.repository';
+import { ulid } from 'ulid';
+
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+const CLEANUP_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+
+@Service()
+export class LogService extends BaseService {
+  private cleanupTimer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(private repo: LogRepository) {
+    super();
+  }
+
+  async onModuleInit(): Promise<void> {
+    this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
+  }
+
+  async onModuleDestroy(): Promise<void> {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  async logDelivery(routeId: string, subject: string, detail?: string): Promise<void> {
+    try {
+      await this.repo.insert({
+        id: ulid(),
+        entityType: 'route',
+        entityId: routeId,
+        action: 'delivery',
+        subject,
+        detail: detail ?? null,
+        success: true,
+        createdAt: new Date(),
+      });
+    } catch (err) {
+      this.logger.error('Failed to write delivery log', err);
+    }
+  }
+
+  async logCronFire(jobId: string, subject: string, manual: boolean = false): Promise<void> {
+    try {
+      await this.repo.insert({
+        id: ulid(),
+        entityType: 'cron',
+        entityId: jobId,
+        action: 'fire',
+        subject,
+        detail: manual ? JSON.stringify({ manual: true }) : null,
+        success: true,
+        createdAt: new Date(),
+      });
+    } catch (err) {
+      this.logger.error('Failed to write cron fire log', err);
+    }
+  }
+
+  async logError(entityType: 'route' | 'cron', entityId: string, subject: string, error: unknown): Promise<void> {
+    try {
+      const detail = error instanceof Error
+        ? JSON.stringify({ message: error.message, stack: error.stack })
+        : JSON.stringify({ message: String(error) });
+
+      await this.repo.insert({
+        id: ulid(),
+        entityType,
+        entityId,
+        action: 'error',
+        subject,
+        detail,
+        success: false,
+        createdAt: new Date(),
+      });
+    } catch (err) {
+      this.logger.error('Failed to write error log', err);
+    }
+  }
+
+  async getLogsForEntity(
+    entityType: string,
+    entityId: string,
+    opts?: { limit?: number; offset?: number; success?: boolean; action?: string; subjectLike?: string },
+  ) {
+    const filters = { entityType, entityId, success: opts?.success, action: opts?.action, subjectLike: opts?.subjectLike };
+    const [logs, total] = await Promise.all([
+      this.repo.findByEntity(filters, opts?.limit, opts?.offset),
+      this.repo.countByEntity(filters),
+    ]);
+    return {
+      items: logs.map(l => ({ ...l, createdAt: l.createdAt.getTime() })),
+      total,
+    };
+  }
+
+  async getRecentLogs(limit?: number) {
+    const logs = await this.repo.findRecent(limit);
+    return logs.map(l => ({
+      ...l,
+      createdAt: l.createdAt.getTime(),
+    }));
+  }
+
+  private async cleanup(): Promise<void> {
+    try {
+      const deleted = await this.repo.deleteOlderThan(SEVEN_DAYS_MS);
+      if (deleted > 0) {
+        this.logger.info(`Cleaned up ${deleted} old execution logs`);
+      }
+    } catch (err) {
+      this.logger.error('Failed to cleanup execution logs', err);
+    }
+  }
+}