zubo 0.1.0

package/src/channels/discord.ts

@@ -0,0 +1,137 @@
+import {
+  Client,
+  GatewayIntentBits,
+  type Message as DiscordMessage,
+} from "discord.js";
+import type { ChannelAdapter, InboundMessage } from "./adapter";
+import type { MessageRouter } from "./router";
+import { splitMessage } from "./utils";
+import { logger } from "../util/logger";
+
+export function createDiscordAdapter(
+  token: string,
+  allowedUsers: string[],
+  router: MessageRouter
+): ChannelAdapter {
+  const client = new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.DirectMessages,
+      GatewayIntentBits.MessageContent,
+    ],
+  });
+
+  // Map session keys to channel IDs for proactive messaging
+  const channelIds = new Map<string, string>();
+
+  client.on("messageCreate", async (msg: DiscordMessage) => {
+    // Ignore bots
+    if (msg.author.bot) return;
+
+    const isDM = !msg.guild;
+    const isMentioned =
+      msg.mentions.users.has(client.user?.id ?? "") ||
+      msg.content.startsWith(`<@${client.user?.id}>`);
+
+    // In guilds, only respond when mentioned
+    if (!isDM && !isMentioned) return;
+
+    const userId = msg.author.id;
+
+    // Auto-pair: first user to DM gets registered
+    if (allowedUsers.length === 0 && isDM) {
+      allowedUsers.push(userId);
+      logger.info(`Auto-registered Discord user: ${userId}`);
+      await msg.reply(
+        "Welcome! You've been registered as the owner of this Zubo agent."
+      );
+    }
+
+    // Access control (skip for guild mentions if no allowlist)
+    if (allowedUsers.length > 0 && !allowedUsers.includes(userId)) {
+      if (isDM) {
+        await msg.reply("Sorry, you're not authorized to use this bot.");
+      }
+      return;
+    }
+
+    const sessionKey = `discord:${userId}`;
+    channelIds.set(sessionKey, msg.channel.id);
+
+    // Strip the mention from the message text
+    let text = msg.content;
+    if (isMentioned && !isDM) {
+      text = text
+        .replace(new RegExp(`<@!?${client.user?.id}>`, "g"), "")
+        .trim();
+    }
+    if (!text) return;
+
+    const message: InboundMessage = {
+      channel: "discord",
+      userId,
+      sessionKey,
+      text,
+    };
+
+    // Show typing
+    if ("sendTyping" in msg.channel) {
+      await msg.channel.sendTyping().catch((err) => {
+        logger.warn("Discord sendTyping failed", { error: err.message });
+      });
+    }
+
+    await router.handleMessage(message, async (replyText: string) => {
+      const chunks = splitMessage(replyText, 1900);
+      for (const chunk of chunks) {
+        await msg.reply(chunk).catch(async () => {
+          // If reply fails, try channel.send
+          if ("send" in msg.channel) {
+            await (msg.channel as any).send(chunk).catch((err: any) => {
+              logger.error("Discord send failed", { error: err.message });
+            });
+          }
+        });
+      }
+    });
+  });
+
+  client.on("error", (err) => {
+    logger.error("Discord client error", { error: err.message });
+  });
+
+  return {
+    channelName: "discord",
+
+    start() {
+      client.login(token).then(() => {
+        logger.info(`Discord bot ${client.user?.tag} started`);
+      });
+    },
+
+    stop() {
+      client.destroy();
+    },
+
+    async sendMessage(sessionKey: string, text: string) {
+      const channelId = channelIds.get(sessionKey);
+      if (!channelId) {
+        logger.warn("No Discord channel ID for session", { sessionKey });
+        return;
+      }
+      try {
+        const channel = await client.channels.fetch(channelId);
+        if (channel && "send" in channel) {
+          const chunks = splitMessage(text, 1900);
+          for (const chunk of chunks) {
+            await (channel as any).send(chunk);
+          }
+        }
+      } catch (err: any) {
+        logger.error("Discord proactive send failed", { error: err.message });
+      }
+    },
+  };
+}
+

package/src/channels/optional-deps.d.ts

