@johpaz/hive-agents 0.0.35 → 0.0.36

package/packages/core/src/scheduler/types.ts

@@ -0,0 +1,164 @@
+/**
+ * Hive Scheduler - Type Definitions
+ * 
+ * Type interfaces for the Croner-based scheduling system.
+ * All names use "CronJob" terminology (formerly ScheduledTask).
+ */
+
+import type { Database } from "bun:sqlite";
+import type { Cron } from "croner";
+
+/**
+ * Task type: recurring uses cron expression, one_shot uses fire_at
+ */
+export type TaskType = "recurring" | "one_shot";
+
+/**
+ * Task status
+ */
+export type TaskStatus = "active" | "paused" | "completed" | "failed" | "cancelled";
+
+/**
+ * Task run status
+ */
+export type TaskRunStatus = "running" | "success" | "failed" | "timeout";
+
+/**
+ * CronJob as stored in SQLite (cron_jobs table)
+ */
+export interface CronJob {
+  id: string;
+  name: string;
+  task: string;
+  task_type: TaskType;
+  cron_expression: string | null;
+  fire_at: string | null;
+  timezone: string;
+  start_at: string | null;
+  stop_at: string | null;
+  dom_and_dow: number;
+  max_runs: number | null;
+  protect: number;
+  interval_sec: number | null;
+  agent_id: string | null;
+  channel: string;
+  payload: string;
+  tool_name: string | null;
+  status: TaskStatus;
+  run_count: number;
+  error_count: number;
+  last_error: string | null;
+  created_at: string;
+  updated_at: string;
+  last_run_at: string | null;
+  next_run_at: string | null;
+  completed_at: string | null;
+}
+
+/**
+ * Task run history record
+ */
+export interface TaskRun {
+  id: string;
+  task_id: string;
+  status: TaskRunStatus;
+  started_at: string;
+  finished_at: string | null;
+  duration_ms: number | null;
+  error_message: string | null;
+  payload_snapshot: string | null;
+  agent_response: string | null;
+}
+
+/**
+ * Input for creating a new cron job
+ */
+export interface CreateCronJobInput {
+  name: string;
+  task: string;
+  task_type: TaskType;
+  cron_expression?: string;
+  fire_at?: string;
+  timezone: string;
+  start_at?: string;
+  stop_at?: string;
+  dom_and_dow?: boolean;
+  agent_id?: string | null;
+  channel?: string;
+  payload?: Record<string, unknown>;
+  tool_name?: string | null;
+  max_runs?: number | null;
+  protect?: boolean;
+  interval_sec?: number | null;
+}
+
+/**
+ * Input for updating an existing cron job
+ */
+export interface UpdateCronJobInput {
+  name?: string;
+  task?: string;
+  task_type?: TaskType;
+  cron_expression?: string | null;
+  fire_at?: string | null;
+  timezone?: string;
+  start_at?: string | null;
+  stop_at?: string | null;
+  dom_and_dow?: boolean;
+  agent_id?: string | null;
+  channel?: string;
+  payload?: Record<string, unknown>;
+  tool_name?: string | null;
+  max_runs?: number | null;
+  protect?: boolean;
+  interval_sec?: number | null;
+  status?: TaskStatus;
+}
+
+/**
+ * Scheduler status for a cron job
+ */
+export interface CronJobStatus {
+  id: string;
+  name: string;
+  nextRun: Date | null;
+  isBusy: boolean;
+  status: TaskStatus;
+}
+
+/**
+ * Handler function type for executing cron jobs
+ */
+export type CronJobExecutionHandler = (job: CronJob) => Promise<CronJobExecutionResult>;
+
+/**
+ * Result of cron job execution
+ */
+export interface CronJobExecutionResult {
+  success: boolean;
+  response?: string;
+  error?: string;
+}
+
+/**
+ * Internal job wrapper holding Croner instance and metadata
+ */
+export interface CronJobEntry {
+  job: CronJob;
+  cron: Cron;
+}
+
+/**
+ * Options for Croner job creation
+ */
+export interface CronerOptions {
+  timezone: string;
+  protect: boolean;
+  catch: boolean | ((error: Error) => void);
+  name: string;
+  maxRuns?: number;
+  interval?: number;
+  startAt?: string;
+  stopAt?: string;
+  domAndDow?: boolean;
+}

package/packages/core/src/security/google-chat.ts

