HAIP 1 archive — Transport Mechanisms

import Redis from 'ioredis';

class HAIPRedisClient {
  private redis: Redis;
  private sessionId: string;
  private seqCounter = 1;

  constructor() {
    this.redis = new Redis();
    this.sessionId = this.generateUUID();
  }

  async connect() {
    // Subscribe to HAIP events
    await this.redis.subscribe('haip:events');

    this.redis.on('message', (channel, message) => {
      const haipMessage = JSON.parse(message);
      this.handleMessage(haipMessage);
    });

    // Send handshake
    await this.sendHandshake();
  }

  private async sendHandshake() {
    const handshake = {
      id: this.generateUUID(),
      session: this.sessionId,
      seq: "1",
      ts: Date.now().toString(),
      channel: "SYSTEM",
      type: "HAI",
      payload: {
        haip_version: "1.1.2",
        accept_major: [1],
        accept_events: ["HAI", "MESSAGE_START", "MESSAGE_PART", "MESSAGE_END"]
      }
    };

    await this.redis.publish('haip:handshake', JSON.stringify(handshake));
  }

  async sendMessage(text: string) {
    const message = {
      id: this.generateUUID(),
      session: this.sessionId,
      seq: this.seqCounter++.toString(),
      ts: Date.now().toString(),
      channel: "USER",
      type: "MESSAGE_START",
      payload: {
        message_id: this.generateUUID(),
        author: "USER",
        text: text
      }
    };

    await this.redis.publish('haip:message', JSON.stringify(message));
  }
}

class HAIPConnectionManager {
  private reconnectAttempts = 0;
  private maxReconnectAttempts = 5;
  private baseDelay = 1000;

  async reconnect() {
    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
      throw new Error("Max reconnection attempts exceeded");
    }

    const delay = this.baseDelay * Math.pow(2, this.reconnectAttempts);
    this.reconnectAttempts++;

    await new Promise((resolve) => setTimeout(resolve, delay));

    try {
      await this.connect();
      this.reconnectAttempts = 0; // Reset on successful connection
    } catch (error) {
      console.error("Reconnection failed:", error);
      await this.reconnect();
    }
  }
}

class HAIPHealthMonitor {
  private pingInterval: NodeJS.Timeout | null = null;
  private lastPong: number = 0;

  startPing() {
    this.pingInterval = setInterval(() => {
      this.sendPing();
    }, 30000); // Ping every 30 seconds
  }

  private sendPing() {
    const ping = {
      id: this.generateUUID(),
      session: this.sessionId,
      seq: this.seqCounter++.toString(),
      ts: Date.now().toString(),
      channel: "SYSTEM",
      type: "PING",
      payload: {
        nonce: this.generateUUID()
      }
    };

    this.ws.send(JSON.stringify(ping));
  }

  handlePong() {
    this.lastPong = Date.now();
  }

  isHealthy(): boolean {
    return Date.now() - this.lastPong < 90000; // 90 seconds
  }
}