thepopebot 1.1.2 → 1.2.3

package/lib/channels/telegram.js

@@ -0,0 +1,146 @@
+import { ChannelAdapter } from './base.js';
+import {
+  sendMessage,
+  downloadFile,
+  reactToMessage,
+  startTypingIndicator,
+} from '../tools/telegram.js';
+import { isWhisperEnabled, transcribeAudio } from '../tools/openai.js';
+
+class TelegramAdapter extends ChannelAdapter {
+  constructor(botToken) {
+    super();
+    this.botToken = botToken;
+  }
+
+  /**
+   * Parse a Telegram webhook update into normalized message data.
+   * Handles: text, voice/audio (transcribed), photos, documents.
+   * Returns null if the update should be ignored.
+   */
+  async receive(request) {
+    const { TELEGRAM_WEBHOOK_SECRET, TELEGRAM_CHAT_ID, TELEGRAM_VERIFICATION } = process.env;
+
+    // Validate secret token if configured
+    if (TELEGRAM_WEBHOOK_SECRET) {
+      const headerSecret = request.headers.get('x-telegram-bot-api-secret-token');
+      if (headerSecret !== TELEGRAM_WEBHOOK_SECRET) {
+        return null;
+      }
+    }
+
+    const update = await request.json();
+    const message = update.message || update.edited_message;
+
+    if (!message || !message.chat || !this.botToken) return null;
+
+    const chatId = String(message.chat.id);
+    let text = message.text || null;
+    const attachments = [];
+
+    // Check for verification code — works even before TELEGRAM_CHAT_ID is set
+    if (TELEGRAM_VERIFICATION && text === TELEGRAM_VERIFICATION) {
+      await sendMessage(this.botToken, chatId, `Your chat ID:\n<code>${chatId}</code>`);
+      return null;
+    }
+
+    // Security: if no TELEGRAM_CHAT_ID configured, ignore all messages
+    if (!TELEGRAM_CHAT_ID) return null;
+
+    // Security: only accept messages from configured chat
+    if (chatId !== TELEGRAM_CHAT_ID) return null;
+
+    // Voice messages → transcribe to text
+    if (message.voice) {
+      if (!isWhisperEnabled()) {
+        await sendMessage(
+          this.botToken,
+          chatId,
+          'Voice messages are not supported. Please set OPENAI_API_KEY to enable transcription.'
+        );
+        return null;
+      }
+      try {
+        const { buffer, filename } = await downloadFile(this.botToken, message.voice.file_id);
+        text = await transcribeAudio(buffer, filename);
+      } catch (err) {
+        console.error('Failed to transcribe voice:', err);
+        await sendMessage(this.botToken, chatId, 'Sorry, I could not transcribe your voice message.');
+        return null;
+      }
+    }
+
+    // Audio messages → transcribe to text
+    if (message.audio && !text) {
+      if (!isWhisperEnabled()) {
+        await sendMessage(
+          this.botToken,
+          chatId,
+          'Audio messages are not supported. Please set OPENAI_API_KEY to enable transcription.'
+        );
+        return null;
+      }
+      try {
+        const { buffer, filename } = await downloadFile(this.botToken, message.audio.file_id);
+        text = await transcribeAudio(buffer, filename);
+      } catch (err) {
+        console.error('Failed to transcribe audio:', err);
+        await sendMessage(this.botToken, chatId, 'Sorry, I could not transcribe your audio message.');
+        return null;
+      }
+    }
+
+    // Photo → download largest size, add as image attachment
+    if (message.photo && message.photo.length > 0) {
+      try {
+        const largest = message.photo[message.photo.length - 1];
+        const { buffer } = await downloadFile(this.botToken, largest.file_id);
+        attachments.push({ category: 'image', mimeType: 'image/jpeg', data: buffer });
+        // Use caption as text if no text yet
+        if (!text && message.caption) text = message.caption;
+      } catch (err) {
+        console.error('Failed to download photo:', err);
+      }
+    }
+
+    // Document → download, add as document attachment
+    if (message.document) {
+      try {
+        const { buffer, filename } = await downloadFile(this.botToken, message.document.file_id);
+        const mimeType = message.document.mime_type || 'application/octet-stream';
+        attachments.push({ category: 'document', mimeType, data: buffer });
+        if (!text && message.caption) text = message.caption;
+      } catch (err) {
+        console.error('Failed to download document:', err);
+      }
+    }
+
+    // Nothing actionable
+    if (!text && attachments.length === 0) return null;
+
+    return {
+      threadId: chatId,
+      text: text || '',
+      attachments,
+      metadata: { messageId: message.message_id, chatId },
+    };
+  }
+
+  async acknowledge(metadata) {
+    await reactToMessage(this.botToken, metadata.chatId, metadata.messageId).catch(() => {});
+  }
+
+  startProcessingIndicator(metadata) {
+    return startTypingIndicator(this.botToken, metadata.chatId);
+  }
+
+  async sendResponse(threadId, text, metadata) {
+    await sendMessage(this.botToken, threadId, text);
+  }
+
+  get supportsStreaming() {
+    return false;
+  }
+}
+
+export { TelegramAdapter };