@@ -0,0 +1,269 @@
+import http, { type IncomingMessage, type ServerResponse, type Server } from "http";
+import { BaseChannel, type ChannelConfig, type IncomingMessage as HiveIncomingMessage, type OutboundMessage } from "../channels/base.ts";
+import { logger } from "../utils/logger.ts";
+import { pairingService } from "./pairing.ts";
+
+export interface GoogleChatConfig extends ChannelConfig {
+  projectId?: string;
+  serviceAccountKey?: string;
+  webhookPort?: number;
+  webhookPath?: string;
+}
+
+interface GoogleChatEvent {
+  type: string;
+  eventTime: string;
+  space: {
+    name: string;
+    displayName: string;
+    type: "ROOM" | "DM";
+  };
+  message?: {
+    name: string;
+    sender: {
+      name: string;
+      displayName: string;
+    };
+    createTime: string;
+    text: string;
+    thread?: {
+      name: string;
+    };
+  };
+  user?: {
+    name: string;
+    displayName: string;
+  };
+}
+
+export class GoogleChatChannel extends BaseChannel {
+  name = "google-chat";
+  accountId: string;
+  config: GoogleChatConfig;
+
+  private server?: Server;
+  private log = logger.child("google-chat");
+  private spaceCache: Map<string, { space: string; thread?: string }> = new Map();
+
+  constructor(accountId: string, config: GoogleChatConfig) {
+    super();
+    this.accountId = accountId;
+    this.config = {
+      ...config,
+      dmPolicy: config.dmPolicy ?? "pairing",
+      allowFrom: config.allowFrom ?? [],
+      enabled: config.enabled ?? true,
+      webhookPort: config.webhookPort ?? 8080,
+      webhookPath: config.webhookPath ?? "/webhook/google-chat",
+    };
+  }
+
+  async start(): Promise<void> {
+    this.server = http.createServer((req, res) => {
+      if (req.url === this.config.webhookPath && req.method === "POST") {
+        this.handleWebhook(req, res);
+      } else {
+        res.writeHead(404).end();
+      }
+    });
+
+    return new Promise((resolve, reject) => {
+      this.server!.listen(this.config.webhookPort, () => {
+        this.running = true;
+        this.log.info(
+          `Google Chat webhook listening on port ${this.config.webhookPort}${this.config.webhookPath}`
+        );
+        resolve();
+      });
+
+      this.server!.on("error", (error: Error) => {
+        this.log.error(`Server error: ${error.message}`);
+        reject(error);
+      });
+    });
+  }
+
+  private async handleWebhook(req: IncomingMessage, res: ServerResponse): Promise<void> {
+    let body = "";
+    req.on("data", (chunk) => (body += chunk));
+    req.on("end", async () => {
+      try {
+        const event: GoogleChatEvent = JSON.parse(body);
+
+        if (event.type === "ADDED_TO_SPACE") {
+          await this.handleAddedToSpace(event, res);
+          return;
+        }
+
+        if (event.type === "REMOVED_FROM_SPACE") {
+          this.log.info(`Removed from space: ${event.space.name}`);
+          res.writeHead(200).end();
+          return;
+        }
+
+        if (event.type === "MESSAGE" && event.message) {
+          await this.handleChatMessage(event, res);
+          return;
+        }
+
+        res.writeHead(200).end();
+      } catch (error) {
+        this.log.error(`Webhook error: ${(error as Error).message}`);
+        res.writeHead(500).end();
+      }
+    });
+  }
+
+  private async handleAddedToSpace(
+    event: GoogleChatEvent,
+    res: ServerResponse
+  ): Promise<void> {
+    const message =
+      event.space.type === "DM"
+        ? {
+          text: "¡Hola! Soy tu asistente AI. Envía un mensaje para comenzar.",
+        }
+        : {
+          text: "¡Gracias por añadirme al espacio! Mencióname con @bot para interactuar.",
+        };
+
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(message));
+  }
+
+  private async handleChatMessage(event: GoogleChatEvent, res: ServerResponse): Promise<void> {
+    if (!event.message) {
+      res.writeHead(200).end();
+      return;
+    }
+
+    const userId = event.message.sender.name.split("/").pop() ?? "unknown";
+    const spaceName = event.space.name;
+    const isDM = event.space.type === "DM";
+    const kind = isDM ? "direct" : "group";
+    const peerId = isDM ? userId : `${spaceName}:${userId}`;
+
+    if (event.message.text === "/myid") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          text: `🆔 Tu Google Chat ID es: ${userId}\n\nPara emparejar, solicita un código al administrador.`,
+        })
+      );
+      return;
+    }
+
+    if (event.message.text.startsWith("/pair ")) {
+      const code = event.message.text.split(" ")[1]?.trim();
+      const result = pairingService.approve(code ?? "");
+
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          text: result.success
+            ? "✅ ¡Emparejamiento exitoso!"
+            : `❌ ${result.error}`,
+        })
+      );
+      return;
+    }
+
+    if (this.config.dmPolicy === "pairing" && !pairingService.isAllowed("google-chat", userId)) {
+      this.log.debug(`Message from unpaired user: ${userId}`);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          text:
+            "⛔ No estás emparejado.\n\n" +
+            "Tu ID: " +
+            userId +
+            "\n\n" +
+            "Solicita un código de emparejamiento al administrador.",
+        })
+      );
+      return;
+    }
+
+    if (!isDM && !this.isUserAllowed(peerId)) {
+      this.log.debug(`Message from unauthorized user: ${peerId}`);
+      res.writeHead(200).end();
+      return;
+    }
+
+    const sessionId = this.formatSessionId(peerId, kind);
+    this.spaceCache.set(sessionId, {
+      space: spaceName,
+      thread: event.message.thread?.name,
+    });
+
+    const incomingMessage: HiveIncomingMessage = {
+      sessionId,
+      channel: "google-chat",
+      accountId: this.accountId,
+      peerId,
+      peerKind: kind,
+      content: event.message.text,
+      metadata: {
+        googleChat: {
+          spaceName,
+          userId,
+          displayName: event.message.sender.displayName,
+          threadName: event.message.thread?.name,
+        },
+      },
+    };
+
+    res.writeHead(200).end();
+
+    await this.handleMessage(incomingMessage);
+  }
+
+  async stop(): Promise<void> {
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server!.close(() => {
+          this.running = false;
+          this.log.info("Google Chat channel stopped");
+          resolve();
+        });
+      });
+    }
+  }
+
+  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 cached = this.spaceCache.get(sessionId);
+
+    if (!cached) {
+      this.log.warn(`No cached space for session: ${sessionId}`);
+      return;
+    }
+
+    if (message.type === "stream" && message.chunk) {
+      this.log.info(`[Google Chat] Stream chunk to ${cached.space}: ${message.chunk.slice(0, 50)}...`);
+      return;
+    }
+
+    this.log.info(`[Google Chat] Would send to ${cached.space}: ${content.slice(0, 100)}...`);
+  }
+
+  async sendMessage(space: string, content: string, thread?: string): Promise<void> {
+    this.log.info(`[Google Chat] Sending to ${space}: ${content.slice(0, 100)}...`);
+    if (thread) {
+      this.log.info(`  Thread: ${thread}`);
+    }
+  }
+}
+
+export function createGoogleChatChannel(
+  accountId: string,
+  config: GoogleChatConfig
+): GoogleChatChannel {
+  return new GoogleChatChannel(accountId, config);
+}

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

