@johpaz/hive-sdk 0.1.4 → 0.1.6

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

@@ -6,7 +6,8 @@ import { createDiscordChannel, type DiscordConfig } from "./discord.ts";
 import { createWebChatChannel, type WebChatConfig } from "./webchat.ts";
 import { createWhatsAppChannel, WhatsAppChannel, type WhatsAppConfig } from "./whatsapp.ts";
 import { createSlackChannel, type SlackConfig } from "./slack.ts";
-import { getDb } from "../storage/SQLiteStorage.ts";
+import { col } from "../storage/hive.ts";
+import type { ChannelDoc, AgentDoc, UserIdentityDoc } from "../storage/collections.ts";
 import { loadChannelConfig } from "../storage/crypto.ts";
 
 export class ChannelManager {
@@ -14,11 +15,44 @@ export class ChannelManager {
   private channels: Map<string, IChannel> = new Map();
   private messageHandler?: MessageHandler;
   private log = logger.child("channels");
+  /**
+   * `channel:sessionId` → accountId of the account that received the message.
+   *
+   * Outbound calls (agent reply, narration, notify tools, scheduler) only carry
+   * a channel name and a routing session id. With two accounts of the same type
+   * connected — two WhatsApp numbers — picking a channel by name alone sends the
+   * reply out through whichever account happens to be first, to a peer that may
+   * not even exist there. Every inbound message records its account here so the
+   * reply goes back out the way it came in.
+   *
+   * Known limit: if the same peer id talks to two accounts of one type, the
+   * routing session id is identical for both and the most recent inbound
+   * message wins. Distinguishing them would require the account in the session
+   * id itself.
+   */
+  private sessionAccounts: Map<string, string> = new Map();
 
   constructor(config: Config) {
     this.config = config;
   }
 
+  private sessionKey(channelName: string, sessionId: string): string {
+    return `${channelName}:${sessionId}`;
+  }
+
+  /**
+   * Resolves which account owns an outbound session: an explicit account wins,
+   * then the account that last received a message on it.
+   */
+  private resolveAccountId(
+    channelName: string,
+    sessionId: string,
+    explicit?: string
+  ): string | undefined {
+    if (explicit) return explicit;
+    return this.sessionAccounts.get(this.sessionKey(channelName, sessionId));
+  }
+
   onMessage(handler: MessageHandler): void {
     this.messageHandler = handler;
   }
@@ -32,16 +66,36 @@ export class ChannelManager {
       await this.initializeFromConfig();
     }
 
+    await this.seedSessionAccounts();
+
     this.log.info(`Initialized ${this.channels.size} channel(s)`);
   }
 
+  /**
+   * Restores session→account routing from persisted identities. Without this, a
+   * durable worker that finishes after a restart would have no record of which
+   * account its conversation came in on.
+   */
+  private async seedSessionAccounts(): Promise<void> {
+    try {
+      const identitiesCol = await col<UserIdentityDoc>("userIdentities");
+      for (const { doc } of await identitiesCol.scan({})) {
+        if (!doc.account_id || !doc.channel_user_id) continue;
+        // Skip identities whose account is gone (disconnected and replaced by
+        // another one) — pinning a session to it would only fail every send.
+        if (!this.channels.has(`${doc.channel}:${doc.account_id}`)) continue;
+        this.sessionAccounts.set(this.sessionKey(doc.channel, doc.channel_user_id), doc.account_id);
+      }
+    } catch (error) {
+      this.log.debug(`Could not seed session accounts: ${(error as Error).message}`);
+    }
+  }
+
   private async initializeFromDB(): Promise<void> {
     try {
-      const db = getDb();
+      const channelsCol = await col<ChannelDoc>("channels");
       // Load all active channels - config may be empty for webchat
-      const rows = db.query(`
-        SELECT id, type, enabled, active FROM channels WHERE enabled = 1 AND active = 1
-      `).all() as Array<{ id: string; type: string; enabled: number; active: number }>;
+      const rows = (await channelsCol.scan({})).filter(e => e.doc.enabled && e.doc.active).map(e => e.doc);
 
       for (const row of rows) {
         let config: Record<string, unknown> = {};
@@ -85,6 +139,26 @@ export class ChannelManager {
     }
   }
 
+  /**
+   * Wires a channel into the manager: inbound messages record which account
+   * received them before reaching the handler, so replies can be routed back.
+   */
+  private registerChannel(key: string, channel: IChannel): void {
+    channel.onMessage(async (message: IncomingMessage) => {
+      if (message.accountId && message.sessionId) {
+        this.sessionAccounts.set(
+          this.sessionKey(message.channel, message.sessionId),
+          message.accountId
+        );
+      }
+      if (this.messageHandler) {
+        await this.messageHandler(message);
+      }
+    });
+
+    this.channels.set(key, channel);
+  }
+
   private async createChannel(
     channelName: string,
     accountId: string,
@@ -125,7 +199,8 @@ export class ChannelManager {
         case "whatsapp": {
           let coordinatorId = "main";
           try {
-            const coordinator = getDb().query(`SELECT id FROM agents WHERE role = 'coordinator' LIMIT 1`).get() as { id: string } | null;
+            const agentsCol = await col<AgentDoc>("agents");
+            const coordinator = (await agentsCol.findBy("role", "coordinator", { limit: 1 }))[0];
             if (coordinator?.id) coordinatorId = coordinator.id;
           } catch { /* fallback to "main" */ }
           channel = createWhatsAppChannel({
@@ -158,14 +233,8 @@ export class ChannelManager {
           return;
       }
 
-      channel.onMessage(async (message: IncomingMessage) => {
-        if (this.messageHandler) {
-          await this.messageHandler(message);
-        }
-      });
-
       const key = `${channelName}:${accountId}`;
-      this.channels.set(key, channel);
+      this.registerChannel(key, channel);
 
       this.log.info(`Created channel: ${key}`);
     } catch (error) {
@@ -217,22 +286,35 @@ export class ChannelManager {
 
   getChannel(channelName: string, accountId?: string): IChannel | undefined {
     if (accountId) {
-      return this.channels.get(`${channelName}:${accountId}`);
-    }
-
-    for (const [key, channel] of this.channels) {
-      if (key.startsWith(channelName)) {
-        return channel;
+      const exact = this.channels.get(`${channelName}:${accountId}`);
+      // Deliberately no fallback: delivering through a different account would
+      // send someone else's conversation out of the wrong number.
+      if (!exact) {
+        this.log.warn(`Channel ${channelName}:${accountId} is not instantiated — refusing to fall back to another account`);
       }
+      return exact;
     }
 
-    return undefined;
+    const matches = [...this.channels.entries()].filter(([key]) => key.startsWith(`${channelName}:`));
+    if (matches.length > 1) {
+      this.log.warn(
+        `${matches.length} "${channelName}" accounts are connected and no account was given — routing through ${matches[0]![0]}`
+      );
+    }
+    return matches[0]?.[1];
   }
 
   async removeChannel(channelName: string, accountId: string): Promise<void> {
     const key = `${channelName}:${accountId}`;
     await this.stopChannel(channelName, accountId);
     this.channels.delete(key);
+    // Drop sessions pinned to this account, otherwise every later send to them
+    // resolves to a channel that no longer exists.
+    for (const [sessionKey, account] of this.sessionAccounts) {
+      if (account === accountId && sessionKey.startsWith(`${channelName}:`)) {
+        this.sessionAccounts.delete(sessionKey);
+      }
+    }
     this.log.info(`Removed channel: ${key}`);
   }
 
@@ -398,12 +480,22 @@ export class ChannelManager {
     });
   }
 
+  /** Resolves the account that owns this session (see `sessionAccounts`). */
+  private channelForSession(
+    channelName: string,
+    sessionId: string,
+    accountId?: string
+  ): IChannel | undefined {
+    return this.getChannel(channelName, this.resolveAccountId(channelName, sessionId, accountId));
+  }
+
   async send(
     channelName: string,
     sessionId: string,
-    message: unknown
+    message: unknown,
+    accountId?: string
   ): Promise<void> {
-    const channel = this.getChannel(channelName);
+    const channel = this.channelForSession(channelName, sessionId, accountId);
 
     if (!channel) {
       throw new Error(`Channel not found: ${channelName}`);
@@ -412,29 +504,29 @@ export class ChannelManager {
     await channel.send(sessionId, message as any);
   }
 
-  async startTyping(channelName: string, sessionId: string): Promise<void> {
-    const channel = this.getChannel(channelName);
+  async startTyping(channelName: string, sessionId: string, accountId?: string): Promise<void> {
+    const channel = this.channelForSession(channelName, sessionId, accountId);
     if (channel?.startTyping) {
       await channel.startTyping(sessionId);
     }
   }
 
-  async stopTyping(channelName: string, sessionId: string): Promise<void> {
-    const channel = this.getChannel(channelName);
+  async stopTyping(channelName: string, sessionId: string, accountId?: string): Promise<void> {
+    const channel = this.channelForSession(channelName, sessionId, accountId);
     if (channel?.stopTyping) {
       await channel.stopTyping(sessionId);
     }
   }
 
-  async markAsRead(channelName: string, sessionId: string, messageId?: string): Promise<void> {
-    const channel = this.getChannel(channelName);
+  async markAsRead(channelName: string, sessionId: string, messageId?: string, accountId?: string): Promise<void> {
+    const channel = this.channelForSession(channelName, sessionId, accountId);
     if (channel?.markAsRead) {
       await channel.markAsRead(sessionId, messageId);
     }
   }
 
-  async sendAudio(channelName: string, sessionId: string, audio: Buffer, mimeType: string): Promise<void> {
-    const channel = this.getChannel(channelName);
+  async sendAudio(channelName: string, sessionId: string, audio: Buffer, mimeType: string, accountId?: string): Promise<void> {
+    const channel = this.channelForSession(channelName, sessionId, accountId);
     if (!channel) {
       throw new Error(`Channel not found: ${channelName}`);
     }

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

@@ -2,7 +2,8 @@ import { App, ExpressReceiver, type SlashCommand } from "@slack/bolt";
 import type { ChannelConfig, IncomingMessage, OutboundMessage } from "./base.ts";
 import { BaseChannel } 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 SlackConfig extends ChannelConfig {
   accountId?: string;
@@ -95,7 +96,7 @@ export class SlackChannel extends BaseChannel {
       this.connectionState.status = "connected";
       this.log.info(`Slack channel started on port ${port}`);
       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 */ }
 
     } catch (error) {
@@ -103,7 +104,7 @@ export class SlackChannel extends BaseChannel {
       this.connectionState.error = (error as Error).message;
       this.log.error(`Slack connection error: ${(error as Error).message}`);
       try {
-        getDb().query(`UPDATE channels SET status = 'error' WHERE id = ?`).run(this.accountId);
+        await updateDoc<ChannelDoc>("channels", this.accountId, { status: "error" });
       } catch { /* ignore DB errors */ }
       throw error;
     }
@@ -124,7 +125,7 @@ export class SlackChannel extends BaseChannel {
     this.connectionState.status = "disconnected";
     this.log.info("Slack channel 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 */ }
   }
 

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

@@ -1,7 +1,9 @@
 import { Bot, GrammyError, InputFile, type Context } from "grammy";
 import { BaseChannel, type ChannelConfig, type IncomingMessage, type OutboundMessage } from "./base.ts";
 import { logger } from "../utils/logger.ts";
-import { getDb } from "../storage/SQLiteStorage.ts";
+import { col, updateDoc } from "../storage/hive.ts";
+import type { ChannelDoc, UserIdentityDoc } from "../storage/collections.ts";
+import { resolveUserId } from "../storage/onboarding";
 
 export interface TelegramConfig extends ChannelConfig {
   botToken: string;
@@ -55,22 +57,45 @@ export class TelegramChannel extends BaseChannel {
     });
 
     this.bot.start({
-      onStart: () => {
+      onStart: async () => {
         this.running = true;
         this.log.info(`Telegram bot started: @${this.bot?.botInfo?.username ?? "unknown"}`);
         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 */ }
       },
-    }).catch((error: Error) => {
+    }).catch(async (error: Error) => {
       this.log.error(`Telegram bot error: ${error.message}`);
       this.running = false;
       try {
-        getDb().query(`UPDATE channels SET status = 'error' WHERE id = ?`).run(this.accountId);
+        await updateDoc<ChannelDoc>("channels", this.accountId, { status: "error" });
       } catch { /* ignore DB errors */ }
     });
   }
 
+  /**
+   * Ensures a userIdentities row links this Telegram chat to the single-user
+   * account, so cron/task notifications can route to Telegram even when the
+   * user's first-ever contact with the bot was a command (e.g. /start) that
+   * otherwise replies and returns before reaching the normal
+   * handleMessage() → resolveContext() auto-link path.
+   */
+  private async linkIdentity(channelUserId: string): Promise<void> {
+    try {
+      const userId = await resolveUserId({});
+      if (!userId) return;
+      const identitiesCol = await col<UserIdentityDoc>("userIdentities");
+      await identitiesCol.put(`${userId}:telegram`, {
+        user_id: userId,
+        channel: "telegram",
+        channel_user_id: channelUserId,
+        linked_at: Date.now(),
+      });
+    } catch (err) {
+      this.log.warn(`Failed to auto-link telegram identity: ${(err as Error).message}`);
+    }
+  }
+
   private async handleTelegramMessage(ctx: Context): Promise<void> {
     const message = ctx.message;
     if (!message) return;
@@ -100,6 +125,11 @@ export class TelegramChannel extends BaseChannel {
       if (now - ts > 60_000) this.recentlyProcessed.delete(id);
     }
 
+    // Auto-link this chat on first contact, before any command short-circuits.
+    if (!isGroup && this.isUserAllowed(chatId)) {
+      await this.linkIdentity(chatId);
+    }
+
     const text = message.text;
     const isCommand = text?.startsWith("/") ?? false;
 
@@ -306,7 +336,7 @@ export class TelegramChannel extends BaseChannel {
       this.running = false;
       this.log.info("Telegram 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 */ }
     }
   }

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

@@ -19,17 +19,22 @@ export class WebChatChannel extends BaseChannel {
   accountId: string;
   config: WebChatConfig;
 
+  private explicitAccountId?: string;
   private connections: Map<string, ServerWebSocket<WebSocketData>> = new Map();
   private log = logger.child("webchat");
 
   constructor(config: WebChatConfig) {
     super();
     this.config = config;
-    // Resolve accountId from database (single user) or use fallback
-    this.accountId = config.accountId || resolveUserId({}) || "webchat";
+    this.explicitAccountId = config.accountId;
+    this.accountId = config.accountId || "webchat";
   }
 
   async start(): Promise<void> {
+    // Resolve accountId from database (single user) if not provided explicitly
+    if (!this.explicitAccountId) {
+      this.accountId = (await resolveUserId({})) || "webchat";
+    }
     this.running = true;
     this.log.info("WebChat channel ready");
   }
@@ -46,7 +51,8 @@ export class WebChatChannel extends BaseChannel {
     this.log.debug(`WebChat connection registered: ${data.sessionId}`);
   }
 
-  unregisterConnection(sessionId: string): void {
+  unregisterConnection(sessionId: string, ws?: ServerWebSocket<WebSocketData>): void {
+    if (ws && this.connections.get(sessionId) !== ws) return;
     this.connections.delete(sessionId);
     this.log.debug(`WebChat connection unregistered: ${sessionId}`);
   }
@@ -86,15 +92,10 @@ export class WebChatChannel extends BaseChannel {
     const ws = this.connections.get(sessionId);
 
     if (!ws) {
-      this.log.warn(`No WebChat connection for session: ${sessionId}`);
-      return;
+      throw new Error(`No WebChat connection for session: ${sessionId}`);
     }
 
-    try {
-      ws.send(JSON.stringify(message));
-    } catch (error) {
-      this.log.error(`Failed to send WebChat message: ${(error as Error).message}`);
-    }
+    ws.send(JSON.stringify(message));
   }
 
   async sendAudio(sessionId: string, audio: Buffer, mimeType: string): Promise<void> {

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

@@ -11,8 +11,10 @@ import type { ChannelConfig, IncomingMessage, OutboundMessage } from "./base.ts"
 import { BaseChannel } from "./base.ts";
 import { existsSync, mkdirSync, rmSync } from "node:fs";
 import * as path from "node:path";
+import { homedir } from "node:os";
 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";
 // @ts-ignore — no type definitions for qrcode-terminal
 import qrcodeTerminal from "qrcode-terminal";
 
@@ -69,7 +71,7 @@ export class WhatsAppChannel extends BaseChannel {
   }
 
   private getAuthPath(agentId: string, accountId: string): string {
-    const baseDir = process.env.HOME ?? "";
+    const baseDir = homedir();
     const authDir = path.join(baseDir, ".hive", "agents", agentId, "whatsapp", accountId);
 
     if (!existsSync(authDir)) {
@@ -117,11 +119,22 @@ export class WhatsAppChannel extends BaseChannel {
       this.connectionState.waVersion = version.join(".");
       this.log.info(`Using WhatsApp Web v${version.join(".")}`);
 
+      const baileysLogger = {
+        level: "silent",
+        child: () => baileysLogger,
+        trace: () => {},
+        debug: () => {},
+        info:  (msg: unknown) => { if (typeof msg === "object" && msg !== null) this.log.debug((msg as any).msg ?? JSON.stringify(msg)); },
+        warn:  (msg: unknown) => { if (typeof msg === "object" && msg !== null) this.log.warn((msg as any).msg ?? JSON.stringify(msg)); },
+        error: (msg: unknown) => { if (typeof msg === "object" && msg !== null) this.log.error((msg as any).msg ?? JSON.stringify(msg)); },
+      };
+
       this.socket = makeWASocket({
         version,
         auth: state,
         printQRInTerminal: false,
         syncFullHistory: false,
+        logger: baileysLogger as any,
         getMessage: async () => ({ conversation: "" }),
       });
 
@@ -169,8 +182,7 @@ export class WhatsAppChannel extends BaseChannel {
       this.log.warn(`WhatsApp disconnected: ${statusCode}`);
 
       try {
-        getDb().query(`UPDATE channels SET status = ? WHERE id = ?`)
-          .run(shouldReconnect ? "connecting" : "disconnected", this.accountId);
+        await updateDoc<ChannelDoc>("channels", this.accountId, { status: shouldReconnect ? "connecting" : "disconnected" });
       } catch { /* ignore DB errors */ }
 
       const needsSessionClear =
@@ -207,8 +219,7 @@ export class WhatsAppChannel extends BaseChannel {
       }
 
       try {
-        getDb().query(`UPDATE channels SET status = 'connected', last_active = ? WHERE id = ?`)
-          .run(Date.now(), this.accountId);
+        await updateDoc<ChannelDoc>("channels", this.accountId, { status: "connected", last_active: Date.now() });
       } catch { /* ignore DB errors */ }
     }
   }
@@ -471,7 +482,11 @@ export class WhatsAppChannel extends BaseChannel {
       throw new Error("WhatsApp not connected");
     }
 
-    await this.stopTyping(sessionId);
+    // Progress narration arrives mid-turn. Clearing "typing…" on it would leave
+    // the user watching interim messages with no sign the agent is still
+    // working — only a final message ends the indicator.
+    const isInterim = message.type === "progress";
+    if (!isInterim) await this.stopTyping(sessionId);
 
     const text = message.content ?? message.chunk ?? "";
     if (!text) return;
@@ -479,6 +494,7 @@ export class WhatsAppChannel extends BaseChannel {
     const jid = this.getJid(sessionId);
 
     await this.socket.sendMessage(jid, { text });
+    if (isInterim) await this.startTyping(sessionId);
     this.log.debug(`Sent message to ${jid}`);
   }
 

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

@@ -1,2 +1,13 @@
-export { loadEnv, getHiveDir, loadConfig } from "./loader.ts";
-export type { Config } from "./loader.ts";
+export {
+    loadEnv,
+    getHiveDir,
+    loadConfig,
+    expandConfigPath,
+    expandPath,
+    type Config,
+    type ProviderConfig,
+    type MCPServerConfig,
+    type AgentEntry,
+    type Binding,
+    type UserConfig as ConfigUserConfig
+} from "./loader.ts";