@johpaz/hive 1.1.0

package/packages/core/src/canvas/canvas-tools.ts

@@ -0,0 +1,420 @@
+import type { Tool } from "../agent/native-tools.ts";
+import type { Config } from "../config/loader.ts";
+import { canvasManager } from "./canvas-manager.ts";
+import { logger } from "../utils/logger.ts";
+
+export function createCanvasRenderTool(_config: Config): Tool {
+  const log = logger.child("canvas-render");
+
+  return {
+    name: "canvas_render",
+    description: "Render a component on the user's canvas",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID to render to (auto-resolved from user context if omitted)",
+        },
+        component: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Unique component ID",
+            },
+            type: {
+              type: "string",
+              enum: ["button", "form", "chart", "table", "markdown", "text", "image"],
+              description: "Component type",
+            },
+            props: {
+              type: "object",
+              description: "Component properties",
+            },
+          },
+          required: ["id", "type", "props"],
+        },
+      },
+      required: ["component"],
+    },
+    execute: async (params: Record<string, unknown>, config?: any) => {
+      const userId = config?.configurable?.user_id;
+      const rawSessionId = params.sessionId as string;
+      const sessionId = rawSessionId
+        ? (rawSessionId.startsWith("canvas:") ? rawSessionId : `canvas:${rawSessionId}`)
+        : (userId ? `canvas:${userId}` : (() => { throw new Error("No session or user ID provided"); })());
+      const component = params.component as {
+        id: string;
+        type: "button" | "form" | "chart" | "table" | "markdown" | "text" | "image" | "card" | "progress" | "list" | "confirm";
+        props: Record<string, unknown>;
+      };
+
+      log.debug(`Rendering component ${component.id} to session ${sessionId}`);
+
+      // Check if session is connected, if not try to render to any available session
+      if (!canvasManager.isSessionConnected(sessionId)) {
+        const connectedSessions = canvasManager.getConnectedSessions();
+        if (connectedSessions.length > 0) {
+          log.warn(`Session ${sessionId} not connected, using first available: ${connectedSessions[0]}`);
+        } else {
+          log.warn(`No canvas sessions connected. Rendering to ${sessionId} anyway.`);
+        }
+      }
+
+      await canvasManager.render(sessionId, {
+        id: component.id,
+        type: component.type as any,
+        props: component.props,
+      });
+
+      return {
+        success: true,
+        componentId: component.id,
+        sessionId,
+      };
+    },
+  };
+}
+
+export function createCanvasAskTool(_config: Config): Tool {
+  const log = logger.child("canvas-ask");
+
+  return {
+    name: "canvas_ask",
+    description: "Display a form and wait for user response",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID",
+        },
+        title: {
+          type: "string",
+          description: "Form title",
+        },
+        fields: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              label: { type: "string" },
+              type: { type: "string", enum: ["text", "email", "textarea", "select"] },
+              required: { type: "boolean" },
+              options: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    label: { type: "string" },
+                    value: { type: "string" },
+                  },
+                },
+              },
+            },
+            required: ["name", "label", "type"],
+          },
+          description: "Form fields",
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in milliseconds (default: 300000)",
+        },
+      },
+      required: ["fields"],
+    },
+    execute: async (params: Record<string, unknown>, config?: any) => {
+      const userId = config?.configurable?.user_id;
+      const rawSessionId = params.sessionId as string;
+      const sessionId = rawSessionId
+        ? (rawSessionId.startsWith("canvas:") ? rawSessionId : `canvas:${rawSessionId}`)
+        : (userId ? `canvas:${userId}` : (() => { throw new Error("No session or user ID provided"); })());
+      const title = (params.title as string) ?? "Form";
+      const fields = params.fields as Array<{
+        name: string;
+        label: string;
+        type: string;
+        required?: boolean;
+        options?: Array<{ label: string; value: string }>;
+      }>;
+      const timeout = (params.timeout as number) ?? 300000;
+
+      const formId = `form-${Date.now()}`;
+
+      log.debug(`Asking user via form ${formId}`);
+
+      await canvasManager.render(sessionId, {
+        id: formId,
+        type: "form",
+        props: { title, fields },
+      });
+
+      try {
+        const response = await canvasManager.waitForInteraction(sessionId, formId, timeout);
+
+        return {
+          success: true,
+          formId,
+          data: response,
+        };
+      } catch (error) {
+        return {
+          success: false,
+          formId,
+          error: (error as Error).message,
+        };
+      }
+    },
+  };
+}
+
+export function createCanvasClearTool(_config: Config): Tool {
+  const log = logger.child("canvas-clear");
+
+  return {
+    name: "canvas_clear",
+    description: "Clear the canvas for a session",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID to clear",
+        },
+      },
+      required: [],
+    },
+    execute: async (params: Record<string, unknown>, config?: any) => {
+      const userId = config?.configurable?.user_id;
+      const rawSessionId = params.sessionId as string;
+      const sessionId = rawSessionId
+        ? (rawSessionId.startsWith("canvas:") ? rawSessionId : `canvas:${rawSessionId}`)
+        : (userId ? `canvas:${userId}` : (() => { throw new Error("No session or user ID provided"); })());
+
+      log.debug(`Clearing canvas for session ${sessionId}`);
+
+      await canvasManager.clear(sessionId);
+
+      return { success: true, sessionId };
+    },
+  };
+}
+
+export function createCanvasTools(config: Config): Tool[] {
+  return [
+    createCanvasRenderTool(config),
+    createCanvasAskTool(config),
+    createCanvasClearTool(config),
+    createCanvasCardTool(config),
+    createCanvasProgressTool(config),
+    createCanvasListTool(config),
+    createCanvasConfirmTool(config),
+  ];
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Extended Canvas Tools for A2UI
+// ═══════════════════════════════════════════════════════════════════════════
+
+export function createCanvasCardTool(_config: Config): Tool {
+  const log = logger.child("canvas-card");
+
+  return {
+    name: "canvas_show_card",
+    description: "Display a card with labeled items (useful for showing status, summaries)",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Session ID" },
+        title: { type: "string", description: "Card title" },
+        items: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              label: { type: "string" },
+              value: { type: "string" },
+              variant: { type: "string", enum: ["default", "success", "warning", "danger"] },
+            },
+          },
+        },
+        actions: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string" },
+              label: { type: "string" },
+              variant: { type: "string", enum: ["primary", "secondary", "danger", "success"] },
+            },
+          },
+        },
+      },
+      required: ["items"],
+    },
+    execute: async (params: Record<string, unknown>, config?: any) => {
+      const userId = config?.configurable?.user_id;
+      const rawSessionId = params.sessionId as string;
+      const sessionId = rawSessionId
+        ? (rawSessionId.startsWith("canvas:") ? rawSessionId : `canvas:${rawSessionId}`)
+        : (userId ? `canvas:${userId}` : (() => { throw new Error("No session or user ID provided"); })());
+      const title = (params.title as string) ?? "Information";
+      const items = (params.items as Array<{ label: string; value: string; variant?: string }>) ?? [];
+      const actions = (params.actions as Array<{ id: string; label: string; variant?: string }>) ?? [];
+
+      const cardId = `card-${Date.now()}`;
+
+      await canvasManager.render(sessionId, {
+        id: cardId,
+        type: "card",
+        props: { title, items, actions },
+      });
+
+      return { success: true, cardId, sessionId };
+    },
+  };
+}
+
+export function createCanvasProgressTool(_config: Config): Tool {
+  const log = logger.child("canvas-progress");
+
+  return {
+    name: "canvas_show_progress",
+    description: "Display progress bars for tasks (useful for multi-step operations)",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Session ID" },
+        tasks: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string" },
+              name: { type: "string" },
+              progress: { type: "number" },
+              status: { type: "string", enum: ["pending", "running", "completed", "error"] },
+            },
+          },
+        },
+      },
+      required: ["tasks"],
+    },
+    execute: async (params: Record<string, unknown>, config?: any) => {
+      const userId = config?.configurable?.user_id;
+      const rawSessionId = params.sessionId as string;
+      const sessionId = rawSessionId
+        ? (rawSessionId.startsWith("canvas:") ? rawSessionId : `canvas:${rawSessionId}`)
+        : (userId ? `canvas:${userId}` : (() => { throw new Error("No session or user ID provided"); })());
+      const tasks = (params.tasks as Array<{ id: string; name: string; progress: number; status?: string }>) ?? [];
+
+      const progressId = `progress-${Date.now()}`;
+
+      await canvasManager.render(sessionId, {
+        id: progressId,
+        type: "progress",
+        props: { tasks },
+      });
+
+      return { success: true, progressId, sessionId };
+    },
+  };
+}
+
+export function createCanvasListTool(_config: Config): Tool {
+  const log = logger.child("canvas-list");
+
+  return {
+    name: "canvas_show_list",
+    description: "Display a list of key-value pairs (useful for configuration display)",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Session ID" },
+        title: { type: "string", description: "List title" },
+        items: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              key: { type: "string" },
+              value: { type: "string" },
+            },
+          },
+        },
+      },
+      required: ["items"],
+    },
+    execute: async (params: Record<string, unknown>, config?: any) => {
+      const userId = config?.configurable?.user_id;
+      const rawSessionId = params.sessionId as string;
+      const sessionId = rawSessionId
+        ? (rawSessionId.startsWith("canvas:") ? rawSessionId : `canvas:${rawSessionId}`)
+        : (userId ? `canvas:${userId}` : (() => { throw new Error("No session or user ID provided"); })());
+      const title = (params.title as string) ?? "Details";
+      const items = (params.items as Array<{ key: string; value: string }>) ?? [];
+
+      const listId = `list-${Date.now()}`;
+
+      await canvasManager.render(sessionId, {
+        id: listId,
+        type: "list",
+        props: { title, items },
+      });
+
+      return { success: true, listId, sessionId };
+    },
+  };
+}
+
+export function createCanvasConfirmTool(_config: Config): Tool {
+  const log = logger.child("canvas-confirm");
+
+  return {
+    name: "canvas_confirm",
+    description: "Show a confirmation dialog and wait for user response",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Session ID" },
+        title: { type: "string", description: "Dialog title" },
+        message: { type: "string", description: "Confirmation message" },
+        confirmLabel: { type: "string", description: "Confirm button label" },
+        cancelLabel: { type: "string", description: "Cancel button label" },
+        danger: { type: "boolean", description: "Show as dangerous action" },
+        timeout: { type: "number", description: "Timeout in ms (default: 60000)" },
+      },
+      required: ["message"],
+    },
+    execute: async (params: Record<string, unknown>, config?: any) => {
+      const userId = config?.configurable?.user_id;
+      const rawSessionId = params.sessionId as string;
+      const sessionId = rawSessionId
+        ? (rawSessionId.startsWith("canvas:") ? rawSessionId : `canvas:${rawSessionId}`)
+        : (userId ? `canvas:${userId}` : (() => { throw new Error("No session or user ID provided"); })());
+      const title = (params.title as string) ?? "Confirm";
+      const message = params.message as string;
+      const confirmLabel = (params.confirmLabel as string) ?? "Confirm";
+      const cancelLabel = (params.cancelLabel as string) ?? "Cancel";
+      const danger = (params.danger as boolean) ?? false;
+      const timeout = (params.timeout as number) ?? 60000;
+
+      const confirmId = `confirm-${Date.now()}`;
+
+      await canvasManager.render(sessionId, {
+        id: confirmId,
+        type: "confirm",
+        props: { title, message, confirmLabel, cancelLabel, danger },
+      });
+
+      try {
+        const response = await canvasManager.waitForInteraction(sessionId, confirmId, timeout);
+        return { success: true, confirmed: response === true, confirmId, sessionId };
+      } catch (error) {
+        return { success: false, confirmed: false, confirmId, error: (error as Error).message, sessionId };
+      }
+    },
+  };
+}

