@johpaz/hive-sdk 0.0.14 → 0.0.15

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

@@ -0,0 +1,448 @@
+import type { Tool } from "../agent/NativeTools.ts";
+import type { Config } from "../config/loader.ts";
+import { canvasManager } from "./CanvasManager.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",
+            },
+            span: {
+              type: "string",
+              enum: ["full", "half"],
+              description: "Width span: 'full' for full-width component, 'half' for half width. Default: single column",
+            },
+          },
+          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>;
+        span?: "full" | "half";
+      };
+
+      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,
+        span: component.span,
+      });
+
+      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"] },
+            },
+          },
+        },
+        span: {
+          type: "string",
+          enum: ["full", "half"],
+          description: "Width span: 'full' for full-width card, 'half' for half width. Default: single column",
+        },
+      },
+      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 span = params.span as "full" | "half" | undefined;
+
+      const cardId = `card-${Date.now()}`;
+
+      await canvasManager.render(sessionId, {
+        id: cardId,
+        type: "card",
+        props: { title, items, actions },
+        span,
+      });
+
+      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"] },
+            },
+          },
+        },
+        span: {
+          type: "string",
+          enum: ["full", "half"],
+          description: "Width span: 'full' for full-width, 'half' for half width. Default: single column",
+        },
+      },
+      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 span = params.span as "full" | "half" | undefined;
+
+      const progressId = `progress-${Date.now()}`;
+
+      await canvasManager.render(sessionId, {
+        id: progressId,
+        type: "progress",
+        props: { tasks },
+        span,
+      });
+
+      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" },
+            },
+          },
+        },
+        span: {
+          type: "string",
+          enum: ["full", "half"],
+          description: "Width span: 'full' for full-width, 'half' for half width. Default: single column",
+        },
+      },
+      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 span = params.span as "full" | "half" | undefined;
+
+      const listId = `list-${Date.now()}`;
+
+      await canvasManager.render(sessionId, {
+        id: listId,
+        type: "list",
+        props: { title, items },
+        span,
+      });
+
+      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,149 @@
+import { getDb } from "../storage/SQLiteStorage.ts"
+
+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 }>()
+
+interface AgentLiveState { status: string; currentTool: string | null }
+const agentLiveState = new Map<string, AgentLiveState>()
+const canvasComponents = new Map<string, unknown>()
+
+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) {
+  // Track canvas components for new subscribers
+  if (type === "canvas:render" && data?.component?.id) {
+    canvasComponents.set(data.component.id, data.component)
+  }
+  if (type === "canvas:clear") {
+    canvasComponents.clear()
+  }
+
+  // Track live agent state for new subscribers
+  if (type === "canvas:node_update" && data?.nodeId && data?.changes) {
+    const prev = agentLiveState.get(data.nodeId) ?? { status: "idle", currentTool: null }
+    agentLiveState.set(data.nodeId, {
+      status: data.changes.status ?? prev.status,
+      currentTool: "currentTool" in data.changes ? data.changes.currentTool : prev.currentTool,
+    })
+  }
+
+  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 removeCanvasComponent(id: string) {
+  canvasComponents.delete(id);
+}
+
+export function getCanvasSnapshot() {
+  const db = getDb()
+
+  const agentNodes = db
+    .query<any, []>("SELECT id, name, description, role, status FROM agents")
+    .all()
+    .map((a: any) => {
+      const live = agentLiveState.get(a.id)
+      return {
+        id: a.id,
+        name: a.name,
+        description: a.description,
+        status: live?.status ?? a.status,
+        type: "agent",
+        data: { role: a.role, currentTool: live?.currentTool ?? null },
+      }
+    })
+
+  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],
+    components: Array.from(canvasComponents.values()),
+  }
+}

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

@@ -0,0 +1,6 @@
+export { createCanvasRenderTool, createCanvasAskTool, createCanvasClearTool, createCanvasTools, createCanvasCardTool, createCanvasProgressTool, createCanvasListTool, createCanvasConfirmTool } from "./canvas-tools.ts";
+export { createA2UISurfaceTool, createA2UIUpdateComponentsTool, createA2UIUpdateDataModelTool, createA2UIDeleteSurfaceTool } from "./a2ui-tools.ts";
+export type { CanvasEvent, CanvasEventType } from "./emitter.ts";
+export { subscribeCanvas, unsubscribeCanvas, emitCanvas, getCanvasSnapshot, removeCanvasComponent } from "./emitter.ts";
+export type { WebSocketLike, CanvasComponent, CanvasMessage, InteractionEvent } from "./CanvasManager.ts";
+export { WebSocketState, CanvasManager, canvasManager } from "./CanvasManager.ts";

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

@@ -0,0 +1,2 @@
+export { loadEnv, getHiveDir, loadConfig } from "./loader.ts";
+export type { Config } from "./loader.ts";