@@ -0,0 +1,17 @@
+// Type declarations for optional channel dependencies.
+// These modules are dynamically imported and gracefully handle missing packages.
+declare module "@slack/bolt" {
+  export class App {
+    constructor(options: any);
+    message(handler: (args: any) => Promise<void>): void;
+    event(name: string, handler: (args: any) => Promise<void>): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+  }
+}
+
+declare module "@whiskeysockets/baileys" {
+  export default function makeWASocket(options: any): any;
+  export function useMultiFileAuthState(path: string): Promise<{ state: any; saveCreds: () => Promise<void> }>;
+  export const DisconnectReason: { loggedOut: number };
+}

package/src/channels/router.ts

@@ -0,0 +1,199 @@
+import type { LlmProvider } from "../llm/provider";
+import type { InboundMessage, ChannelAdapter } from "./adapter";
+import { agentLoop, agentLoopStream, type StreamCallbacks } from "../agent/loop";
+import { searchMemory } from "../memory/engine";
+import { logger } from "../util/logger";
+import { recordError } from "../util/error-buffer";
+import { Database } from "bun:sqlite";
+
+/** Check if budget has been exceeded. Returns an error message if paused, null if OK. */
+function checkBudget(db: Database): string | null {
+  try {
+    const config = db.query("SELECT daily_limit_usd, monthly_limit_usd, paused FROM budget_config WHERE id = 1").get() as {
+      daily_limit_usd: number | null;
+      monthly_limit_usd: number | null;
+      paused: number;
+    } | null;
+    if (!config) return null;
+    if (config.paused) return "Budget exceeded — agent is paused. Adjust your budget limits in the dashboard to resume.";
+
+    if (config.daily_limit_usd) {
+      const daily = db.query(
+        "SELECT COALESCE(SUM(cost_usd), 0) as total FROM usage WHERE date(created_at) = date('now') AND cost_usd IS NOT NULL"
+      ).get() as { total: number };
+      if (daily.total >= config.daily_limit_usd) {
+        db.run("UPDATE budget_config SET paused = 1 WHERE id = 1");
+        return `Daily budget limit ($${config.daily_limit_usd.toFixed(2)}) reached. Agent paused.`;
+      }
+    }
+
+    if (config.monthly_limit_usd) {
+      const monthly = db.query(
+        "SELECT COALESCE(SUM(cost_usd), 0) as total FROM usage WHERE created_at >= datetime('now', 'start of month') AND cost_usd IS NOT NULL"
+      ).get() as { total: number };
+      if (monthly.total >= config.monthly_limit_usd) {
+        db.run("UPDATE budget_config SET paused = 1 WHERE id = 1");
+        return `Monthly budget limit ($${config.monthly_limit_usd.toFixed(2)}) reached. Agent paused.`;
+      }
+    }
+  } catch {
+    // Budget table may not exist yet — allow through
+  }
+  return null;
+}
+
+/** All channels share one session file since Zubo is a single-owner agent. */
+const UNIFIED_SESSION = "owner";
+
+export interface MessageRouter {
+  handleMessage(
+    message: InboundMessage,
+    reply: (text: string) => Promise<void>
+  ): Promise<void>;
+  handleMessageStream?(
+    message: InboundMessage,
+    onDelta: (text: string) => void,
+    onToolStart?: (name: string) => void,
+    onToolEnd?: (name: string) => void,
+  ): Promise<string>;
+  sendProactive(sessionKey: string, task: string): Promise<string>;
+  broadcastProactive?(message: string): Promise<void>;
+  addAdapter(adapter: ChannelAdapter): void;
+  /** @deprecated Use addAdapter instead */
+  setAdapter(adapter: ChannelAdapter): void;
+  stopAll(): void;
+}
+
+export function createRouter(
+  llm: LlmProvider,
+  db: Database
+): MessageRouter {
+  const adapters = new Map<string, ChannelAdapter>();
+
+  function getAdapterForSession(sessionKey: string): ChannelAdapter | null {
+    const channel = sessionKey.split(":")[0];
+    return adapters.get(channel) ?? null;
+  }
+
+  return {
+    addAdapter(adapter: ChannelAdapter) {
+      adapters.set(adapter.channelName, adapter);
+    },
+
+    // Backward compat
+    setAdapter(adapter: ChannelAdapter) {
+      adapters.set(adapter.channelName, adapter);
+    },
+
+    stopAll() {
+      for (const adapter of adapters.values()) {
+        adapter.stop();
+      }
+    },
+
+    async handleMessage(message, reply) {
+      const { sessionKey, text } = message;
+
+      logger.info(`Message from ${message.channel}:${message.userId}`, {
+        sessionKey,
+      });
+
+      // Budget enforcement
+      const budgetError = checkBudget(db);
+      if (budgetError) {
+        await reply(budgetError);
+        return;
+      }
+
+      try {
+        // Search memory for relevant context
+        let memories = "";
+        try {
+          const results = searchMemory(db, text, 3);
+          if (results.length > 0) {
+            memories = results.map((r) => r.content).join("\n\n");
+          }
+        } catch (err: any) {
+          if (!err.message?.includes("no such table")) {
+            logger.warn("Memory search failed", { error: err.message });
+          }
+        }
+
+        const result = await agentLoop(llm, UNIFIED_SESSION, text, memories);
+        if (result.reply) {
+          await reply(result.reply);
+        }
+      } catch (err: any) {
+        logger.error("Agent loop error", { error: err.message });
+        recordError("agent-loop", err.message);
+        await reply("Sorry, I encountered an error. Please try again.");
+      }
+    },
+
+    async handleMessageStream(message, onDelta, onToolStart?, onToolEnd?) {
+      const { text } = message;
+
+      logger.info(`Stream message from ${message.channel}:${message.userId}`);
+
+      // Budget enforcement
+      const budgetError = checkBudget(db);
+      if (budgetError) {
+        onDelta(budgetError);
+        return budgetError;
+      }
+
+      let memories = "";
+      try {
+        const results = searchMemory(db, text, 3);
+        if (results.length > 0) {
+          memories = results.map((r) => r.content).join("\n\n");
+        }
+      } catch (err: any) {
+        if (!err.message?.includes("no such table")) {
+          logger.warn("Memory search failed", { error: err.message });
+        }
+      }
+
+      return new Promise<string>((resolve, reject) => {
+        agentLoopStream(
+          llm,
+          UNIFIED_SESSION,
+          text,
+          {
+            onTextDelta: onDelta,
+            onToolStart: onToolStart ? (name) => onToolStart(name) : undefined,
+            onToolEnd: onToolEnd ? (name) => onToolEnd(name) : undefined,
+            onDone: (result) => resolve(result.reply),
+            onError: (err) => reject(err),
+          },
+          memories
+        );
+      });
+    },
+
+    async sendProactive(sessionKey, task) {
+      try {
+        const result = await agentLoop(llm, UNIFIED_SESSION, task);
+        const adapter = getAdapterForSession(sessionKey);
+        if (adapter && result.reply) {
+          await adapter.sendMessage(sessionKey, result.reply);
+        }
+        return result.reply;
+      } catch (err: any) {
+        logger.error("Proactive message error", { error: err.message });
+        return "";
+      }
+    },
+
+    async broadcastProactive(message) {
+      for (const [name, adapter] of adapters) {
+        try {
+          // Use a generic session key for each channel
+          await adapter.sendMessage(`${name}:owner`, message);
+        } catch (err: any) {
+          logger.warn(`Failed to broadcast to ${name}`, { error: err.message });
+        }
+      }
+    },
+  };
+}