package/packages/core/src/canvas/emitter.ts

@@ -0,0 +1,115 @@
+import { getDb } from "../storage/sqlite"
+
+export interface CanvasEvent {
+  type: CanvasEventType
+  data: any
+  timestamp: number
+}
+
+export type CanvasEventType =
+  | "canvas:snapshot"
+  | "canvas:node_add"
+  | "canvas:node_update"
+  | "canvas:node_remove"
+  | "canvas:edge_add"
+  | "canvas:edge_remove"
+  | "ag-ui:event"
+
+const subscribers = new Set<{ send: (data: string) => void }>()
+
+export function subscribeCanvas(ws: { send: (data: string) => void }) {
+  subscribers.add(ws)
+}
+
+export function unsubscribeCanvas(ws: { send: (data: string) => void }) {
+  subscribers.delete(ws)
+}
+
+export function emitCanvas(type: CanvasEventType, data: any) {
+  const event: CanvasEvent = { type, data, timestamp: Date.now() }
+  const payload = JSON.stringify(event)
+  for (const ws of subscribers) {
+    try {
+      ws.send(payload)
+    } catch {
+      subscribers.delete(ws)
+    }
+  }
+}
+
+export function getCanvasSnapshot() {
+  const db = getDb()
+
+  const agentNodes = db
+    .query<any, []>("SELECT id, name, description, status FROM agents")
+    .all()
+    .map((a: any) => ({
+      id: a.id,
+      name: a.name,
+      description: a.description,
+      status: a.status,
+      type: "agent",
+    }))
+
+  const mcpNodes = db
+    .query<any, []>("SELECT id, name, status FROM mcp_servers WHERE enabled = 1")
+    .all()
+    .map((m: any) => ({
+      id: `mcp:${m.id}`,
+      name: m.name,
+      status: m.status,
+      type: "mcp",
+    }))
+
+  // Proyectos activos
+  const projectNodes = db
+    .query<any, []>("SELECT id, name, type, status, progress, agent_id FROM projects WHERE status IN ('active','pending','paused')")
+    .all()
+    .map((p: any) => ({
+      id: `project_${p.id}`,
+      name: p.name,
+      status: p.status,
+      type: "project",
+      data: { progress: p.progress, projectType: p.type, agentId: p.agent_id },
+    }))
+
+  // Tareas de proyectos activos
+  const taskNodes = db
+    .query<any, []>(`
+      SELECT t.id, t.name, t.status, t.progress, t.agent_id, t.project_id
+      FROM tasks t
+      INNER JOIN projects p ON t.project_id = p.id
+      WHERE p.status IN ('active','pending','paused')
+    `)
+    .all()
+    .map((t: any) => ({
+      id: `task_${t.id}`,
+      name: t.name,
+      status: t.status,
+      type: "task",
+      data: { progress: t.progress, agentId: t.agent_id, projectId: t.project_id },
+    }))
+
+  // Edges: proyecto → tarea
+  const projectTaskEdges = taskNodes.map((t: any) => ({
+    id: `edge_proj_task_${t.id.replace("task_", "")}`,
+    source: `project_${t.data.projectId}`,
+    target: t.id,
+    edgeType: "contains",
+  }))
+
+  // Edges: tarea → agente asignado
+  const taskAgentEdges = taskNodes
+    .filter((t: any) => t.data.agentId)
+    .map((t: any) => ({
+      id: `edge_task_agent_${t.id.replace("task_", "")}`,
+      source: t.id,
+      target: t.data.agentId,
+      edgeType: "assigned_to",
+    }))
+
+  return {
+    nodes: [...agentNodes, ...mcpNodes, ...projectNodes, ...taskNodes],
+    edges: [...projectTaskEdges, ...taskAgentEdges],
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from "./canvas-manager.ts";
+export * from "./canvas-tools.ts";

package/packages/core/src/channels/base.ts

@@ -0,0 +1,138 @@
+export interface OutboundMessage {
+  type: "message" | "stream" | "status" | "error" | "pong" | "command_result" | "log" | "typing" | "audio";
+  sessionId: string;
+  content?: string;
+  chunk?: string;
+  isLast?: boolean;
+  isStep?: boolean;
+  stepType?: "plan" | "tool_call" | "tool_result" | "text";
+  audio?: {
+    buffer?: Buffer;
+    base64?: string;
+    mimeType?: string;
+  };
+  status?: {
+    state: string;
+    model?: string;
+    tokens?: number;
+  };
+  error?: string;
+  result?: unknown;
+  logEntry?: {
+    timestamp: string;
+    level: string;
+    source: string;
+    message: string;
+    meta?: Record<string, unknown>;
+  };
+}
+
+export interface IncomingMessage {
+  sessionId: string;
+  channel: string;
+  accountId: string;
+  peerId: string;
+  peerKind: "direct" | "group";
+  content: string;
+  audio?: {
+    buffer?: Buffer;
+    url?: string;
+    base64?: string;
+    mimeType?: string;
+  };
+  metadata?: Record<string, unknown>;
+  replyToId?: string;
+}
+
+export interface ChannelConfig {
+  enabled: boolean;
+  dmPolicy: "open" | "pairing" | "allowlist";
+  allowFrom: string[];
+}
+
+export interface IChannel {
+  name: string;
+  accountId: string;
+  config: ChannelConfig;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  send(sessionId: string, message: OutboundMessage): Promise<void>;
+  sendAudio?(sessionId: string, audio: Buffer, mimeType: string): Promise<void>;
+  onMessage(handler: MessageHandler): void;
+  isRunning(): boolean;
+  startTyping?(sessionId: string): Promise<void>;
+  stopTyping?(sessionId: string): Promise<void>;
+  markAsRead?(sessionId: string, messageId?: string): Promise<void>;
+}
+
+export type MessageHandler = (message: IncomingMessage) => Promise<void>;
+
+export abstract class BaseChannel implements IChannel {
+  abstract name: string;
+  abstract accountId: string;
+  abstract config: ChannelConfig;
+
+  protected messageHandler?: MessageHandler;
+  protected running = false;
+  protected typingIntervals: Map<string, Timer> = new Map();
+
+  abstract start(): Promise<void>;
+  abstract stop(): Promise<void>;
+  abstract send(sessionId: string, message: OutboundMessage): Promise<void>;
+
+  onMessage(handler: MessageHandler): void {
+    this.messageHandler = handler;
+  }
+
+  isRunning(): boolean {
+    return this.running;
+  }
+
+  async startTyping(_sessionId: string): Promise<void> {
+    // Default: no-op, override in subclasses
+  }
+
+  async stopTyping(sessionId: string): Promise<void> {
+    const interval = this.typingIntervals.get(sessionId);
+    if (interval) {
+      clearInterval(interval);
+      this.typingIntervals.delete(sessionId);
+    }
+  }
+
+  async markAsRead(_sessionId: string, _messageId?: string): Promise<void> {
+    // Default: no-op, override in subclasses
+  }
+
+  protected async handleMessage(message: IncomingMessage): Promise<void> {
+    if (this.messageHandler) {
+      await this.messageHandler(message);
+    }
+  }
+
+  protected isUserAllowed(peerId: string): boolean {
+    if (this.config.dmPolicy === "open") {
+      return true;
+    }
+
+    const normalizedPeerId = `tg:${peerId}`;
+
+    if (this.config.dmPolicy === "allowlist") {
+      return this.config.allowFrom.some(
+        (allowed) => allowed === peerId || allowed === normalizedPeerId
+      );
+    }
+
+    if (this.config.dmPolicy === "pairing") {
+      return this.config.allowFrom.some(
+        (allowed) => allowed === peerId || allowed === normalizedPeerId
+      );
+    }
+
+    return false;
+  }
+
+  protected formatSessionId(peerId: string, _kind: "direct" | "group"): string {
+    return peerId;
+  }
+}