@omnixal/openclaw-nats-plugin 0.1.9 → 0.1.11

package/cli/bun-setup.ts

@@ -58,11 +58,13 @@ export async function bunSetup(): Promise<void> {
   writeEnvVariables(envVars);
 
   // Write .env into sidecar dir so loadDotEnv picks it up
+  // Explicit localhost values override any container-level env (e.g. OPENCLAW_WS_URL=ws://openclaw:...)
   const sidecarEnv = [
     `PORT=3104`,
     `DB_PATH=${join(DATA_DIR, 'nats-sidecar.db')}`,
     `NATS_SERVERS=nats://127.0.0.1:4222`,
     `NATS_PLUGIN_API_KEY=${apiKey}`,
+    `OPENCLAW_WS_URL=ws://127.0.0.1:18789`,
   ].join('\n');
   writeFileSync(join(SIDECAR_DIR, '.env'), sidecarEnv, 'utf-8');
 

package/package.json

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

package/sidecar/src/consumer/{consumer.service.ts → consumer.controller.ts}

@@ -1,17 +1,12 @@
-import { Service, BaseService, type OnModuleInit, type OnModuleDestroy } from '@onebun/core';
-import type { Message, Subscription } from '@onebun/core';
-import { NatsAdapterService } from '../nats-streams/nats-adapter.service';
+import { Controller, BaseController, Subscribe, OnQueueReady, type Message } from '@onebun/core';
 import { PipelineService } from '../pre-handlers/pipeline.service';
 import { GatewayClientService } from '../gateway/gateway-client.service';
 import { PendingService } from '../pending/pending.service';
 import type { NatsEventEnvelope } from '../publisher/envelope';
 
-@Service()
-export class ConsumerService extends BaseService implements OnModuleInit, OnModuleDestroy {
-  private subscription: Subscription | null = null;
-
+@Controller('/consumer')
+export class ConsumerController extends BaseController {
   constructor(
-    private natsAdapter: NatsAdapterService,
     private pipeline: PipelineService,
     private gatewayClient: GatewayClientService,
     private pendingService: PendingService,
@@ -19,26 +14,17 @@ export class ConsumerService extends BaseService implements OnModuleInit, OnModu
     super();
   }
 
-  async onModuleInit(): Promise<void> {
-    if (!this.natsAdapter.isConnected()) {
-      this.logger.warn('NATS not connected, consumer will not start');
-      return;
-    }
-
-    try {
-      const consumerName = this.config.get('consumer.name');
-      this.subscription = await this.natsAdapter.subscribe(
-        'agent.inbound.>',
-        (message: Message<unknown>) => this.handleInbound(message),
-        { ackMode: 'manual', group: consumerName },
-      );
-      this.logger.info(`Consuming from agent_inbound as ${consumerName}`);
-    } catch (err: any) {
-      this.logger.warn(`Failed to start consumer: ${err?.message}`);
-    }
+  @OnQueueReady()
+  onReady() {
+    const consumerName = this.config.get('consumer.name');
+    this.logger.info(`Queue connected, consuming as ${consumerName}`);
   }
 
-  private async handleInbound(message: Message<unknown>): Promise<void> {
+  @Subscribe('agent.inbound.>', {
+    ackMode: 'manual',
+    group: 'openclaw-main',
+  })
+  async handleInbound(message: Message<unknown>): Promise<void> {
     try {
       const envelope = this.extractEnvelope(message);
 
@@ -103,11 +89,4 @@ export class ConsumerService extends BaseService implements OnModuleInit, OnModu
   private formatMessage(envelope: NatsEventEnvelope): string {
     return `[NATS:${envelope.subject}] ${JSON.stringify(envelope.payload)}`;
   }
-
-  async onModuleDestroy(): Promise<void> {
-    if (this.subscription) {
-      await this.subscription.unsubscribe();
-      this.subscription = null;
-    }
-  }
 }

package/sidecar/src/consumer/consumer.module.ts

@@ -1,12 +1,11 @@
 import { Module } from '@onebun/core';
-import { ConsumerService } from './consumer.service';
-import { NatsStreamsModule } from '../nats-streams/nats-streams.module';
+import { ConsumerController } from './consumer.controller';
 import { PreHandlersModule } from '../pre-handlers/pre-handlers.module';
 import { GatewayClientModule } from '../gateway/gateway-client.module';
 import { PendingModule } from '../pending/pending.module';
 
 @Module({
-  imports: [NatsStreamsModule, PreHandlersModule, GatewayClientModule, PendingModule],
-  providers: [ConsumerService],
+  imports: [PreHandlersModule, GatewayClientModule, PendingModule],
+  controllers: [ConsumerController],
 })
 export class ConsumerModule {}

package/sidecar/src/health/health.module.ts

@@ -1,12 +1,11 @@
 import { Module } from '@onebun/core';
 import { HealthController } from './health.controller';
 import { HealthService } from './health.service';
-import { NatsStreamsModule } from '../nats-streams/nats-streams.module';
 import { GatewayClientModule } from '../gateway/gateway-client.module';
 import { PendingModule } from '../pending/pending.module';
 
 @Module({
-  imports: [NatsStreamsModule, GatewayClientModule, PendingModule],
+  imports: [GatewayClientModule, PendingModule],
   controllers: [HealthController],
   providers: [HealthService],
 })

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

@@ -1,5 +1,4 @@
-import { Service, BaseService } from '@onebun/core';
-import { NatsAdapterService } from '../nats-streams/nats-adapter.service';
+import { Service, BaseService, QueueService } from '@onebun/core';
 import { GatewayClientService } from '../gateway/gateway-client.service';
 import { PendingService } from '../pending/pending.service';
 
@@ -20,19 +19,27 @@ export class HealthService extends BaseService {
   private readonly startedAt = Date.now();
 
   constructor(
-    private nats: NatsAdapterService,
+    private queueService: QueueService,
     private gateway: GatewayClientService,
     private pending: PendingService,
   ) {
     super();
   }
 
+  private isQueueConnected(): boolean {
+    try {
+      return this.queueService.getAdapter().isConnected();
+    } catch {
+      return false;
+    }
+  }
+
   async getStatus(): Promise<HealthStatus> {
     const pendingCount = await this.pending.countPending();
 
     return {
       nats: {
-        connected: this.nats.isConnected(),
+        connected: this.isQueueConnected(),
         url: this.config.get('nats.servers'),
       },
       gateway: {

package/sidecar/src/index.ts

@@ -1,13 +1,36 @@
 import { OneBunApplication } from '@onebun/core';
+import { JetStreamQueueAdapter, type JetStreamAdapterOptions } from '@onebun/nats';
 import { AppModule } from './app.module';
 import { envSchema } from './config';
 
+const natsServers = Bun.env.NATS_SERVERS ?? 'nats://localhost:4222';
+const ackWaitMs = Number(Bun.env.NATS_ACK_WAIT_MS ?? 30000);
+const maxDeliver = Number(Bun.env.NATS_MAX_DELIVER ?? 3);
+
 const app = new OneBunApplication(AppModule, {
   development: Bun.env.NODE_ENV !== 'production',
   envSchema,
   envOptions: {
     loadDotEnv: true,
   },
+  queue: {
+    adapter: JetStreamQueueAdapter as any,
+    options: {
+      servers: natsServers,
+      stream: 'agent_inbound',
+      createStream: true,
+      streamConfig: {
+        subjects: ['agent.inbound.>'],
+        retention: 'workqueue',
+        storage: 'file',
+        replicas: 1,
+      },
+      consumerConfig: {
+        ackWait: ackWaitMs * 1_000_000, // ms → ns
+        maxDeliver,
+      },
+    } as JetStreamAdapterOptions,
+  },
 });
 
 app.start()

package/sidecar/src/nats-streams/nats-streams.module.ts

@@ -1,8 +1,7 @@
 import { Module } from '@onebun/core';
-import { NatsAdapterService } from './nats-adapter.service';
+import { StreamSetupController } from './stream-setup.controller';
 
 @Module({
-  providers: [NatsAdapterService],
-  exports: [NatsAdapterService],
+  controllers: [StreamSetupController],
 })
 export class NatsStreamsModule {}

package/sidecar/src/nats-streams/stream-setup.controller.ts

@@ -0,0 +1,64 @@
+import { Controller, BaseController, OnQueueReady, QueueService } from '@onebun/core';
+
+/**
+ * Ensures additional JetStream streams (agent_events, agent_dlq) exist
+ * once the queue adapter is connected.
+ */
+@Controller('/nats-setup')
+export class StreamSetupController extends BaseController {
+  constructor(private queueService: QueueService) {
+    super();
+  }
+
+  @OnQueueReady()
+  async onReady(): Promise<void> {
+    await this.ensureExtraStreams();
+  }
+
+  private async ensureExtraStreams(): Promise<void> {
+    try {
+      const adapter = this.queueService.getAdapter();
+      const nc = (adapter as any)?.client?.getConnection?.();
+      if (!nc) {
+        this.logger.warn('Cannot access NATS connection for stream creation');
+        return;
+      }
+
+      const jsModule = await import('@nats-io/jetstream');
+      const jsm = await jsModule.jetstreamManager(nc);
+
+      const SEVEN_DAYS_NS = 7 * 24 * 60 * 60 * 1e9;
+
+      await this.ensureStream(jsm, {
+        name: 'agent_events',
+        subjects: ['agent.events.>'],
+        retention: 'limits',
+        max_age: SEVEN_DAYS_NS,
+        storage: 'file',
+        num_replicas: 1,
+      });
+
+      await this.ensureStream(jsm, {
+        name: 'agent_dlq',
+        subjects: ['agent.dlq.>'],
+        retention: 'limits',
+        max_age: SEVEN_DAYS_NS,
+        storage: 'file',
+        num_replicas: 1,
+      });
+
+      this.logger.info('Additional JetStream streams ensured (agent_events, agent_dlq)');
+    } catch (err: any) {
+      this.logger.warn(`Failed to ensure extra streams: ${err?.message}`);
+    }
+  }
+
+  private async ensureStream(jsm: any, config: Record<string, any>): Promise<void> {
+    try {
+      await jsm.streams.info(config.name);
+      await jsm.streams.update(config.name, config);
+    } catch {
+      await jsm.streams.add(config);
+    }
+  }
+}

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

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

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

@@ -1,20 +1,15 @@
-import { Service, BaseService } from '@onebun/core';
-import { NatsAdapterService } from '../nats-streams/nats-adapter.service';
+import { Service, BaseService, QueueService } from '@onebun/core';
 import { createEnvelope, type EnvelopeMeta } from './envelope';
 
 @Service()
 export class PublisherService extends BaseService {
-  constructor(private natsAdapter: NatsAdapterService) {
+  constructor(private queueService: QueueService) {
     super();
   }
 
   async publish(subject: string, payload: unknown, meta?: EnvelopeMeta): Promise<void> {
-    if (!this.natsAdapter.isConnected()) {
-      this.logger.warn(`NATS not connected, dropping publish to ${subject}`);
-      return;
-    }
     const envelope = createEnvelope(subject, payload, meta);
-    await this.natsAdapter.publish(subject, envelope);
+    await this.queueService.publish(subject, envelope);
     this.logger.debug(`Published to ${subject}`, { id: envelope.id });
   }
 }

package/sidecar/src/nats-streams/nats-adapter.service.ts

@@ -1,133 +0,0 @@
-import { Service, BaseService, type OnModuleInit, type OnModuleDestroy } from '@onebun/core';
-import type { Subscription, MessageHandler, SubscribeOptions, PublishOptions } from '@onebun/core';
-import { JetStreamQueueAdapter, type JetStreamAdapterOptions } from '@onebun/nats';
-
-/**
- * Manages the JetStreamQueueAdapter lifecycle with graceful degradation.
- *
- * When NATS is unavailable, the service runs in degraded mode:
- * publish and subscribe operations are silently dropped with warnings.
- *
- * Also ensures additional streams (agent_events, agent_dlq) exist.
- */
-@Service()
-export class NatsAdapterService extends BaseService implements OnModuleInit, OnModuleDestroy {
-  private adapter: JetStreamQueueAdapter | null = null;
-  private _connected = false;
-
-  async onModuleInit(): Promise<void> {
-    const servers = this.config.get('nats.servers');
-    const reconnectTimeWait = this.config.get('nats.reconnectDelayMs');
-    const maxReconnectAttempts = this.config.get('nats.maxReconnectAttempts');
-    const ackWaitMs = this.config.get('consumer.ackWaitMs');
-    const maxDeliver = this.config.get('consumer.maxDeliver');
-
-    const options: JetStreamAdapterOptions = {
-      servers,
-      maxReconnectAttempts,
-      reconnectTimeWait,
-      stream: 'agent_inbound',
-      createStream: true,
-      streamConfig: {
-        subjects: ['agent.inbound.>'],
-        retention: 'workqueue',
-        storage: 'file',
-        replicas: 1,
-      },
-      consumerConfig: {
-        ackWait: ackWaitMs * 1_000_000, // ms → ns
-        maxDeliver,
-      },
-    };
-
-    this.adapter = new JetStreamQueueAdapter(options);
-
-    try {
-      await this.adapter.connect();
-      this._connected = true;
-      await this.ensureExtraStreams();
-      this.logger.info('NATS JetStream connected');
-    } catch (err: any) {
-      this.logger.warn(`NATS connection failed, running in degraded mode: ${err?.message}`);
-      this.adapter = null;
-      this._connected = false;
-    }
-  }
-
-  isConnected(): boolean {
-    return this._connected && this.adapter !== null;
-  }
-
-  async publish<T>(pattern: string, data: T, options?: PublishOptions): Promise<string | null> {
-    if (!this.adapter || !this.isConnected()) {
-      this.logger.warn(`NATS not connected, dropping publish to ${pattern}`);
-      return null;
-    }
-    return await this.adapter.publish(pattern, data, options);
-  }
-
-  async subscribe<T>(
-    pattern: string,
-    handler: MessageHandler<T>,
-    options?: SubscribeOptions,
-  ): Promise<Subscription | null> {
-    if (!this.adapter || !this.isConnected()) {
-      this.logger.warn(`NATS not connected, cannot subscribe to ${pattern}`);
-      return null;
-    }
-    return await this.adapter.subscribe(pattern, handler, options);
-  }
-
-  async onModuleDestroy(): Promise<void> {
-    if (this.adapter) {
-      await this.adapter.disconnect();
-      this.logger.info('NATS JetStream disconnected');
-    }
-  }
-
-  private async ensureExtraStreams(): Promise<void> {
-    try {
-      const nc = (this.adapter as any)?.client?.getConnection?.();
-      if (!nc) {
-        this.logger.warn('Cannot access NATS connection for stream creation');
-        return;
-      }
-
-      const jsModule = await import('@nats-io/jetstream');
-      const jsm = await jsModule.jetstreamManager(nc);
-
-      const SEVEN_DAYS_NS = 7 * 24 * 60 * 60 * 1e9;
-
-      await this.ensureStream(jsm, {
-        name: 'agent_events',
-        subjects: ['agent.events.>'],
-        retention: 'limits',
-        max_age: SEVEN_DAYS_NS,
-        storage: 'file',
-        num_replicas: 1,
-      });
-
-      await this.ensureStream(jsm, {
-        name: 'agent_dlq',
-        subjects: ['agent.dlq.>'],
-        retention: 'limits',
-        max_age: SEVEN_DAYS_NS,
-        storage: 'file',
-        num_replicas: 1,
-      });
-
-      this.logger.info('Additional JetStream streams ensured (agent_events, agent_dlq)');
-    } catch (err: any) {
-      this.logger.warn(`Failed to ensure extra streams: ${err?.message}`);
-    }
-  }
-
-  private async ensureStream(jsm: any, config: Record<string, any>): Promise<void> {
-    try {
-      await jsm.streams.info(config.name);
-      await jsm.streams.update(config.name, config);
-    } catch {
-      await jsm.streams.add(config);
-    }
-  }
-}