@omnixal/openclaw-nats-plugin 0.2.14 → 0.2.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnixal/openclaw-nats-plugin",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "description": "NATS JetStream event-driven plugin for OpenClaw",
   "license": "MIT",
   "type": "module",

package/plugins/nats-context-engine/http-handler.ts

@@ -2,13 +2,11 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
-import http from 'node:http';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 
 const ROUTE_PREFIX = '/nats-dashboard';
 const SIDECAR_URL = process.env.NATS_SIDECAR_URL || 'http://127.0.0.1:3104';
 const API_KEY = process.env.NATS_PLUGIN_API_KEY || 'dev-nats-plugin-key';
-const sidecarParsed = new URL(SIDECAR_URL);
 
 // Stable location (copied during setup) takes priority over in-package dist
 const STABLE_DIST = path.join(homedir(), '.openclaw', 'nats-plugin', 'dashboard');
@@ -28,10 +26,33 @@ const MIME_TYPES: Record<string, string> = {
 
 export function createDashboardHandler() {
   return async (req: IncomingMessage, res: ServerResponse): Promise<boolean> => {
-    const url = new URL(req.url!, `http://${req.headers.host}`);
-    const subPath = url.pathname.slice(ROUTE_PREFIX.length);
+    const rawUrl = req.url || '/';
+    const url = new URL(rawUrl, `http://${req.headers.host || 'localhost'}`);
+
+    // Support both prefixed and stripped paths (OpenClaw may strip the prefix)
+    let subPath: string;
+    if (url.pathname.startsWith(ROUTE_PREFIX)) {
+      subPath = url.pathname.slice(ROUTE_PREFIX.length);
+    } else {
+      subPath = url.pathname;
+    }
 
-    // API proxy: /nats-dashboard/api/* → sidecar
+    // Debug endpoint
+    if (subPath === '/api/_debug') {
+      res.statusCode = 200;
+      res.setHeader('content-type', 'application/json');
+      res.end(JSON.stringify({
+        rawUrl,
+        pathname: url.pathname,
+        subPath,
+        sidecarUrl: SIDECAR_URL,
+        distDir: DIST_DIR,
+        distExists: existsSync(path.join(DIST_DIR, 'index.html')),
+      }, null, 2));
+      return true;
+    }
+
+    // API proxy: /api/* → sidecar
     if (subPath.startsWith('/api/')) {
       return proxyToSidecar(subPath, url.search, req, res);
     }
@@ -54,6 +75,7 @@ async function proxyToSidecar(
   res: ServerResponse,
 ): Promise<boolean> {
   try {
+    const targetUrl = `${SIDECAR_URL}${subPath}${search}`;
     const headers: Record<string, string> = {
       'Authorization': `Bearer ${API_KEY}`,
     };
@@ -66,19 +88,17 @@ async function proxyToSidecar(
       body = await readBody(req);
     }
 
-    // Use node:http directly — global fetch() may be intercepted by gateway SSRF guards
-    const upstream = await httpRequest({
-      hostname: sidecarParsed.hostname,
-      port: Number(sidecarParsed.port),
-      path: `${subPath}${search}`,
+    const upstream = await fetch(targetUrl, {
       method: req.method || 'GET',
       headers,
-      timeout: 10_000,
-    }, body);
+      body,
+      signal: AbortSignal.timeout(10_000),
+    });
 
-    res.statusCode = upstream.statusCode;
-    res.setHeader('content-type', upstream.headers['content-type'] || 'application/json');
-    res.end(upstream.body);
+    res.statusCode = upstream.status;
+    res.setHeader('content-type', upstream.headers.get('content-type') || 'application/json');
+    const responseBody = await upstream.text();
+    res.end(responseBody);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.error(`[nats-dashboard] Sidecar proxy error: ${message} (url=${SIDECAR_URL}${subPath})`);
@@ -91,36 +111,6 @@ async function proxyToSidecar(
 
 const MAX_BODY_BYTES = 1_048_576; // 1MB
 
-interface HttpResponse {
-  statusCode: number;
-  headers: Record<string, string | string[] | undefined>;
-  body: string;
-}
-
-function httpRequest(
-  opts: http.RequestOptions,
-  body?: string,
-): Promise<HttpResponse> {
-  return new Promise((resolve, reject) => {
-    const req = http.request(opts, (res) => {
-      const chunks: Buffer[] = [];
-      res.on('data', (chunk: Buffer) => chunks.push(chunk));
-      res.on('end', () => {
-        resolve({
-          statusCode: res.statusCode || 500,
-          headers: res.headers,
-          body: Buffer.concat(chunks).toString(),
-        });
-      });
-      res.on('error', reject);
-    });
-    req.on('error', reject);
-    req.on('timeout', () => { req.destroy(); reject(new Error('Request timeout')); });
-    if (body) req.write(body);
-    req.end();
-  });
-}
-
 function readBody(req: IncomingMessage): Promise<string> {
   return new Promise((resolve, reject) => {
     const chunks: Buffer[] = [];

package/sidecar/src/config.ts

@@ -28,6 +28,10 @@ export const envSchema = {
     ttlSeconds: Env.number({ default: 60, env: 'NATS_DEDUP_TTL_SECONDS' }),
     cleanupIntervalMs: Env.number({ default: 300000, env: 'NATS_DEDUP_CLEANUP_INTERVAL_MS' }),
   },
+  pending: {
+    flushIntervalMs: Env.number({ default: 30000, env: 'NATS_PENDING_FLUSH_INTERVAL_MS' }),
+    flushBatchSize: Env.number({ default: 10, env: 'NATS_PENDING_FLUSH_BATCH_SIZE' }),
+  },
   auth: {
     pluginApiKey: Env.string({ default: 'dev-nats-plugin-key', env: 'NATS_PLUGIN_API_KEY' }),
   },

package/sidecar/src/pending/pending-flush.service.ts

@@ -0,0 +1,70 @@
+import { Service, BaseService, type OnModuleInit, type OnModuleDestroy } from '@onebun/core';
+import { PendingService } from './pending.service';
+import { GatewayClientService, GatewayRpcError } from '../gateway/gateway-client.service';
+import { MetricsService } from '../metrics/metrics.service';
+import { LogService } from '../logs/log.service';
+
+@Service()
+export class PendingFlushService extends BaseService implements OnModuleInit, OnModuleDestroy {
+  private flushTimer?: ReturnType<typeof setInterval>;
+
+  constructor(
+    private pendingService: PendingService,
+    private gatewayClient: GatewayClientService,
+    private metrics: MetricsService,
+    private logService: LogService,
+  ) {
+    super();
+  }
+
+  async onModuleInit(): Promise<void> {
+    const intervalMs = this.config.get('pending.flushIntervalMs');
+    this.flush().catch((e) => {
+      this.logger.warn('Initial pending flush failed', { error: String(e) });
+    });
+    this.flushTimer = setInterval(() => {
+      this.flush().catch((e) => {
+        this.logger.warn('Pending flush failed', { error: String(e) });
+      });
+    }, intervalMs);
+  }
+
+  async onModuleDestroy(): Promise<void> {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = undefined;
+    }
+  }
+
+  async flush(): Promise<void> {
+    if (!this.gatewayClient.isAlive()) {
+      return;
+    }
+
+    const batchSize = this.config.get('pending.flushBatchSize');
+    const pending = await this.pendingService.fetchPending('default', batchSize);
+    if (pending.length === 0) {
+      return;
+    }
+
+    this.logger.info(`Flushing ${pending.length} pending event(s)`);
+
+    for (const event of pending) {
+      try {
+        const message = `[NATS:${event.subject}] ${JSON.stringify(event.payload)}`;
+        await this.gatewayClient.inject({ message, eventId: event.id });
+        await this.pendingService.markDelivered([event.id]);
+        this.metrics.recordConsume(event.subject);
+        await this.logService.logDelivery('pending-flush', event.subject, JSON.stringify({ eventId: event.id }));
+      } catch (err) {
+        await this.logService.logError('route', 'pending-flush', event.subject, err);
+        if (err instanceof GatewayRpcError) {
+          this.logger.error(`Pending flush: gateway rejected event ${event.id}: ${err.errorCode}`);
+          continue;
+        }
+        this.logger.error(`Pending flush: network error on event ${event.id}, stopping batch`, err);
+        break;
+      }
+    }
+  }
+}

package/sidecar/src/pending/pending.module.ts

@@ -2,10 +2,14 @@ import { Module } from '@onebun/core';
 import { PendingController } from './pending.controller';
 import { PendingService } from './pending.service';
 import { PendingRepository } from './pending.repository';
+import { PendingFlushService } from './pending-flush.service';
+import { MetricsModule } from '../metrics/metrics.module';
+import { LogModule } from '../logs/log.module';
 
 @Module({
+  imports: [MetricsModule, LogModule],
   controllers: [PendingController],
-  providers: [PendingService, PendingRepository],
+  providers: [PendingService, PendingRepository, PendingFlushService],
   exports: [PendingService],
 })
 export class PendingModule {}

package/sidecar/src/pending/pending.repository.ts

@@ -28,12 +28,16 @@ export class PendingRepository extends BaseService {
       .onConflictDoNothing();
   }
 
-  async fetchPending(sessionKey: string): Promise<DbPendingEvent[]> {
-    return this.db
+  async fetchPending(sessionKey: string, limit?: number): Promise<DbPendingEvent[]> {
+    const query = this.db
       .select()
       .from(pendingEvents)
       .where(and(eq(pendingEvents.sessionKey, sessionKey), isNull(pendingEvents.deliveredAt)))
       .orderBy(desc(pendingEvents.priority));
+    if (limit !== undefined) {
+      return query.limit(limit);
+    }
+    return query;
   }
 
   async markDelivered(ids: string[]): Promise<void> {

package/sidecar/src/pending/pending.service.ts

@@ -19,8 +19,8 @@ export class PendingService extends BaseService {
     });
   }
 
-  async fetchPending(sessionKey: string): Promise<DbPendingEvent[]> {
-    return this.repo.fetchPending(sessionKey);
+  async fetchPending(sessionKey: string, limit?: number): Promise<DbPendingEvent[]> {
+    return this.repo.fetchPending(sessionKey, limit);
   }
 
   async markDelivered(ids: string[]): Promise<void> {

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

@@ -124,7 +124,7 @@ export class SchedulerController extends BaseController {
 
   // ── Queue Handlers ────────────────────────────────────────────────
 
-  @Subscribe('scheduler.fire.*', { group: 'scheduler-handler' })
+  @Subscribe('scheduler.fire.*', { group: 'scheduler-cron-handler' })
   async handleFire(message: Message<unknown>): Promise<void> {
     const jobName = message.pattern?.split('.').pop();
     if (jobName) {
@@ -132,7 +132,7 @@ export class SchedulerController extends BaseController {
     }
   }
 
-  @Subscribe('scheduler.timer.*', { group: 'scheduler-handler' })
+  @Subscribe('scheduler.timer.*', { group: 'scheduler-timer-handler' })
   async handleTimerFire(message: Message<unknown>): Promise<void> {
     const timerName = message.pattern?.split('.').pop();
     if (timerName) {