package/lib/chat/actions.js

@@ -0,0 +1,239 @@
+'use server';
+
+import { auth } from '../auth/index.js';
+import {
+  createChat as dbCreateChat,
+  getChatById,
+  getMessagesByChatId,
+  deleteChat as dbDeleteChat,
+  deleteAllChatsByUser,
+} from '../db/chats.js';
+import {
+  getNotifications as dbGetNotifications,
+  getUnreadCount as dbGetUnreadCount,
+  markAllRead as dbMarkAllRead,
+} from '../db/notifications.js';
+
+/**
+ * Get the authenticated user or throw.
+ */
+async function requireAuth() {
+  const session = await auth();
+  if (!session?.user?.id) {
+    throw new Error('Unauthorized');
+  }
+  return session.user;
+}
+
+/**
+ * Get all chats for the authenticated user (includes Telegram chats).
+ * @returns {Promise<object[]>}
+ */
+export async function getChats() {
+  const user = await requireAuth();
+  const { or, eq, desc } = await import('drizzle-orm');
+  const { getDb } = await import('../db/index.js');
+  const { chats } = await import('../db/schema.js');
+  const db = getDb();
+  return db
+    .select()
+    .from(chats)
+    .where(or(eq(chats.userId, user.id), eq(chats.userId, 'telegram')))
+    .orderBy(desc(chats.updatedAt))
+    .all();
+}
+
+/**
+ * Get messages for a specific chat (with ownership check).
+ * @param {string} chatId
+ * @returns {Promise<object[]>}
+ */
+export async function getChatMessages(chatId) {
+  const user = await requireAuth();
+  const chat = getChatById(chatId);
+  if (!chat || (chat.userId !== user.id && chat.userId !== 'telegram')) {
+    return [];
+  }
+  return getMessagesByChatId(chatId);
+}
+
+/**
+ * Create a new chat.
+ * @param {string} [id] - Optional chat ID
+ * @param {string} [title='New Chat']
+ * @returns {Promise<object>}
+ */
+export async function createChat(id, title = 'New Chat') {
+  const user = await requireAuth();
+  return dbCreateChat(user.id, title, id);
+}
+
+/**
+ * Delete a chat (with ownership check).
+ * @param {string} chatId
+ * @returns {Promise<{success: boolean}>}
+ */
+export async function deleteChat(chatId) {
+  const user = await requireAuth();
+  const chat = getChatById(chatId);
+  if (!chat || chat.userId !== user.id) {
+    return { success: false };
+  }
+  dbDeleteChat(chatId);
+  return { success: true };
+}
+
+/**
+ * Delete all chats for the authenticated user.
+ * @returns {Promise<{success: boolean}>}
+ */
+export async function deleteAllChats() {
+  const user = await requireAuth();
+  deleteAllChatsByUser(user.id);
+  return { success: true };
+}
+
+/**
+ * Get all notifications, newest first.
+ * @returns {Promise<object[]>}
+ */
+export async function getNotifications() {
+  await requireAuth();
+  return dbGetNotifications();
+}
+
+/**
+ * Get count of unread notifications.
+ * @returns {Promise<number>}
+ */
+export async function getUnreadNotificationCount() {
+  await requireAuth();
+  return dbGetUnreadCount();
+}
+
+/**
+ * Mark all notifications as read.
+ * @returns {Promise<{success: boolean}>}
+ */
+export async function markNotificationsRead() {
+  await requireAuth();
+  dbMarkAllRead();
+  return { success: true };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// API Key actions
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Create (or replace) the API key.
+ * @returns {Promise<{ key: string, record: object } | { error: string }>}
+ */
+export async function createNewApiKey() {
+  const user = await requireAuth();
+  try {
+    const { createApiKeyRecord } = await import('../db/api-keys.js');
+    return createApiKeyRecord(user.id);
+  } catch (err) {
+    console.error('Failed to create API key:', err);
+    return { error: 'Failed to create API key' };
+  }
+}
+
+/**
+ * Get the current API key metadata (no hash).
+ * @returns {Promise<object|null>}
+ */
+export async function getApiKeys() {
+  await requireAuth();
+  try {
+    const { getApiKey } = await import('../db/api-keys.js');
+    return getApiKey();
+  } catch (err) {
+    console.error('Failed to get API key:', err);
+    return null;
+  }
+}
+
+/**
+ * Delete the API key.
+ * @returns {Promise<{ success: boolean } | { error: string }>}
+ */
+export async function deleteApiKey() {
+  await requireAuth();
+  try {
+    const mod = await import('../db/api-keys.js');
+    mod.deleteApiKey();
+    return { success: true };
+  } catch (err) {
+    console.error('Failed to delete API key:', err);
+    return { error: 'Failed to delete API key' };
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Swarm actions
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Get swarm status (active + completed jobs with counts).
+ * @returns {Promise<object>}
+ */
+export async function getSwarmStatus() {
+  await requireAuth();
+  try {
+    const { getSwarmStatus: fetchStatus } = await import('../tools/github.js');
+    return await fetchStatus();
+  } catch (err) {
+    console.error('Failed to get swarm status:', err);
+    return { error: 'Failed to get swarm status', active: [], completed: [], counts: { running: 0, queued: 0, succeeded: 0, failed: 0 } };
+  }
+}
+
+/**
+ * Get swarm config (crons + triggers).
+ * @returns {Promise<{ crons: object[], triggers: object[] }>}
+ */
+export async function getSwarmConfig() {
+  await requireAuth();
+  const { cronsFile, triggersFile } = await import('../paths.js');
+  const fs = await import('fs');
+  let crons = [];
+  let triggers = [];
+  try { crons = JSON.parse(fs.readFileSync(cronsFile, 'utf8')); } catch {}
+  try { triggers = JSON.parse(fs.readFileSync(triggersFile, 'utf8')); } catch {}
+  return { crons, triggers };
+}
+
+/**
+ * Cancel a running swarm job.
+ * @param {number} runId - Workflow run ID
+ * @returns {Promise<object>}
+ */
+export async function cancelSwarmJob(runId) {
+  await requireAuth();
+  try {
+    const { cancelWorkflowRun } = await import('../tools/github.js');
+    return await cancelWorkflowRun(runId);
+  } catch (err) {
+    console.error('Failed to cancel workflow run:', err);
+    return { error: err.message || 'Failed to cancel workflow run' };
+  }
+}
+
+/**
+ * Rerun a swarm job (all or failed only).
+ * @param {number} runId - Workflow run ID
+ * @param {boolean} [failedOnly=false]
+ * @returns {Promise<object>}
+ */
+export async function rerunSwarmJob(runId, failedOnly = false) {
+  await requireAuth();
+  try {
+    const { rerunWorkflowRun } = await import('../tools/github.js');
+    return await rerunWorkflowRun(runId, !!failedOnly);
+  } catch (err) {
+    console.error('Failed to rerun workflow:', err);
+    return { error: err.message || 'Failed to rerun workflow' };
+  }
+}

package/lib/chat/api.js

@@ -0,0 +1,103 @@
+import { auth } from '../auth/index.js';
+import { chatStream } from '../ai/index.js';
+
+/**
+ * POST handler for /api/chat — streaming chat with session auth.
+ * Dedicated route handler separate from the catch-all api/index.js.
+ */
+export async function POST(request) {
+  const session = await auth();
+  if (!session?.user?.id) {
+    return Response.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
+  const body = await request.json();
+  const { messages, chatId: rawChatId } = body;
+
+  if (!messages?.length) {
+    return Response.json({ error: 'No messages' }, { status: 400 });
+  }
+
+  // Get the last user message — AI SDK v5 sends UIMessage[] with parts
+  const lastUserMessage = [...messages].reverse().find((m) => m.role === 'user');
+  if (!lastUserMessage) {
+    return Response.json({ error: 'No user message' }, { status: 400 });
+  }
+
+  // Extract text from message parts (AI SDK v5+) or fall back to content
+  let userText =
+    lastUserMessage.parts
+      ?.filter((p) => p.type === 'text')
+      .map((p) => p.text)
+      .join('\n') ||
+    lastUserMessage.content ||
+    '';
+
+  // Extract file parts from message
+  const fileParts = lastUserMessage.parts?.filter((p) => p.type === 'file') || [];
+  const attachments = [];
+
+  for (const part of fileParts) {
+    const { mediaType, url } = part;
+    if (!mediaType || !url) continue;
+
+    if (mediaType.startsWith('image/') || mediaType === 'application/pdf') {
+      // Images and PDFs → pass as visual attachments for the LLM
+      attachments.push({ category: 'image', mimeType: mediaType, dataUrl: url });
+    } else if (mediaType.startsWith('text/') || mediaType === 'application/json') {
+      // Text files → decode base64 data URL and inline into message text
+      try {
+        const base64Data = url.split(',')[1];
+        const textContent = Buffer.from(base64Data, 'base64').toString('utf-8');
+        const fileName = part.name || 'file';
+        userText += `\n\nFile: ${fileName}\n\`\`\`\n${textContent}\n\`\`\``;
+      } catch (e) {
+        console.error('Failed to decode text file:', e);
+      }
+    }
+  }
+
+  if (!userText.trim() && attachments.length === 0) {
+    return Response.json({ error: 'Empty message' }, { status: 400 });
+  }
+
+  // Map web channel to thread_id — AI layer handles DB persistence
+  const threadId = rawChatId || crypto.randomUUID();
+  const { createUIMessageStream, createUIMessageStreamResponse } = await import('ai');
+
+  const stream = createUIMessageStream({
+    onError: (error) => {
+      console.error('Chat stream error:', error);
+      return error?.message || 'An error occurred while processing your message.';
+    },
+    execute: async ({ writer }) => {
+      // chatStream handles: save user msg, invoke agent, save assistant msg, auto-title
+      const chunks = chatStream(threadId, userText, attachments, {
+        userId: session.user.id,
+      });
+
+      // Signal start of assistant message
+      writer.write({ type: 'start' });
+
+      const textId = crypto.randomUUID();
+      let textStarted = false;
+
+      for await (const chunk of chunks) {
+        if (!textStarted) {
+          writer.write({ type: 'text-start', id: textId });
+          textStarted = true;
+        }
+        writer.write({ type: 'text-delta', id: textId, delta: chunk });
+      }
+
+      if (textStarted) {
+        writer.write({ type: 'text-end', id: textId });
+      }
+
+      // Signal end of assistant message
+      writer.write({ type: 'finish' });
+    },
+  });
+
+  return createUIMessageStreamResponse({ stream });
+}

package/lib/chat/components/app-sidebar.js

@@ -0,0 +1,161 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { SquarePenIcon, PanelLeftIcon, MessageIcon, BellIcon, SwarmIcon, ClockIcon, ZapIcon } from "./icons.js";
+import { getUnreadNotificationCount } from "../actions.js";
+import { SidebarHistory } from "./sidebar-history.js";
+import { SidebarUserNav } from "./sidebar-user-nav.js";
+import {
+  Sidebar,
+  SidebarContent,
+  SidebarFooter,
+  SidebarHeader,
+  SidebarGroup,
+  SidebarGroupLabel,
+  SidebarMenu,
+  SidebarMenuItem,
+  SidebarMenuButton,
+  useSidebar
+} from "./ui/sidebar.js";
+import { Tooltip, TooltipContent, TooltipTrigger } from "./ui/tooltip.js";
+import { useChatNav } from "./chat-nav-context.js";
+function AppSidebar({ user }) {
+  const { navigateToChat } = useChatNav();
+  const { state, open, setOpenMobile, toggleSidebar } = useSidebar();
+  const collapsed = state === "collapsed";
+  const [unreadCount, setUnreadCount] = useState(0);
+  useEffect(() => {
+    getUnreadNotificationCount().then((count) => setUnreadCount(count)).catch(() => {
+    });
+  }, []);
+  return /* @__PURE__ */ jsxs(Sidebar, { children: [
+    /* @__PURE__ */ jsxs(SidebarHeader, { children: [
+      /* @__PURE__ */ jsxs("div", { className: collapsed ? "flex justify-center" : "flex items-center justify-between", children: [
+        !collapsed && /* @__PURE__ */ jsx("span", { className: "px-2 font-semibold text-lg", children: "The Pope Bot" }),
+        /* @__PURE__ */ jsxs(Tooltip, { children: [
+          /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+            "button",
+            {
+              className: "inline-flex shrink-0 items-center justify-center rounded-md p-2 text-muted-foreground hover:bg-background hover:text-foreground",
+              onClick: toggleSidebar,
+              children: /* @__PURE__ */ jsx(PanelLeftIcon, { size: 16 })
+            }
+          ) }),
+          /* @__PURE__ */ jsx(TooltipContent, { side: collapsed ? "right" : "bottom", children: collapsed ? "Open sidebar" : "Close sidebar" })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs(SidebarMenu, { children: [
+        /* @__PURE__ */ jsx(SidebarMenuItem, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [
+          /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+            SidebarMenuButton,
+            {
+              className: collapsed ? "justify-center" : "",
+              onClick: () => {
+                navigateToChat(null);
+                setOpenMobile(false);
+              },
+              children: [
+                /* @__PURE__ */ jsx(SquarePenIcon, { size: 16 }),
+                !collapsed && /* @__PURE__ */ jsx("span", { children: "New chat" })
+              ]
+            }
+          ) }),
+          collapsed && /* @__PURE__ */ jsx(TooltipContent, { side: "right", children: "New chat" })
+        ] }) }),
+        /* @__PURE__ */ jsx(SidebarMenuItem, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [
+          /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+            SidebarMenuButton,
+            {
+              className: collapsed ? "justify-center" : "",
+              onClick: () => {
+                window.location.href = "/chats";
+              },
+              children: [
+                /* @__PURE__ */ jsx(MessageIcon, { size: 16 }),
+                !collapsed && /* @__PURE__ */ jsx("span", { children: "Chats" })
+              ]
+            }
+          ) }),
+          collapsed && /* @__PURE__ */ jsx(TooltipContent, { side: "right", children: "Chats" })
+        ] }) }),
+        /* @__PURE__ */ jsx(SidebarMenuItem, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [
+          /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+            SidebarMenuButton,
+            {
+              className: collapsed ? "justify-center" : "",
+              onClick: () => {
+                window.location.href = "/notifications";
+              },
+              children: [
+                /* @__PURE__ */ jsx(BellIcon, { size: 16 }),
+                !collapsed && /* @__PURE__ */ jsxs("span", { className: "flex items-center gap-2", children: [
+                  "Notifications",
+                  unreadCount > 0 && /* @__PURE__ */ jsx("span", { className: "inline-flex items-center justify-center rounded-full bg-destructive px-1.5 py-0.5 text-[10px] font-medium leading-none text-destructive-foreground", children: unreadCount })
+                ] }),
+                collapsed && unreadCount > 0 && /* @__PURE__ */ jsx("span", { className: "absolute -top-1 -right-1 inline-flex h-4 w-4 items-center justify-center rounded-full bg-destructive text-[10px] font-medium text-destructive-foreground", children: unreadCount })
+              ]
+            }
+          ) }),
+          collapsed && /* @__PURE__ */ jsx(TooltipContent, { side: "right", children: "Notifications" })
+        ] }) }),
+        /* @__PURE__ */ jsx(SidebarMenuItem, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [
+          /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+            SidebarMenuButton,
+            {
+              className: collapsed ? "justify-center" : "",
+              onClick: () => {
+                window.location.href = "/swarm";
+              },
+              children: [
+                /* @__PURE__ */ jsx(SwarmIcon, { size: 16 }),
+                !collapsed && /* @__PURE__ */ jsx("span", { children: "Swarm" })
+              ]
+            }
+          ) }),
+          collapsed && /* @__PURE__ */ jsx(TooltipContent, { side: "right", children: "Swarm" })
+        ] }) }),
+        /* @__PURE__ */ jsx(SidebarMenuItem, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [
+          /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+            SidebarMenuButton,
+            {
+              className: collapsed ? "justify-center" : "",
+              onClick: () => {
+                window.location.href = "/crons";
+              },
+              children: [
+                /* @__PURE__ */ jsx(ClockIcon, { size: 16 }),
+                !collapsed && /* @__PURE__ */ jsx("span", { children: "Cron Jobs" })
+              ]
+            }
+          ) }),
+          collapsed && /* @__PURE__ */ jsx(TooltipContent, { side: "right", children: "Cron Jobs" })
+        ] }) }),
+        /* @__PURE__ */ jsx(SidebarMenuItem, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [
+          /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+            SidebarMenuButton,
+            {
+              className: collapsed ? "justify-center" : "",
+              onClick: () => {
+                window.location.href = "/triggers";
+              },
+              children: [
+                /* @__PURE__ */ jsx(ZapIcon, { size: 16 }),
+                !collapsed && /* @__PURE__ */ jsx("span", { children: "Triggers" })
+              ]
+            }
+          ) }),
+          collapsed && /* @__PURE__ */ jsx(TooltipContent, { side: "right", children: "Triggers" })
+        ] }) })
+      ] })
+    ] }),
+    !collapsed && /* @__PURE__ */ jsxs(SidebarContent, { children: [
+      /* @__PURE__ */ jsx(SidebarGroup, { className: "pt-0", children: /* @__PURE__ */ jsx(SidebarGroupLabel, { children: "Chats" }) }),
+      /* @__PURE__ */ jsx(SidebarHistory, {})
+    ] }),
+    collapsed && /* @__PURE__ */ jsx("div", { className: "flex-1" }),
+    /* @__PURE__ */ jsx(SidebarFooter, { children: user && /* @__PURE__ */ jsx(SidebarUserNav, { user, collapsed }) })
+  ] });
+}
+export {
+  AppSidebar
+};