package/src/channels/signal.ts

@@ -0,0 +1,133 @@
+import type { ChannelAdapter, InboundMessage } from "./adapter";
+import type { MessageRouter } from "./router";
+import { splitMessage } from "./utils";
+import { logger } from "../util/logger";
+
+export function createSignalAdapter(
+  phoneNumber: string,
+  allowedNumbers: string[],
+  signalCliPath: string | undefined,
+  router: MessageRouter
+): ChannelAdapter {
+  let proc: any = null;
+  // Validate CLI path — reject shell metacharacters to prevent command injection
+  const rawCliPath = signalCliPath ?? "signal-cli";
+  if (/[;&|`$]/.test(rawCliPath)) {
+    throw new Error("Invalid signal-cli path: shell metacharacters not allowed");
+  }
+  const cliPath = rawCliPath;
+
+  return {
+    channelName: "signal",
+
+    start() {
+      try {
+        const child = Bun.spawn(
+          [cliPath, "-u", phoneNumber, "jsonRpc"],
+          {
+            stdin: "pipe",
+            stdout: "pipe",
+            stderr: "pipe",
+          }
+        );
+        proc = child;
+
+        const reader = child.stdout.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+
+        (async () => {
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              buffer += decoder.decode(value, { stream: true });
+              const lines = buffer.split("\n");
+              buffer = lines.pop() ?? "";
+
+              for (const line of lines) {
+                if (!line.trim()) continue;
+                try {
+                  const msg = JSON.parse(line);
+                  if (msg.method === "receive") {
+                    const envelope = msg.params?.envelope;
+                    if (!envelope?.dataMessage?.message) continue;
+
+                    const sender = envelope.source;
+                    const text = envelope.dataMessage.message;
+
+                    // Auto-pair
+                    if (allowedNumbers.length === 0) {
+                      allowedNumbers.push(sender);
+                      logger.info(`Auto-registered Signal number: ${sender}`);
+                    }
+
+                    if (allowedNumbers.length > 0 && !allowedNumbers.includes(sender)) continue;
+
+                    const sessionKey = `signal:${sender}`;
+                    const inbound: InboundMessage = {
+                      channel: "signal",
+                      userId: sender,
+                      sessionKey,
+                      text,
+                    };
+
+                    await router.handleMessage(inbound, async (reply) => {
+                      const chunks = splitMessage(reply, 4000);
+                      for (const chunk of chunks) {
+                        sendSignalMessage(child, phoneNumber, sender, chunk);
+                      }
+                    });
+                  }
+                } catch (err: any) {
+                  logger.warn("Failed to parse Signal message", { error: (err as Error).message });
+                }
+              }
+            }
+          } catch (err: any) {
+            logger.error("Signal read error", { error: err.message });
+          }
+        })();
+
+        logger.info("Signal adapter started via signal-cli JSON-RPC");
+      } catch (err: any) {
+        logger.error("Failed to start Signal adapter — ensure signal-cli is installed", { error: err.message });
+      }
+    },
+
+    stop() {
+      if (proc) {
+        proc.kill();
+        proc = null;
+      }
+    },
+
+    async sendMessage(sessionKey: string, text: string) {
+      if (!proc) return;
+      const number = sessionKey.split(":")[1];
+      if (!number) return;
+      const chunks = splitMessage(text, 4000);
+      for (const chunk of chunks) {
+        sendSignalMessage(proc, phoneNumber, number, chunk);
+      }
+    },
+  };
+}
+
+function sendSignalMessage(proc: any, from: string, to: string, text: string) {
+  const rpcMsg = JSON.stringify({
+    jsonrpc: "2.0",
+    method: "send",
+    id: Date.now().toString(),
+    params: {
+      recipient: [to],
+      message: text,
+    },
+  }) + "\n";
+
+  try {
+    proc.stdin.write(rpcMsg);
+  } catch (err: any) {
+    logger.error("Signal send failed", { error: err.message });
+  }
+}

package/src/channels/slack.ts

@@ -0,0 +1,101 @@
+import type { ChannelAdapter, InboundMessage } from "./adapter";
+import type { MessageRouter } from "./router";
+import { splitMessage } from "./utils";
+import { logger } from "../util/logger";
+
+export function createSlackAdapter(
+  botToken: string,
+  appToken: string,
+  allowedUsers: string[],
+  router: MessageRouter
+): ChannelAdapter {
+  let app: any = null;
+
+  return {
+    channelName: "slack",
+
+    start() {
+      import("@slack/bolt").then(({ App }) => {
+        app = new App({
+          token: botToken,
+          appToken: appToken,
+          socketMode: true,
+        });
+
+        app.message(async ({ message, say }: any) => {
+          if (message.subtype) return;
+          const userId = message.user;
+
+          // Auto-pair first user
+          if (allowedUsers.length === 0) {
+            allowedUsers.push(userId);
+            logger.info(`Auto-registered Slack user: ${userId}`);
+            await say("Welcome! You've been registered as the owner of this Zubo agent.");
+          }
+
+          if (allowedUsers.length > 0 && !allowedUsers.includes(userId)) {
+            return;
+          }
+
+          const sessionKey = `slack:${userId}`;
+          const inbound: InboundMessage = {
+            channel: "slack",
+            userId,
+            sessionKey,
+            text: message.text || "",
+          };
+
+          await router.handleMessage(inbound, async (reply) => {
+            const chunks = splitMessage(reply, 3000);
+            for (const chunk of chunks) {
+              await say(chunk);
+            }
+          });
+        });
+
+        app.event("app_mention", async ({ event, say }: any) => {
+          const userId = event.user;
+          if (allowedUsers.length > 0 && !allowedUsers.includes(userId)) return;
+
+          const text = event.text.replace(/<@[^>]+>/g, "").trim();
+          if (!text) return;
+
+          const sessionKey = `slack:${userId}`;
+          const inbound: InboundMessage = {
+            channel: "slack",
+            userId,
+            sessionKey,
+            text,
+          };
+
+          await router.handleMessage(inbound, async (reply) => {
+            const chunks = splitMessage(reply, 3000);
+            for (const chunk of chunks) {
+              await say(chunk);
+            }
+          });
+        });
+
+        app.start().then(() => {
+          logger.info("Slack adapter started (Socket Mode)");
+        });
+      }).catch((err: any) => {
+        logger.error("Failed to start Slack adapter — install @slack/bolt", { error: err.message });
+      });
+    },
+
+    stop() {
+      if (app) {
+        app.stop().catch((err: any) => {
+          logger.warn("Slack app stop failed", { error: err.message });
+        });
+        app = null;
+      }
+    },
+
+    async sendMessage(sessionKey: string, text: string) {
+      // For proactive messages we'd need channel IDs; skip for now
+      logger.debug("Slack proactive message (not delivered via DM)", { text: text.slice(0, 100) });
+    },
+  };
+}

package/src/channels/telegram.ts

@@ -0,0 +1,102 @@
+import { Bot } from "grammy";
+import type { ChannelAdapter, InboundMessage } from "./adapter";
+import type { MessageRouter } from "./router";
+import type { ZuboConfig } from "../config/schema";
+import { saveConfig } from "../config/loader";
+import { splitMessage } from "./utils";
+import { logger } from "../util/logger";
+
+export function createTelegramAdapter(
+  token: string,
+  config: ZuboConfig,
+  router: MessageRouter
+): ChannelAdapter {
+  const bot = new Bot(token);
+
+  // Map session keys to chat IDs for proactive messaging
+  const chatIds = new Map<string, number>();
+
+  // Pre-populate chat IDs from config (for proactive messaging after restart).
+  // For DMs, chat ID equals user ID.
+  for (const userId of config.telegramAllowedUsers) {
+    chatIds.set(`telegram:${userId}`, userId);
+  }
+
+  bot.on("message:text", async (ctx) => {
+    const userId = ctx.from.id;
+    const chatId = ctx.chat.id;
+    const text = ctx.message.text;
+
+    // Auto-pair: first user to message gets registered
+    if (config.telegramAllowedUsers.length === 0) {
+      config.telegramAllowedUsers.push(userId);
+      await saveConfig(config);
+      logger.info(`Auto-registered Telegram user: ${userId}`);
+      await ctx.reply(
+        "Welcome! You've been registered as the owner of this Zubo agent."
+      );
+    }
+
+    // Access control
+    if (!config.telegramAllowedUsers.includes(userId)) {
+      await ctx.reply("Sorry, you're not authorized to use this bot.");
+      return;
+    }
+
+    const sessionKey = `telegram:${userId}`;
+    chatIds.set(sessionKey, chatId);
+
+    const message: InboundMessage = {
+      channel: "telegram",
+      userId: String(userId),
+      sessionKey,
+      text,
+    };
+
+    // Show typing indicator
+    await ctx.replyWithChatAction("typing");
+
+    await router.handleMessage(message, async (replyText: string) => {
+      // Split long messages (Telegram 4096 char limit)
+      const chunks = splitMessage(replyText, 4000);
+      for (const chunk of chunks) {
+        await ctx.reply(chunk, { parse_mode: "Markdown" }).catch(async () => {
+          // Fallback without markdown if parsing fails
+          await ctx.reply(chunk);
+        });
+      }
+    });
+  });
+
+  bot.catch((err) => {
+    logger.error("Telegram bot error", { error: err.message });
+  });
+
+  return {
+    channelName: "telegram",
+    start() {
+      bot.start({
+        onStart: (info) => {
+          logger.info(`Telegram bot @${info.username} started`);
+        },
+      });
+    },
+    stop() {
+      bot.stop();
+    },
+    async sendMessage(sessionKey: string, text: string) {
+      const chatId = chatIds.get(sessionKey);
+      if (chatId) {
+        const chunks = splitMessage(text, 4000);
+        for (const chunk of chunks) {
+          await bot.api.sendMessage(chatId, chunk).catch((err) => {
+            logger.error("Failed to send Telegram message", { error: err.message });
+          });
+        }
+      } else {
+        logger.warn("No chat ID for session key", { sessionKey });
+      }
+    },
+  };
+}
+