@johpaz/hive-sdk 0.1.4 → 0.1.5

package/packages/core/src/artifacts/store.ts

@@ -0,0 +1,162 @@
+import { createHash, randomUUID } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { extname, join } from "node:path";
+import { getHiveDir } from "../config/loader";
+import { col, updateDoc } from "../storage/hive";
+import type { ArtifactDoc } from "../storage/collections";
+
+const ARTIFACT_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+
+function extensionFor(mimeType: string): string {
+  if (mimeType === "image/png") return "png";
+  if (mimeType === "image/jpeg") return "jpg";
+  if (mimeType === "image/webp") return "webp";
+  return "bin";
+}
+
+function hash(bytes: Uint8Array): string {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+function detectedMime(bytes: Uint8Array, fallback: string): string {
+  if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) {
+    return "image/png";
+  }
+  if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) {
+    return "image/jpeg";
+  }
+  if (
+    bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46 &&
+    bytes[8] === 0x57 && bytes[9] === 0x45 && bytes[10] === 0x42 && bytes[11] === 0x50
+  ) {
+    return "image/webp";
+  }
+  return fallback;
+}
+
+export async function createArtifact(input: {
+  bytes: Uint8Array;
+  mimeType: string;
+  kind: string;
+  userId: string;
+  runId?: string | null;
+  taskId?: string | null;
+  rootDir?: string;
+  width?: number | null;
+  height?: number | null;
+  now?: number;
+}): Promise<ArtifactDoc> {
+  const now = input.now ?? Date.now();
+  const id = randomUUID();
+  const root = input.rootDir ?? getHiveDir();
+  const mimeType = detectedMime(input.bytes, input.mimeType);
+  const day = new Date(now).toISOString().slice(0, 10);
+  const dir = join(root, "artifacts", day);
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, `${id}.${extensionFor(mimeType)}`);
+  writeFileSync(path, input.bytes, { flag: "wx" });
+
+  const doc: ArtifactDoc = {
+    id,
+    run_id: input.runId ?? null,
+    task_id: input.taskId ?? null,
+    user_id: input.userId,
+    kind: input.kind,
+    path,
+    mime_type: mimeType,
+    size: input.bytes.byteLength,
+    sha256: hash(input.bytes),
+    width: input.width ?? null,
+    height: input.height ?? null,
+    status: "active",
+    created_at: now,
+    expires_at: now + ARTIFACT_RETENTION_MS,
+    expired_at: null,
+  };
+
+  try {
+    const artifacts = await col<ArtifactDoc>("artifacts");
+    await artifacts.put(id, doc, { expectedVersion: 0 });
+    return doc;
+  } catch (error) {
+    try { unlinkSync(path); } catch { /* best effort rollback */ }
+    throw error;
+  }
+}
+
+export async function inspectArtifact(
+  artifactId: string,
+  options: { userId?: string } = {},
+): Promise<Record<string, unknown>> {
+  const artifacts = await col<ArtifactDoc>("artifacts");
+  const entry = await artifacts.get(artifactId);
+  if (!entry) return { ok: false, artifact_id: artifactId, error: "Artifact not found" };
+  const artifact = entry.doc;
+  if (options.userId && artifact.user_id && artifact.user_id !== options.userId) {
+    return { ok: false, artifact_id: artifactId, error: "Artifact not accessible" };
+  }
+  if (artifact.status !== "active") {
+    return {
+      ok: false,
+      artifact_id: artifactId,
+      status: artifact.status,
+      expired_at: artifact.expired_at,
+      error: "Artifact binary has expired",
+    };
+  }
+  if (!existsSync(artifact.path)) {
+    return {
+      ok: false,
+      artifact_id: artifactId,
+      status: "missing",
+      error: "Artifact binary is missing",
+    };
+  }
+
+  const bytes = readFileSync(artifact.path);
+  const actualHash = hash(bytes);
+  const stat = statSync(artifact.path);
+  return {
+    ok: actualHash === artifact.sha256 && stat.size === artifact.size,
+    artifact_id: artifact.id,
+    kind: artifact.kind,
+    mime_type: detectedMime(bytes, artifact.mime_type),
+    extension: extname(artifact.path),
+    size: stat.size,
+    expected_size: artifact.size,
+    sha256: actualHash,
+    sha256_matches: actualHash === artifact.sha256,
+    width: artifact.width,
+    height: artifact.height,
+    created_at: artifact.created_at,
+    expires_at: artifact.expires_at,
+    status: artifact.status,
+  };
+}
+
+export async function expireArtifacts(now = Date.now()): Promise<{ expired: number }> {
+  const artifacts = await col<ArtifactDoc>("artifacts");
+  const rows = await artifacts.scan({});
+  let expired = 0;
+  for (const row of rows) {
+    if (row.doc.status !== "active" || row.doc.expires_at > now) continue;
+    try {
+      if (existsSync(row.doc.path)) unlinkSync(row.doc.path);
+    } catch {
+      continue;
+    }
+    await updateDoc<ArtifactDoc>("artifacts", row.id, {
+      status: "expired",
+      expired_at: now,
+    });
+    expired++;
+  }
+  return { expired };
+}

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

