@johpaz/hive 1.7.2 → 1.7.3

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

@@ -1,321 +0,0 @@
-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

@@ -1,312 +0,0 @@
-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();