@harbinger-ai/harbinger 0.1.0

package/lib/channels/telegram.js

@@ -0,0 +1,148 @@
+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 (required)
+    if (!TELEGRAM_WEBHOOK_SECRET) {
+      console.error('[telegram] TELEGRAM_WEBHOOK_SECRET not configured — rejecting webhook');
+      return null;
+    }
+    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,288 @@
+'use server';
+
+import { auth } from '../auth/index.js';
+import {
+  createChat as dbCreateChat,
+  getChatById,
+  getMessagesByChatId,
+  deleteChat as dbDeleteChat,
+  deleteAllChatsByUser,
+  updateChatTitle,
+  toggleChatStarred,
+} 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 };
+}
+
+/**
+ * Get the title of a specific chat (with ownership check).
+ * @param {string} chatId
+ * @returns {Promise<string|null>}
+ */
+export async function getChatTitle(chatId) {
+  const user = await requireAuth();
+  const chat = getChatById(chatId);
+  if (!chat || (chat.userId !== user.id && chat.userId !== 'telegram')) {
+    return null;
+  }
+  return chat.title;
+}
+
+/**
+ * Rename a chat (with ownership check).
+ * @param {string} chatId
+ * @param {string} title
+ * @returns {Promise<{success: boolean}>}
+ */
+export async function renameChat(chatId, title) {
+  const user = await requireAuth();
+  const chat = getChatById(chatId);
+  if (!chat || chat.userId !== user.id) {
+    return { success: false };
+  }
+  updateChatTitle(chatId, title);
+  return { success: true };
+}
+
+/**
+ * Toggle a chat's starred status (with ownership check).
+ * @param {string} chatId
+ * @returns {Promise<{success: boolean, starred?: number}>}
+ */
+export async function starChat(chatId) {
+  const user = await requireAuth();
+  const chat = getChatById(chatId);
+  if (!chat || chat.userId !== user.id) {
+    return { success: false };
+  }
+  const starred = toggleChatStarred(chatId);
+  return { success: true, starred };
+}
+
+/**
+ * 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 };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// App info actions
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Get the installed package version and update status (auth-gated, never in client bundle).
+ * @returns {Promise<{ version: string, updateAvailable: string|null }>}
+ */
+export async function getAppVersion() {
+  await requireAuth();
+  const { getInstalledVersion } = await import('../cron.js');
+  const { getAvailableVersion, getReleaseNotes } = await import('../db/update-check.js');
+  return {
+    version: getInstalledVersion(),
+    updateAvailable: getAvailableVersion(),
+    changelog: getReleaseNotes(),
+  };
+}
+
+/**
+ * Trigger the upgrade-event-handler workflow via GitHub Actions.
+ * @returns {Promise<{ success: boolean }>}
+ */
+export async function triggerUpgrade() {
+  await requireAuth();
+  const { triggerWorkflowDispatch } = await import('../tools/github.js');
+  const { getAvailableVersion } = await import('../db/update-check.js');
+  const targetVersion = getAvailableVersion();
+  await triggerWorkflowDispatch('upgrade-event-handler.yml', 'main', {
+    target_version: targetVersion || '',
+  });
+  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(page = 1) {
+  await requireAuth();
+  try {
+    const { getSwarmStatus: fetchStatus } = await import('../tools/github.js');
+    return await fetchStatus(page);
+  } catch (err) {
+    console.error('Failed to get swarm status:', err);
+    return { error: 'Failed to get swarm status', runs: [], hasMore: false };
+  }
+}
+
+/**
+ * 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 };
+}
+

package/lib/chat/api.js

@@ -0,0 +1,135 @@
+import { auth } from '../auth/index.js';
+import { chatStream } from '../ai/index.js';
+import { v4 as uuidv4 } from 'uuid';
+
+/**
+ * POST handler for /stream/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, trigger } = 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 || uuidv4();
+  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 skipUserPersist = trigger === 'regenerate-message';
+      const chunks = chatStream(threadId, userText, attachments, {
+        userId: session.user.id,
+        skipUserPersist,
+      });
+
+      // Signal start of assistant message
+      writer.write({ type: 'start' });
+
+      let textStarted = false;
+      let textId = uuidv4();
+
+      for await (const chunk of chunks) {
+        if (chunk.type === 'text') {
+          if (!textStarted) {
+            textId = uuidv4();
+            writer.write({ type: 'text-start', id: textId });
+            textStarted = true;
+          }
+          writer.write({ type: 'text-delta', id: textId, delta: chunk.text });
+
+        } else if (chunk.type === 'tool-call') {
+          // Close any open text block before tool events
+          if (textStarted) {
+            writer.write({ type: 'text-end', id: textId });
+            textStarted = false;
+          }
+          writer.write({
+            type: 'tool-input-start',
+            toolCallId: chunk.toolCallId,
+            toolName: chunk.toolName,
+          });
+          writer.write({
+            type: 'tool-input-available',
+            toolCallId: chunk.toolCallId,
+            toolName: chunk.toolName,
+            input: chunk.args,
+          });
+
+        } else if (chunk.type === 'tool-result') {
+          writer.write({
+            type: 'tool-output-available',
+            toolCallId: chunk.toolCallId,
+            output: chunk.result,
+          });
+        }
+      }
+
+      // Close final text block if still open
+      if (textStarted) {
+        writer.write({ type: 'text-end', id: textId });
+      }
+
+      // Signal end of assistant message
+      writer.write({ type: 'finish' });
+    },
+  });
+
+  return createUIMessageStreamResponse({ stream });
+}