@@ -0,0 +1,161 @@
+import { logger } from "../utils/logger.ts";
+import { eventBus } from "../events/event-bus.ts";
+
+export interface WebSocketLike {
+  readyState: number;
+  send(data: string | ArrayBuffer | Uint8Array): number | boolean;
+  close(code?: number, reason?: string): void;
+}
+
+export const WebSocketState = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3,
+};
+
+interface A2UISurfaceCache {
+  createData: Record<string, unknown>;
+  components?: unknown[];
+  dataModel?: Record<string, unknown>;
+}
+
+export class CanvasManager {
+  private sessions: Map<string, WebSocketLike> = new Map();
+  private a2uiCache: Map<string, A2UISurfaceCache> = new Map();
+  private log = logger.child("canvas");
+  private heartbeatInterval: ReturnType<typeof setInterval> | null = null;
+
+  constructor() {
+    this.startHeartbeat();
+  }
+
+  private startHeartbeat(): void {
+    if (this.heartbeatInterval) return;
+
+    // Enviar ping a todas las sesiones cada 30 segundos
+    this.heartbeatInterval = setInterval(() => {
+      for (const [sessionId, ws] of this.sessions) {
+        if (ws.readyState === WebSocketState.OPEN) {
+          try {
+            ws.send(JSON.stringify({ type: "canvas:ping", sessionId }));
+            this.log.debug(`Heartbeat sent to ${sessionId}`);
+          } catch (e) {
+            this.log.error(`Failed to send heartbeat to ${sessionId}`);
+          }
+        }
+      }
+    }, 30000);
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+
+  registerSession(sessionId: string, ws: WebSocketLike): void {
+    this.sessions.set(sessionId, ws);
+    this.log.info(`Canvas session registered: ${sessionId}`);
+
+    eventBus.emit("tool:completed" as any, {
+      toolName: "canvas:session:register",
+      result: { sessionId },
+      duration: 0,
+      success: true,
+    });
+
+    // Notify the client that the session is registered
+    ws.send(JSON.stringify({ type: "canvas:connected", sessionId }));
+
+    // Replay any cached A2UI surfaces so late-connecting clients get current state
+    for (const [surfaceId, cache] of this.a2uiCache) {
+      try {
+        ws.send(JSON.stringify({ type: "a2ui:createSurface", data: cache.createData }));
+        if (cache.components && cache.components.length > 0) {
+          ws.send(JSON.stringify({ type: "a2ui:updateComponents", data: { surfaceId, components: cache.components } }));
+        }
+        if (cache.dataModel && Object.keys(cache.dataModel).length > 0) {
+          ws.send(JSON.stringify({ type: "a2ui:updateDataModel", data: { surfaceId, path: undefined, value: cache.dataModel } }));
+        }
+        this.log.debug(`Replayed A2UI surface '${surfaceId}' to session ${sessionId}`);
+      } catch (e) {
+        this.log.warn(`Failed to replay A2UI surface '${surfaceId}' to ${sessionId}`);
+      }
+    }
+  }
+
+  unregisterSession(sessionId: string, ws?: WebSocketLike): void {
+    if (ws && this.sessions.get(sessionId) !== ws) return;
+    this.sessions.delete(sessionId);
+    this.log.info(`Canvas session disconnected: ${sessionId}`);
+  }
+
+  async sendA2UIMessage(sessionId: string, messageType: string, data: Record<string, unknown>): Promise<void> {
+    // Update A2UI cache so late-connecting clients can receive current state
+    const surfaceId = data.surfaceId as string | undefined;
+    if (surfaceId) {
+      if (messageType === "a2ui:createSurface") {
+        this.a2uiCache.set(surfaceId, { createData: data });
+      } else if (messageType === "a2ui:updateComponents") {
+        const cached = this.a2uiCache.get(surfaceId);
+        if (cached) cached.components = data.components as unknown[];
+      } else if (messageType === "a2ui:updateDataModel") {
+        const cached = this.a2uiCache.get(surfaceId);
+        if (cached) {
+          const path = data.path as string | undefined;
+          const value = data.value as Record<string, unknown>;
+          if (!path || path === "/") {
+            cached.dataModel = value;
+          } else {
+            cached.dataModel = cached.dataModel ?? {};
+            // Store the full model snapshot when possible; partial paths accumulate
+            const key = path.replace(/^\//, "").split("/")[0];
+            if (key) cached.dataModel[key] = value;
+          }
+        }
+      } else if (messageType === "a2ui:deleteSurface") {
+        this.a2uiCache.delete(surfaceId);
+      }
+    }
+
+    const ws = this.sessions.get(sessionId);
+
+    if (!ws || ws.readyState !== WebSocketState.OPEN) {
+      const connected = this.getConnectedSessions();
+      this.log.warn(`Session ${sessionId} NOT connected for A2UI message. Cached for replay. Available: ${connected.join(", ")}`);
+      return;
+    }
+
+    ws.send(JSON.stringify({ type: messageType, data }));
+    this.log.debug(`Sent A2UI message '${messageType}' to session ${sessionId}`);
+  }
+
+  isSessionConnected(sessionId: string): boolean {
+    const ws = this.sessions.get(sessionId);
+    return ws !== undefined && ws.readyState === WebSocketState.OPEN;
+  }
+
+  getConnectedSessions(): string[] {
+    return Array.from(this.sessions.entries())
+      .filter(([_, ws]) => ws.readyState === WebSocketState.OPEN)
+      .map(([id]) => id);
+  }
+
+  getStats(): { totalSessions: number; activeSessions: number } {
+    return {
+      totalSessions: this.sessions.size,
+      activeSessions: this.getConnectedSessions().length,
+    };
+  }
+
+  clearAll(): void {
+    this.stopHeartbeat();
+    this.sessions.clear();
+    this.a2uiCache.clear();
+    this.log.info("Canvas manager cleared");
+  }
+}
+
+export const canvasManager = new CanvasManager();

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

@@ -1,6 +1,10 @@
 import { describe, expect, it } from "bun:test";
 import { emitCanvas, subscribeCanvas, unsubscribeCanvas } from "./emitter.ts";
 
+// `canvas:render` desapareció en 0.1.5: el canvas dejó de emitir componentes
+// sueltos y pasó a un modelo de grafo (`node_add` / `node_update` / `edge_*`),
+// que es el que consume la vista de oficina 3D.
+
 describe("canvas emitter", () => {
   it("subscribes and unsubscribes websocket-like objects", () => {
     let received: any = null;
@@ -9,11 +13,11 @@ describe("canvas emitter", () => {
     };
 
     subscribeCanvas(ws);
-    emitCanvas("canvas:render", { component: { id: "test", type: "card" } });
+    emitCanvas("canvas:node_update", { nodeId: "test", changes: { status: "thinking" } });
     unsubscribeCanvas(ws);
 
     expect(received).toBeDefined();
-    expect(received.type).toBe("canvas:render");
+    expect(received.type).toBe("canvas:node_update");
   });
 
   it("stops receiving after unsubscribe", () => {
@@ -23,9 +27,9 @@ describe("canvas emitter", () => {
     };
 
     subscribeCanvas(ws);
-    emitCanvas("canvas:render", { component: { id: "a", type: "card" } });
+    emitCanvas("canvas:node_update", { nodeId: "a", changes: { status: "thinking" } });
     unsubscribeCanvas(ws);
-    emitCanvas("canvas:render", { component: { id: "b", type: "card" } });
+    emitCanvas("canvas:node_update", { nodeId: "b", changes: { status: "idle" } });
 
     expect(count).toBe(1);
   });

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

@@ -1,4 +1,5 @@
-import { getDb } from "../storage/SQLiteStorage"
+import { col, fromIndexable } from "../storage/hive"
+import type { AgentDoc, McpServerDoc } from "../storage/collections"
 
 export interface CanvasEvent {
   type: CanvasEventType
@@ -13,17 +14,48 @@ export type CanvasEventType =
   | "canvas:node_remove"
   | "canvas:edge_add"
   | "canvas:edge_remove"
-  | "canvas:render"
-  | "canvas:ask"
-  | "canvas:confirm"
-  | "canvas:clear"
+  | "canvas:work_event"
   | "ag-ui:event"
 
-const subscribers = new Set<{ send: (data: string) => void }>()
+export type CanvasWorkPhase =
+  | "delegated"
+  | "review_passed"
+  | "review_failed"
+  | "completed"
+  | "failed"
+  | "aborted"
+  | "blocked"
+
+export interface CanvasWorkEvent {
+  eventId: string
+  phase: CanvasWorkPhase
+  taskRef: string
+  taskName: string
+  actorId: string
+  targetId: string | null
+  toolName?: string | null
+  detail?: string | null
+}
 
-interface AgentLiveState { status: string; currentTool: string | null }
+const subscribers = new Set<{ send: (data: string) => void }>()
+let workEventSequence = 0
+
+interface AgentLiveState {
+  status: string
+  currentTool: string | null
+  currentTask: string | null
+  taskId: string | null
+  delegatedBy: string | null
+}
 const agentLiveState = new Map<string, AgentLiveState>()
-const canvasComponents = new Map<string, unknown>()
+
+const LIVE_DEFAULTS: AgentLiveState = {
+  status: "idle",
+  currentTool: null,
+  currentTask: null,
+  taskId: null,
+  delegatedBy: null,
+}
 
 export function subscribeCanvas(ws: { send: (data: string) => void }) {
   subscribers.add(ws)
@@ -34,20 +66,16 @@ export function unsubscribeCanvas(ws: { send: (data: string) => void }) {
 }
 
 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 }
+    const prev = agentLiveState.get(data.nodeId) ?? { ...LIVE_DEFAULTS }
+    const c = data.changes
     agentLiveState.set(data.nodeId, {
-      status: data.changes.status ?? prev.status,
-      currentTool: "currentTool" in data.changes ? data.changes.currentTool : prev.currentTool,
+      status: c.status ?? prev.status,
+      currentTool: "currentTool" in c ? c.currentTool : prev.currentTool,
+      currentTask: "currentTask" in c ? c.currentTask : prev.currentTask,
+      taskId: "taskId" in c ? c.taskId : prev.taskId,
+      delegatedBy: "delegatedBy" in c ? c.delegatedBy : prev.delegatedBy,
     })
   }
 
@@ -62,17 +90,69 @@ export function emitCanvas(type: CanvasEventType, data: any) {
   }
 }
 
-export function removeCanvasComponent(id: string) {
-  canvasComponents.delete(id);
+/** Evento semántico y transitorio para presentar el trabajo sin inferir resultados. */
+export function emitWorkEvent(event: Omit<CanvasWorkEvent, "eventId">): CanvasWorkEvent {
+  const emitted: CanvasWorkEvent = {
+    eventId: `work:${event.taskRef}:${event.phase}:${Date.now().toString(36)}:${++workEventSequence}`,
+    ...event,
+    taskName: event.taskName.slice(0, 120),
+    detail: event.detail?.slice(0, 180) ?? null,
+  }
+  emitCanvas("canvas:work_event", emitted)
+  return emitted
 }
 
-export function getCanvasSnapshot() {
-  const db = getDb()
+/**
+ * Marca visualmente el inicio de una delegación coordinador→worker:
+ * el worker muestra la tarea en curso y aparece el edge "delegates".
+ */
+export function emitDelegationStarted(opts: {
+  workerId: string
+  parentAgentId: string
+  taskRef: string
+  taskName: string
+}) {
+  emitWorkEvent({
+    phase: "delegated",
+    taskRef: opts.taskRef,
+    taskName: opts.taskName,
+    actorId: opts.parentAgentId,
+    targetId: opts.workerId,
+  })
+  emitCanvas("canvas:node_update", {
+    nodeId: opts.workerId,
+    changes: {
+      status: "thinking",
+      currentTask: opts.taskName,
+      taskId: opts.taskRef,
+      delegatedBy: opts.parentAgentId,
+    },
+  })
+  if (opts.parentAgentId) {
+    emitCanvas("canvas:edge_add", {
+      id: `deleg_${opts.taskRef}`,
+      source: opts.parentAgentId,
+      target: opts.workerId,
+      edgeType: "delegates",
+      data: { taskId: opts.taskRef, taskName: opts.taskName },
+    })
+  }
+}
+
+/** Limpia el estado visual de delegación (éxito, fallo o aborto). */
+export function emitDelegationFinished(opts: { workerId: string; taskRef: string }) {
+  emitCanvas("canvas:node_update", {
+    nodeId: opts.workerId,
+    changes: { status: "idle", currentTool: null, currentTask: null, taskId: null, delegatedBy: null },
+  })
+  emitCanvas("canvas:edge_remove", { id: `deleg_${opts.taskRef}` })
+}
 
-  const agentNodes = db
-    .query<any, []>("SELECT id, name, description, role, status FROM agents")
-    .all()
-    .map((a: any) => {
+export async function getCanvasSnapshot() {
+  const agentsCol = await col<AgentDoc>("agents")
+  const agentNodes = (await agentsCol.scan({}))
+    .map(e => e.doc)
+    .map((a) => {
       const live = agentLiveState.get(a.id)
       return {
         id: a.id,
@@ -80,70 +160,41 @@ export function getCanvasSnapshot() {
         description: a.description,
         status: live?.status ?? a.status,
         type: "agent",
-        data: { role: a.role, currentTool: live?.currentTool ?? null },
+        data: {
+          role: a.role,
+          currentTool: live?.currentTool ?? null,
+          currentTask: live?.currentTask ?? null,
+          taskId: live?.taskId ?? null,
+          delegatedBy: live?.delegatedBy ?? null,
+          source: a.source ?? null,
+        },
       }
     })
 
-  const mcpNodes = db
-    .query<any, []>("SELECT id, name, status FROM mcp_servers WHERE enabled = 1")
-    .all()
-    .map((m: any) => ({
+  const mcpServersCol = await col<McpServerDoc>("mcpServers")
+  const mcpNodes = (await mcpServersCol.scan({}))
+    .map(e => e.doc)
+    .filter(m => m.enabled)
+    .map((m) => ({
       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",
+  // Edges: delegaciones activas coordinador → worker (sobreviven reconexiones)
+  const delegationEdges = Array.from(agentLiveState.entries())
+    .filter(([, s]) => s.delegatedBy && s.taskId)
+    .map(([workerId, s]) => ({
+      id: `deleg_${s.taskId}`,
+      source: s.delegatedBy as string,
+      target: workerId,
+      edgeType: "delegates",
+      data: { taskId: s.taskId, taskName: s.currentTask },
     }))
 
   return {
-    nodes: [...agentNodes, ...mcpNodes, ...projectNodes, ...taskNodes],
-    edges: [...projectTaskEdges, ...taskAgentEdges],
-    components: Array.from(canvasComponents.values()),
+    nodes: [...agentNodes, ...mcpNodes],
+    edges: [...delegationEdges],
   }
 }

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

@@ -1,3 +1 @@
-export * from "./CanvasManager.ts";
-export * from "./canvas-tools.ts";
-export * from "./a2ui-tools.ts";
+export * from "./canvas-manager.ts";

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

@@ -1,12 +1,18 @@
 export interface OutboundMessage {
-  type: "message" | "stream" | "status" | "error" | "pong" | "command_result" | "log" | "typing" | "audio";
+  type: "message" | "stream" | "status" | "error" | "pong" | "command_result" | "log" | "typing" | "audio" | "process" | "progress" | "notification";
   sessionId: string;
   id?: string; // Message ID for streaming
+  messageId?: string;
   content?: string;
   chunk?: string;
   isChunk?: boolean; // True if this is a streaming chunk
   isLast?: boolean;
   isStep?: boolean;
+  processKind?: "analysis" | "tool" | "observation" | "writing";
+  processStatus?: "thinking" | "done" | "error";
+  label?: string;
+  detail?: string;
+  summary?: string;
   stepType?: "plan" | "tool_call" | "tool_result" | "text";
   audio?: {
     buffer?: Buffer;
@@ -20,6 +26,8 @@ export interface OutboundMessage {
   };
   error?: string;
   result?: unknown;
+  notificationId?: string;
+  createdAt?: number;
   logEntry?: {
     timestamp: string;
     level: string;

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

@@ -9,7 +9,8 @@ import {
 } from "discord.js";
 import { BaseChannel, type ChannelConfig, type IncomingMessage, type OutboundMessage } from "./base.ts";
 import { logger } from "../utils/logger.ts";
-import { getDb } from "../storage/SQLiteStorage.ts";
+import { updateDoc } from "../storage/hive.ts";
+import type { ChannelDoc } from "../storage/collections.ts";
 
 export interface DiscordConfig extends ChannelConfig {
   botToken: string;
@@ -56,11 +57,11 @@ export class DiscordChannel extends BaseChannel {
       this.log.error(`Discord client error: ${error.message}`);
     });
 
-    this.client.once(Events.ClientReady, () => {
+    this.client.once(Events.ClientReady, async () => {
       this.log.info(`Discord bot started: ${this.client?.user?.tag ?? "unknown"}`);
       this.running = true;
       try {
-        getDb().query(`UPDATE channels SET status = 'connected' WHERE id = ?`).run(this.accountId);
+        await updateDoc<ChannelDoc>("channels", this.accountId, { status: "connected" });
       } catch { /* ignore DB errors */ }
     });
 
@@ -137,7 +138,7 @@ export class DiscordChannel extends BaseChannel {
       this.running = false;
       this.log.info("Discord bot stopped");
       try {
-        getDb().query(`UPDATE channels SET status = 'disconnected' WHERE id = ?`).run(this.accountId);
+        await updateDoc<ChannelDoc>("channels", this.accountId, { status: "disconnected" });
       } catch { /* ignore DB errors */ }
     }
   }