@johpaz/hive-agents 0.0.35 → 0.0.36

package/packages/core/src/security/signal.ts

@@ -0,0 +1,321 @@
+import { spawn, type ChildProcess } from "child_process";
+import { BaseChannel, type ChannelConfig, type IncomingMessage, type OutboundMessage } from "../channels/base.ts";
+import { logger } from "../utils/logger.ts";
+import { pairingService } from "./pairing.ts";
+
+export interface SignalConfig extends ChannelConfig {
+  phoneNumber: string;
+  dataDir?: string;
+  signalCliPath?: string;
+}
+
+interface SignalMessage {
+  envelope: {
+    source: string;
+    sourceNumber?: string;
+    sourceName?: string;
+    timestamp: number;
+    dataMessage?: {
+      message?: string;
+      expiresInSeconds?: number;
+    };
+    syncMessage?: {
+      sentMessage?: {
+        destination?: string;
+        message?: string;
+      };
+    };
+  };
+}
+
+export class SignalChannel extends BaseChannel {
+  name = "signal";
+  accountId: string;
+  config: SignalConfig;
+
+  private signalCli?: ChildProcess;
+  private log = logger.child("signal");
+  private messageBuffer = "";
+  private chatIdCache: Map<string, string> = new Map();
+
+  constructor(accountId: string, config: SignalConfig) {
+    super();
+    this.accountId = accountId;
+    this.config = {
+      ...config,
+      dmPolicy: config.dmPolicy ?? "pairing",
+      allowFrom: config.allowFrom ?? [],
+      enabled: config.enabled ?? true,
+    };
+  }
+
+  async start(): Promise<void> {
+    if (!this.config.phoneNumber) {
+      throw new Error("Signal phone number not configured");
+    }
+
+    const signalCliPath = this.config.signalCliPath ?? "signal-cli";
+    const dataDir = this.config.dataDir;
+
+    const args = ["daemon", "--system"];
+    if (dataDir) {
+      args.push("--config", dataDir);
+    }
+
+    this.log.info(`Starting signal-cli: ${signalCliPath} ${args.join(" ")}`);
+
+    this.signalCli = spawn(signalCliPath, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    this.signalCli.stdout?.on("data", (data: Buffer) => {
+      this.handleSignalOutput(data.toString());
+    });
+
+    this.signalCli.stderr?.on("data", (data: Buffer) => {
+      this.log.error(`signal-cli stderr: ${data.toString()}`);
+    });
+
+    this.signalCli.on("error", (error: Error) => {
+      this.log.error(`signal-cli error: ${error.message}`);
+    });
+
+    this.signalCli.on("exit", (code, signal) => {
+      this.log.warn(`signal-cli exited with code ${code}, signal ${signal}`);
+      this.running = false;
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+
+    this.running = true;
+    this.log.info(`Signal channel started for ${this.config.phoneNumber}`);
+  }
+
+  private handleSignalOutput(output: string): void {
+    this.messageBuffer += output;
+
+    const lines = this.messageBuffer.split("\n");
+    this.messageBuffer = lines.pop() ?? "";
+
+    for (const line of lines) {
+      if (line.trim()) {
+        this.parseSignalMessage(line);
+      }
+    }
+  }
+
+  private parseSignalMessage(line: string): void {
+    try {
+      const data: SignalMessage = JSON.parse(line);
+
+      if (data.envelope?.dataMessage?.message) {
+        const from = data.envelope.source;
+        const content = data.envelope.dataMessage.message;
+        const timestamp = data.envelope.timestamp;
+
+        this.handleIncomingMessage({
+          from,
+          content,
+          timestamp,
+          name: data.envelope.sourceName,
+        });
+      }
+    } catch {
+      this.log.debug(`Non-JSON output: ${line.slice(0, 100)}`);
+    }
+  }
+
+  private async handleIncomingMessage(msg: {
+    from: string;
+    content: string;
+    timestamp: number;
+    name?: string;
+  }): Promise<void> {
+    const peerId = msg.from;
+    const kind = "direct";
+
+    if (msg.content === "/myid") {
+      await this.sendDirectMessage(
+        peerId,
+        `🆔 Tu Signal ID es: ${peerId}\n\n` +
+          `Para emparejar, usa el comando:\n` +
+          `\`hive pairing generate signal ${peerId}\``
+      );
+      return;
+    }
+
+    if (msg.content === "/pair" || msg.content.startsWith("/pair ")) {
+      const code = msg.content.split(" ")[1]?.trim();
+
+      if (!code) {
+        await this.sendDirectMessage(
+          peerId,
+          "🔐 Envía /pair CODIGO para emparejar.\n" +
+            "Solicita un código de emparejamiento al administrador."
+        );
+        return;
+      }
+
+      const result = pairingService.approve(code);
+      if (result.success) {
+        await this.sendDirectMessage(peerId, "✅ ¡Emparejamiento exitoso! Ya puedes usar el bot.");
+      } else {
+        await this.sendDirectMessage(peerId, `❌ ${result.error}`);
+      }
+      return;
+    }
+
+    if (this.config.dmPolicy === "pairing" && !pairingService.isAllowed("signal", peerId)) {
+      this.log.debug(`Message from unpaired user: ${peerId}`);
+      await this.sendDirectMessage(
+        peerId,
+        "⛔ No estás emparejado.\n\n" +
+          "Tu Signal ID: " + peerId + "\n\n" +
+          "Solicita un código de emparejamiento al administrador y envíalo con:\n" +
+          "/pair CODIGO"
+      );
+      return;
+    }
+
+    if (!this.isUserAllowed(peerId)) {
+      this.log.debug(`Message from unauthorized user: ${peerId}`);
+      return;
+    }
+
+    const sessionId = this.formatSessionId(peerId, kind);
+    this.chatIdCache.set(sessionId, peerId);
+
+    const incomingMessage: IncomingMessage = {
+      sessionId,
+      channel: "signal",
+      accountId: this.accountId,
+      peerId,
+      peerKind: kind,
+      content: msg.content,
+      metadata: {
+        signal: {
+          phoneNumber: peerId,
+          name: msg.name,
+          timestamp: msg.timestamp,
+        },
+      },
+    };
+
+    await this.handleMessage(incomingMessage);
+  }
+
+  async stop(): Promise<void> {
+    if (this.signalCli) {
+      this.signalCli.kill("SIGTERM");
+      this.running = false;
+      this.log.info("Signal channel stopped");
+    }
+  }
+
+  async send(sessionId: string, message: OutboundMessage): Promise<void> {
+    const content = message.content ?? "";
+
+    if (!content || content.trim().length === 0) {
+      this.log.warn("Empty response, skipping send");
+      return;
+    }
+
+    const phoneNumber = this.chatIdCache.get(sessionId) ?? this.extractPhoneFromSession(sessionId);
+
+    if (!phoneNumber) {
+      throw new Error(`Cannot determine phone number for session: ${sessionId}`);
+    }
+
+    await this.sendDirectMessage(phoneNumber, content);
+  }
+
+  private async sendDirectMessage(phoneNumber: string, content: string): Promise<void> {
+    const chunks = this.chunkMessage(content, 2000);
+
+    for (const chunk of chunks) {
+      await this.executeCli([
+        "send",
+        "-a", this.config.phoneNumber,
+        "-m", chunk,
+        phoneNumber,
+      ]);
+
+      if (chunks.length > 1) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+    }
+  }
+
+  private async executeCli(args: string[]): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const signalCliPath = this.config.signalCliPath ?? "signal-cli";
+      const fullArgs = this.config.dataDir
+        ? ["--config", this.config.dataDir, ...args]
+        : args;
+
+      const proc = spawn(signalCliPath, fullArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+
+      let stdout = "";
+      let stderr = "";
+
+      proc.stdout?.on("data", (data: Buffer) => {
+        stdout += data.toString();
+      });
+
+      proc.stderr?.on("data", (data: Buffer) => {
+        stderr += data.toString();
+      });
+
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve(stdout);
+        } else {
+          reject(new Error(`signal-cli failed: ${stderr || stdout}`));
+        }
+      });
+
+      proc.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+
+  private extractPhoneFromSession(sessionId: string): string | undefined {
+    const parts = sessionId.split(":");
+    return parts[4];
+  }
+
+  private chunkMessage(content: string, maxLength: number): string[] {
+    const chunks: string[] = [];
+    let remaining = content;
+
+    while (remaining.length > 0) {
+      if (remaining.length <= maxLength) {
+        chunks.push(remaining);
+        break;
+      }
+
+      let splitPoint = remaining.lastIndexOf("\n\n", maxLength);
+      if (splitPoint === -1 || splitPoint < maxLength * 0.5) {
+        splitPoint = remaining.lastIndexOf("\n", maxLength);
+      }
+      if (splitPoint === -1 || splitPoint < maxLength * 0.5) {
+        splitPoint = remaining.lastIndexOf(" ", maxLength);
+      }
+      if (splitPoint === -1 || splitPoint < maxLength * 0.5) {
+        splitPoint = maxLength;
+      }
+
+      chunks.push(remaining.slice(0, splitPoint));
+      remaining = remaining.slice(splitPoint).trim();
+    }
+
+    return chunks;
+  }
+}
+
+export function createSignalChannel(accountId: string, config: SignalConfig): SignalChannel {
+  return new SignalChannel(accountId, config);
+}

package/packages/core/src/state/store.ts

@@ -0,0 +1,312 @@
+import { logger } from "../utils/logger.ts";
+
+export interface SessionState {
+  id: string;
+  agentId: string;
+  channel: string;
+  userId: string;
+  createdAt: number;
+  lastActivityAt: number;
+  messageCount: number;
+  status: "active" | "idle" | "closed";
+}
+
+export interface AgentState {
+  id: string;
+  name: string;
+  status: "ready" | "busy" | "error";
+  currentSessionId?: string;
+  lastError?: string;
+}
+
+export interface ChannelState {
+  name: string;
+  accountId: string;
+  status: "connected" | "disconnected" | "error";
+  lastActivity?: number;
+  error?: string;
+}
+
+export interface MetricsState {
+  totalMessages: number;
+  totalSessions: number;
+  totalToolCalls: number;
+  averageResponseTime: number;
+  errors: number;
+  startedAt: number;
+}
+
+export interface HiveState {
+  sessions: Map<string, SessionState>;
+  agents: Map<string, AgentState>;
+  channels: Map<string, ChannelState>;
+  metrics: MetricsState;
+}
+
+export interface StateSnapshot {
+  id: string;
+  timestamp: number;
+  state: HiveState;
+  reason?: string;
+  action?: string;
+  correlationId?: string;
+}
+
+interface StateStoreOptions {
+  maxSnapshots?: number;
+  enableSnapshots?: boolean;
+}
+
+const defaultMetrics: MetricsState = {
+  totalMessages: 0,
+  totalSessions: 0,
+  totalToolCalls: 0,
+  averageResponseTime: 0,
+  errors: 0,
+  startedAt: Date.now(),
+};
+
+export class StateStore {
+  private state: HiveState;
+  private snapshots: StateSnapshot[] = [];
+  private readonly maxSnapshots: number;
+  private readonly enableSnapshots: boolean;
+  private listeners: Set<(state: Readonly<HiveState>) => void> = new Set();
+  private correlationId?: string;
+
+  constructor(options: StateStoreOptions = {}) {
+    this.maxSnapshots = options.maxSnapshots ?? 100;
+    this.enableSnapshots = options.enableSnapshots ?? true;
+    this.state = this.createInitialState();
+  }
+
+  setCorrelationId(id: string): void {
+    this.correlationId = id;
+  }
+
+  getCorrelationId(): string | undefined {
+    return this.correlationId;
+  }
+
+  clearCorrelationId(): void {
+    this.correlationId = undefined;
+  }
+
+  private createInitialState(): HiveState {
+    return {
+      sessions: new Map(),
+      agents: new Map(),
+      channels: new Map(),
+      metrics: { ...defaultMetrics },
+    };
+  }
+
+  getState(): Readonly<HiveState> {
+    return this.state;
+  }
+
+  update(updater: (draft: HiveState) => void, reason?: string): void {
+    const newState = this.cloneState(this.state);
+    updater(newState);
+
+    if (this.enableSnapshots) {
+      this.saveSnapshot(newState, reason);
+    }
+
+    this.state = newState;
+    this.notifyListeners();
+  }
+
+  private cloneState(state: HiveState): HiveState {
+    return {
+      sessions: new Map(state.sessions),
+      agents: new Map(state.agents),
+      channels: new Map(state.channels),
+      metrics: { ...state.metrics },
+    };
+  }
+
+  private saveSnapshot(state: HiveState, reason?: string): void {
+    const snapshot: StateSnapshot = {
+      id: crypto.randomUUID(),
+      timestamp: Date.now(),
+      state: this.cloneState(state),
+      reason,
+      action: reason,
+      correlationId: this.correlationId,
+    };
+
+    this.snapshots.push(snapshot);
+
+    if (this.snapshots.length > this.maxSnapshots) {
+      this.snapshots.shift();
+    }
+  }
+
+  getSnapshotAt(timestamp: number): StateSnapshot | undefined {
+    return this.snapshots.find((s) => s.timestamp >= timestamp);
+  }
+
+  getSnapshotById(id: string): StateSnapshot | undefined {
+    return this.snapshots.find((s) => s.id === id);
+  }
+
+  getAllSnapshots(): StateSnapshot[] {
+    return [...this.snapshots];
+  }
+
+  getRecentSnapshots(count: number = 10): StateSnapshot[] {
+    return this.snapshots.slice(-count);
+  }
+
+  subscribe(listener: (state: Readonly<HiveState>) => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  private notifyListeners(): void {
+    const state = this.getState();
+    for (const listener of this.listeners) {
+      try {
+        listener(state);
+      } catch (error) {
+        logger.error("[StateStore] Listener error:", { error: (error as Error).message });
+      }
+    }
+  }
+
+  createSession(session: Omit<SessionState, "createdAt" | "lastActivityAt" | "messageCount" | "status">): SessionState {
+    const newSession: SessionState = {
+      ...session,
+      createdAt: Date.now(),
+      lastActivityAt: Date.now(),
+      messageCount: 0,
+      status: "active",
+    };
+
+    this.update((state) => {
+      state.sessions.set(session.id, newSession);
+      state.metrics.totalSessions++;
+    }, `Session created: ${session.id}`);
+
+    return newSession;
+  }
+
+  updateSession(sessionId: string, updates: Partial<SessionState>): void {
+    this.update((state) => {
+      const session = state.sessions.get(sessionId);
+      if (session) {
+        state.sessions.set(sessionId, { ...session, ...updates });
+      }
+    }, `Session updated: ${sessionId}`);
+  }
+
+  closeSession(sessionId: string): void {
+    this.update((state) => {
+      const session = state.sessions.get(sessionId);
+      if (session) {
+        state.sessions.set(sessionId, { ...session, status: "closed" });
+      }
+    }, `Session closed: ${sessionId}`);
+  }
+
+  incrementMessageCount(sessionId: string): void {
+    this.update((state) => {
+      const session = state.sessions.get(sessionId);
+      if (session) {
+        session.messageCount++;
+        session.lastActivityAt = Date.now();
+        state.sessions.set(sessionId, session);
+        state.metrics.totalMessages++;
+      }
+    });
+  }
+
+  registerAgent(agent: Omit<AgentState, "status">): void {
+    this.update((state) => {
+      state.agents.set(agent.id, { ...agent, status: "ready" });
+    }, `Agent registered: ${agent.id}`);
+  }
+
+  updateAgent(agentId: string, updates: Partial<AgentState>): void {
+    this.update((state) => {
+      const agent = state.agents.get(agentId);
+      if (agent) {
+        state.agents.set(agentId, { ...agent, ...updates });
+      }
+    }, `Agent updated: ${agentId}`);
+  }
+
+  updateChannel(channelName: string, accountId: string, updates: Partial<ChannelState>): void {
+    this.update((state) => {
+      const key = `${channelName}:${accountId}`;
+      const channel = state.channels.get(key);
+      if (channel) {
+        state.channels.set(key, { ...channel, ...updates });
+      } else {
+        state.channels.set(key, {
+          name: channelName,
+          accountId,
+          status: "disconnected",
+          ...updates,
+        });
+      }
+    }, `Channel updated: ${channelName}:${accountId}`);
+  }
+
+  recordToolCall(duration: number, success: boolean): void {
+    this.update((state) => {
+      state.metrics.totalToolCalls++;
+      if (!success) {
+        state.metrics.errors++;
+      }
+      const total = state.metrics.totalToolCalls;
+      const prevAvg = state.metrics.averageResponseTime;
+      state.metrics.averageResponseTime = prevAvg + (duration - prevAvg) / total;
+    });
+  }
+
+  reset(): void {
+    this.state = this.createInitialState();
+    this.snapshots = [];
+    this.saveSnapshot(this.state, "Store reset");
+  }
+
+  exportState(): string {
+    const exportable = {
+      sessions: Object.fromEntries(this.state.sessions),
+      agents: Object.fromEntries(this.state.agents),
+      channels: Object.fromEntries(this.state.channels),
+      metrics: this.state.metrics,
+    };
+    return JSON.stringify(exportable, null, 2);
+  }
+
+  export(): string {
+    return this.exportState();
+  }
+
+  getStats(): {
+    sessionsCount: number;
+    activeSessions: number;
+    agentsCount: number;
+    channelsCount: number;
+    snapshotsCount: number;
+    uptime: number;
+  } {
+    const activeSessions = Array.from(this.state.sessions.values()).filter(
+      (s) => s.status === "active"
+    ).length;
+
+    return {
+      sessionsCount: this.state.sessions.size,
+      activeSessions,
+      agentsCount: this.state.agents.size,
+      channelsCount: this.state.channels.size,
+      snapshotsCount: this.snapshots.length,
+      uptime: Date.now() - this.state.metrics.startedAt,
+    };
+  }
+}
+
+export const stateStore = new StateStore();