@@ -0,0 +1,192 @@
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+
+export * from "./pairing.ts";
+export * from "./rate-limit.ts";
+export * from "./signal.ts";
+export * from "./google-chat.ts";
+
+export interface RateLimitConfig {
+  windowMs: number;
+  maxRequests: number;
+}
+
+export interface RateLimitEntry {
+  count: number;
+  resetAt: number;
+}
+
+export class RateLimiter {
+  private limits: Map<string, RateLimitEntry> = new Map();
+  private config: RateLimitConfig;
+  private log = logger.child("rate-limiter");
+
+  constructor(config: RateLimitConfig) {
+    this.config = config;
+    this.startCleanup();
+  }
+
+  check(key: string): { allowed: boolean; remaining: number; resetAt: number } {
+    const now = Date.now();
+    const entry = this.limits.get(key);
+
+    if (!entry || now > entry.resetAt) {
+      const resetAt = now + this.config.windowMs;
+      this.limits.set(key, { count: 1, resetAt });
+      return { allowed: true, remaining: this.config.maxRequests - 1, resetAt };
+    }
+
+    if (entry.count >= this.config.maxRequests) {
+      this.log.warn(`Rate limit exceeded for ${key}`);
+      return { allowed: false, remaining: 0, resetAt: entry.resetAt };
+    }
+
+    entry.count++;
+    return { 
+      allowed: true, 
+      remaining: this.config.maxRequests - entry.count, 
+      resetAt: entry.resetAt 
+    };
+  }
+
+  reset(key: string): void {
+    this.limits.delete(key);
+  }
+
+  private startCleanup(): void {
+    setInterval(() => {
+      const now = Date.now();
+      for (const [key, entry] of this.limits) {
+        if (now > entry.resetAt) {
+          this.limits.delete(key);
+        }
+      }
+    }, this.config.windowMs);
+  }
+}
+
+export class InputValidator {
+  private maxMessageLength: number;
+  private maxCommandArgs: number;
+  private log = logger.child("validator");
+
+  constructor(options: { maxMessageLength?: number; maxCommandArgs?: number } = {}) {
+    this.maxMessageLength = options.maxMessageLength ?? 100000;
+    this.maxCommandArgs = options.maxCommandArgs ?? 50;
+  }
+
+  validateMessage(content: string): { valid: boolean; error?: string } {
+    if (typeof content !== "string") {
+      return { valid: false, error: "Message must be a string" };
+    }
+
+    if (content.length === 0) {
+      return { valid: false, error: "Message cannot be empty" };
+    }
+
+    if (content.length > this.maxMessageLength) {
+      this.log.warn(`Message too long: ${content.length} > ${this.maxMessageLength}`);
+      return { 
+        valid: false, 
+        error: `Message too long (max ${this.maxMessageLength} characters)` 
+      };
+    }
+
+    return { valid: true };
+  }
+
+  validateCommand(name: string, args: string[]): { valid: boolean; error?: string } {
+    if (!name || typeof name !== "string") {
+      return { valid: false, error: "Command name is required" };
+    }
+
+    if (!/^[a-z0-9_-]+$/.test(name)) {
+      return { valid: false, error: "Invalid command name format" };
+    }
+
+    if (args.length > this.maxCommandArgs) {
+      return { valid: false, error: `Too many arguments (max ${this.maxCommandArgs})` };
+    }
+
+    return { valid: true };
+  }
+
+  validateSessionId(sessionId: string): { valid: boolean; error?: string } {
+    if (!sessionId || typeof sessionId !== "string") {
+      return { valid: false, error: "Session ID is required" };
+    }
+
+    const pattern = /^agent:[a-z0-9_-]+:[a-z0-9_-]+:(main|dm|group)(?::[a-z0-9_-]+)?$/;
+    if (!pattern.test(sessionId)) {
+      return { valid: false, error: "Invalid session ID format" };
+    }
+
+    return { valid: true };
+  }
+
+  sanitizeInput(input: string): string {
+    return input
+      .replace(/\x00/g, "")
+      .replace(/[\x1F\x7F]/g, "")
+      .trim();
+  }
+}
+
+export class AuthManager {
+  private config: Config;
+  private allowedUsers: Set<string>;
+  private log = logger.child("auth");
+
+  constructor(config: Config) {
+    this.config = config;
+    this.allowedUsers = new Set(config.security?.allowedUsers ?? []);
+  }
+
+  isAllowed(peerId: string, channel: string): boolean {
+    if (this.allowedUsers.size === 0) {
+      return true;
+    }
+
+    const channelConfig = this.config.channels?.[channel as keyof typeof this.config.channels];
+    if (channelConfig && typeof channelConfig === "object" && "allowFrom" in channelConfig) {
+      const allowFrom = (channelConfig as { allowFrom?: string[] }).allowFrom;
+      if (allowFrom && allowFrom.length > 0) {
+        return allowFrom.includes(peerId);
+      }
+    }
+
+    return this.allowedUsers.has(peerId);
+  }
+
+  addAllowedUser(peerId: string): void {
+    this.allowedUsers.add(peerId);
+    this.log.info(`Added allowed user: ${peerId}`);
+  }
+
+  removeAllowedUser(peerId: string): boolean {
+    const removed = this.allowedUsers.delete(peerId);
+    if (removed) {
+      this.log.info(`Removed allowed user: ${peerId}`);
+    }
+    return removed;
+  }
+
+  listAllowedUsers(): string[] {
+    return Array.from(this.allowedUsers);
+  }
+}
+
+export function createRateLimiter(config: RateLimitConfig): RateLimiter {
+  return new RateLimiter(config);
+}
+
+export function createInputValidator(options?: {
+  maxMessageLength?: number;
+  maxCommandArgs?: number;
+}): InputValidator {
+  return new InputValidator(options);
+}
+
+export function createAuthManager(config: Config): AuthManager {
+  return new AuthManager(config);
+}