@johpaz/hive 1.7.2 → 1.7.3

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

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

@@ -1,119 +0,0 @@
-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"
-  | "canvas:render"
-  | "canvas:ask"
-  | "canvas:confirm"
-  | "canvas:clear"
-  | "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

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

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

@@ -1,140 +0,0 @@
-export interface OutboundMessage {
-  type: "message" | "stream" | "status" | "error" | "pong" | "command_result" | "log" | "typing" | "audio";
-  sessionId: string;
-  id?: string; // Message ID for streaming
-  content?: string;
-  chunk?: string;
-  isChunk?: boolean; // True if this is a streaming chunk
-  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;
-  }
-}