cognova 0.2.8 → 0.2.10

package/server/api/conversations/index.get.ts

@@ -8,9 +8,10 @@ export default defineEventHandler(async (event) => {
 
   const db = getDb()
 
+  // Main Chat always first, then by most recent
   const conversations = await db.select()
     .from(schema.conversations)
-    .orderBy(desc(schema.conversations.startedAt))
+    .orderBy(desc(schema.conversations.isMain), desc(schema.conversations.startedAt))
     .limit(50)
 
   return { data: conversations }

package/server/api/usage/stats.get.ts

@@ -71,6 +71,7 @@ export default defineEventHandler(async (event) => {
       chat: 0,
       agent: 0,
       memory: 0,
+      bridge: 0,
       totalCost: 0,
       inputTokens: 0,
       outputTokens: 0,
@@ -83,6 +84,7 @@ export default defineEventHandler(async (event) => {
     if (r.source === 'chat') existing.chat += r.costUsd
     else if (r.source === 'agent') existing.agent += r.costUsd
     else if (r.source === 'memory_extraction') existing.memory += r.costUsd
+    else if (r.source === 'bridge') existing.bridge += r.costUsd
     bucketMap.set(bucket, existing)
 
     // By source

package/server/bridge/adapters/telegram.ts

@@ -56,10 +56,11 @@ interface TelegramDocument {
 }
 
 /**
- * Telegram adapter using the Bot API webhook mode.
+ * Telegram adapter supporting both webhook and long-polling modes.
+ *
+ * - If a public APP_URL is configured, registers a webhook with Telegram.
+ * - Otherwise, falls back to long-polling via getUpdates.
  *
- * When started, registers a webhook with Telegram so they push updates to us.
- * When stopped, removes the webhook.
  * Messages are sent via the Bot API sendMessage endpoint.
  */
 export class TelegramAdapter implements BridgeAdapter {
@@ -70,6 +71,9 @@ export class TelegramAdapter implements BridgeAdapter {
   private botToken: string | null = null
   private webhookSecret: string
   private healthy = false
+  private polling = false
+  private pollAbort: AbortController | null = null
+  private pollOffset = 0
 
   constructor(
     bridgeId: string,
@@ -92,6 +96,11 @@ export class TelegramAdapter implements BridgeAdapter {
       throw new Error('TELEGRAM_BOT_TOKEN secret not found. Add it in Settings → Secrets.')
     }
 
+    // Also check for APP_URL in secrets store (set via Settings → App)
+    const appUrlSecret = await getSecretValue('APP_URL')
+    if (appUrlSecret && !process.env.APP_URL)
+      process.env.APP_URL = appUrlSecret
+
     // Validate token by calling getMe
     const me = await this.apiCall('getMe')
     if (!me.ok) {
@@ -105,7 +114,7 @@ export class TelegramAdapter implements BridgeAdapter {
 
     console.log(`[telegram] Bot @${me.result?.username} authenticated`)
 
-    // Register webhook
+    // Register webhook or start polling
     const webhookUrl = this.getWebhookUrl()
     if (webhookUrl) {
       const setResult = await this.apiCall('setWebhook', {
@@ -120,13 +129,19 @@ export class TelegramAdapter implements BridgeAdapter {
 
       console.log(`[telegram] Webhook registered: ${webhookUrl}`)
     } else {
-      console.log('[telegram] No webhook URL configured — using polling or manual webhook setup')
+      // Delete any existing webhook before polling (Telegram requires this)
+      await this.apiCall('deleteWebhook')
+      console.log('[telegram] No public URL configured — starting long-polling')
+      this.startPolling()
     }
 
     this.healthy = true
   }
 
   async stop(): Promise<void> {
+    // Stop polling loop if running
+    this.stopPolling()
+
     if (this.botToken) {
       try {
         await this.apiCall('deleteWebhook')
@@ -238,6 +253,54 @@ export class TelegramAdapter implements BridgeAdapter {
     return headerValue === this.webhookSecret
   }
 
+  // ─── Polling ─────────────────────────────────────
+
+  private startPolling(): void {
+    this.polling = true
+    this.pollAbort = new AbortController()
+    void this.pollLoop()
+  }
+
+  private stopPolling(): void {
+    this.polling = false
+    if (this.pollAbort) {
+      this.pollAbort.abort()
+      this.pollAbort = null
+    }
+  }
+
+  private async pollLoop(): Promise<void> {
+    while (this.polling && this.botToken) {
+      try {
+        const result = await this.apiCall('getUpdates', {
+          offset: this.pollOffset,
+          timeout: 30,
+          allowed_updates: ['message', 'edited_message']
+        }, this.pollAbort?.signal)
+
+        if (!this.polling) break
+
+        if (result.ok && Array.isArray(result.result)) {
+          for (const update of result.result as TelegramUpdate[]) {
+            this.pollOffset = update.update_id + 1
+            await this.handleUpdate(update).catch((error: unknown) => {
+              console.error('[telegram] Error handling polled update:', error)
+            })
+          }
+        } else if (!result.ok) {
+          console.error('[telegram] Polling error:', result.description)
+          // Back off on error to avoid hammering the API
+          await sleep(5000)
+        }
+      } catch (error) {
+        if (!this.polling) break
+        // Network error — back off and retry
+        console.error('[telegram] Poll network error:', error instanceof Error ? error.message : error)
+        await sleep(5000)
+      }
+    }
+  }
+
   // ─── Private helpers ───────────────────────────
 
   private getWebhookUrl(): string | null {
@@ -253,18 +316,25 @@ export class TelegramAdapter implements BridgeAdapter {
     return null
   }
 
-  private async apiCall(method: string, body?: Record<string, unknown>): Promise<TelegramApiResponse> {
+  private async apiCall(
+    method: string,
+    body?: Record<string, unknown>,
+    signal?: AbortSignal
+  ): Promise<TelegramApiResponse> {
     const url = `${TELEGRAM_API}/bot${this.botToken}/${method}`
 
     try {
       const response = await fetch(url, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: body ? JSON.stringify(body) : undefined
+        body: body ? JSON.stringify(body) : undefined,
+        signal
       })
 
       return await response.json() as TelegramApiResponse
     } catch (error) {
+      if (error instanceof DOMException && error.name === 'AbortError')
+        return { ok: false, description: 'Request aborted' }
       return {
         ok: false,
         description: error instanceof Error ? error.message : 'Network error'
@@ -283,7 +353,8 @@ export class TelegramAdapter implements BridgeAdapter {
 interface TelegramApiResponse {
   ok: boolean
   description?: string
-  result?: Record<string, unknown>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  result?: any
 }
 
 function formatTelegramName(from?: TelegramMessage['from']): string {
@@ -292,3 +363,7 @@ function formatTelegramName(from?: TelegramMessage['from']): string {
   if (from.last_name) parts.push(from.last_name)
   return parts.join(' ')
 }
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}

package/server/bridge/responder.ts

@@ -0,0 +1,248 @@
+import { randomUUID } from 'crypto'
+import { query } from '@anthropic-ai/claude-agent-sdk'
+import { eq } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { logTokenUsage } from '~~/server/utils/log-token-usage'
+import { sendOutboundMessage } from './router'
+import type { NormalizedMessage } from './types'
+
+/**
+ * Get or create the Main Chat conversation.
+ * There's exactly one conversation with isMain=true.
+ */
+async function getOrCreateMainChat() {
+  const db = getDb()
+
+  const [existing] = await db.select()
+    .from(schema.conversations)
+    .where(eq(schema.conversations.isMain, true))
+    .limit(1)
+
+  if (existing) return existing
+
+  const [created] = await db.insert(schema.conversations)
+    .values({
+      sessionId: `main-chat-${randomUUID()}`,
+      title: 'Main Chat',
+      isMain: true,
+      status: 'idle',
+      messageCount: 0,
+      totalCostUsd: 0
+    })
+    .returning()
+
+  console.log('[bridge] Created Main Chat conversation')
+  return created!
+}
+
+// SDK result shape (same as agent-executor.ts)
+interface SDKResult {
+  subtype: string
+  total_cost_usd: number
+  num_turns: number
+  duration_ms: number
+  result?: string
+  errors?: string[]
+  session_id?: string
+  usage: { input_tokens: number, output_tokens: number }
+}
+
+/**
+ * Generate a response to a bridge message using the Claude Agent SDK.
+ * Routes through the unified Main Chat conversation.
+ */
+export async function generateBridgeResponse(
+  bridgeId: string,
+  message: NormalizedMessage,
+  bridgeMessageId: string
+): Promise<void> {
+  const db = getDb()
+  const mainChat = await getOrCreateMainChat()
+
+  // Handle bridge commands
+  if (message.text.trim() === '/new') {
+    await db.update(schema.conversations)
+      .set({ sdkSessionId: null, summary: null })
+      .where(eq(schema.conversations.id, mainChat.id))
+
+    await sendOutboundMessage({
+      bridgeId,
+      platform: message.platform,
+      recipient: message.channelId || message.sender,
+      text: 'Conversation reset. Send me a message to start fresh.'
+    })
+    return
+  }
+
+  // Link inbound bridge message to main chat
+  await db.update(schema.bridgeMessages)
+    .set({ conversationId: mainChat.id })
+    .where(eq(schema.bridgeMessages.id, bridgeMessageId))
+
+  // Persist user message in the conversation
+  await db.insert(schema.conversationMessages).values({
+    conversationId: mainChat.id,
+    role: 'user',
+    content: JSON.stringify([{ type: 'text', text: message.text }]),
+    source: message.platform
+  })
+
+  // Build the prompt with platform context
+  const senderLabel = message.senderName || message.sender
+  const prompt = `[${message.platform} message from ${senderLabel}]: ${message.text}`
+
+  // Update status
+  await db.update(schema.conversations)
+    .set({ status: 'streaming' })
+    .where(eq(schema.conversations.id, mainChat.id))
+
+  let responseText = ''
+  let sdkSessionId: string | undefined
+  let costUsd = 0
+  let durationMs = 0
+  let inputTokens = 0
+  let outputTokens = 0
+  let numTurns = 0
+
+  try {
+    const result = await runQuery(prompt, mainChat.sdkSessionId || undefined)
+    responseText = result.text
+    sdkSessionId = result.sdkSessionId
+    costUsd = result.costUsd
+    durationMs = result.durationMs
+    inputTokens = result.inputTokens
+    outputTokens = result.outputTokens
+    numTurns = result.numTurns
+  } catch (error) {
+    // If resume fails, retry without resume
+    if (mainChat.sdkSessionId) {
+      console.warn('[bridge] SDK resume failed, retrying fresh:', error instanceof Error ? error.message : error)
+      try {
+        const result = await runQuery(prompt, undefined)
+        responseText = result.text
+        sdkSessionId = result.sdkSessionId
+        costUsd = result.costUsd
+        durationMs = result.durationMs
+        inputTokens = result.inputTokens
+        outputTokens = result.outputTokens
+        numTurns = result.numTurns
+      } catch (retryError) {
+        console.error('[bridge] SDK query failed:', retryError)
+        responseText = 'Sorry, I ran into an issue processing your message. Please try again.'
+      }
+    } else {
+      console.error('[bridge] SDK query failed:', error)
+      responseText = 'Sorry, I ran into an issue processing your message. Please try again.'
+    }
+  }
+
+  if (!responseText)
+    responseText = '(No response generated)'
+
+  // Update conversation metadata
+  const msgs = await db.select()
+    .from(schema.conversationMessages)
+    .where(eq(schema.conversationMessages.conversationId, mainChat.id))
+
+  await db.update(schema.conversations)
+    .set({
+      status: 'idle',
+      sdkSessionId: sdkSessionId || mainChat.sdkSessionId,
+      messageCount: msgs.length + 1, // +1 for the assistant message we're about to add
+      totalCostUsd: (mainChat.totalCostUsd || 0) + costUsd,
+      endedAt: new Date()
+    })
+    .where(eq(schema.conversations.id, mainChat.id))
+
+  // Persist assistant message
+  await db.insert(schema.conversationMessages).values({
+    conversationId: mainChat.id,
+    role: 'assistant',
+    content: JSON.stringify([{ type: 'text', text: responseText }]),
+    costUsd,
+    durationMs
+  })
+
+  // Log token usage
+  if (costUsd > 0 || inputTokens > 0) {
+    logTokenUsage({
+      source: 'bridge',
+      sourceId: mainChat.id,
+      sourceName: `Bridge: ${message.platform}`,
+      inputTokens,
+      outputTokens,
+      costUsd,
+      durationMs,
+      numTurns
+    })
+  }
+
+  // Send response back through the bridge adapter
+  await sendOutboundMessage({
+    bridgeId,
+    platform: message.platform,
+    recipient: message.channelId || message.sender,
+    text: responseText
+  })
+}
+
+/**
+ * Run a Claude Agent SDK query and extract the response.
+ */
+interface QueryResult {
+  text: string
+  sdkSessionId?: string
+  costUsd: number
+  durationMs: number
+  inputTokens: number
+  outputTokens: number
+  numTurns: number
+}
+
+async function runQuery(
+  prompt: string,
+  resumeSessionId?: string
+): Promise<QueryResult> {
+  const projectDir = process.env.COGNOVA_PROJECT_DIR || process.cwd()
+
+  const conversation = query({
+    prompt,
+    options: {
+      cwd: projectDir,
+      settingSources: ['user', 'project'],
+      permissionMode: 'bypassPermissions',
+      allowDangerouslySkipPermissions: true,
+      maxTurns: 50,
+      ...(resumeSessionId ? { resume: resumeSessionId } : {})
+    }
+  })
+
+  let text = ''
+  let sdkSessionId: string | undefined
+  let costUsd = 0
+  let durationMs = 0
+  let inputTokens = 0
+  let outputTokens = 0
+  let numTurns = 0
+
+  for await (const message of conversation) {
+    if (message.type === 'system' && (message as { subtype?: string }).subtype === 'init') {
+      sdkSessionId = (message as { session_id?: string }).session_id
+    } else if (message.type === 'result') {
+      const msg = message as unknown as SDKResult
+      if (msg.subtype === 'success' && msg.result)
+        text = msg.result
+      else if (msg.errors?.length)
+        text = msg.errors.join('\n')
+
+      sdkSessionId = msg.session_id || sdkSessionId
+      costUsd = msg.total_cost_usd || 0
+      durationMs = msg.duration_ms || 0
+      inputTokens = msg.usage?.input_tokens || 0
+      outputTokens = msg.usage?.output_tokens || 0
+      numTurns = msg.num_turns || 0
+    }
+  }
+
+  return { text, sdkSessionId, costUsd, durationMs, inputTokens, outputTokens, numTurns }
+}

package/server/bridge/router.ts

@@ -1,6 +1,7 @@
 import { eq } from 'drizzle-orm'
 import { getDb, schema } from '~~/server/db'
 import { notifyResourceChange } from '~~/server/utils/notify-resource'
+import { generateBridgeResponse } from './responder'
 import { getAdapter } from './registry'
 import type { NormalizedMessage, OutboundMessage, DeliveryResult } from './types'
 
@@ -38,10 +39,11 @@ export async function handleInboundMessage(
     meta: { platform: message.platform, sender: message.sender, direction: 'inbound' }
   })
 
-  // TODO Phase 2+: Route to Claude agent for processing
-  // This will create/resume a conversation and stream the agent response,
-  // then send the response back through the originating adapter.
-  console.log(`[bridge] Inbound message from ${message.sender} via ${message.platform}: ${message.text.substring(0, 100)}`)
+  // Route to Claude agent for response (fire-and-forget)
+  console.log(`[bridge] Inbound from ${message.sender} via ${message.platform}: ${message.text.substring(0, 100)}`)
+  void generateBridgeResponse(bridgeId, message, stored!.id).catch((error) => {
+    console.error('[bridge] Failed to generate response:', error)
+  })
 }
 
 /**

package/server/db/schema.ts

@@ -131,6 +131,7 @@ export const conversations = pgTable('conversations', {
     enum: ['idle', 'streaming', 'interrupted', 'error']
   }).default('idle').notNull(),
   totalCostUsd: real('total_cost_usd').default(0).notNull(),
+  isMain: boolean('is_main').default(false).notNull(),
   startedAt: timestamp('started_at', { withTimezone: true }).defaultNow().notNull(),
   endedAt: timestamp('ended_at', { withTimezone: true }),
   messageCount: integer('message_count').default(0).notNull()
@@ -143,6 +144,7 @@ export const conversationMessages = pgTable('conversation_messages', {
     .references(() => conversations.id, { onDelete: 'cascade' }),
   role: text('role', { enum: ['user', 'assistant'] }).notNull(),
   content: text('content').notNull(), // JSON string of ChatContentBlock[]
+  source: text('source', { enum: ['web', 'telegram', 'discord', 'imessage', 'email', 'google'] }),
   costUsd: real('cost_usd'),
   durationMs: integer('duration_ms'),
   createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull()
@@ -383,7 +385,7 @@ export const skillsCatalog = pgTable('skills_catalog', {
 
 export const tokenUsage = pgTable('token_usage', {
   id: uuid('id').primaryKey().defaultRandom(),
-  source: text('source', { enum: ['chat', 'agent', 'memory_extraction'] }).notNull(),
+  source: text('source', { enum: ['chat', 'agent', 'memory_extraction', 'bridge'] }).notNull(),
   sourceId: text('source_id'),
   sourceName: text('source_name'),
   inputTokens: integer('input_tokens').default(0).notNull(),

package/server/drizzle/migrations/0015_great_mephistopheles.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "conversation_messages" ADD COLUMN "source" text;--> statement-breakpoint
+ALTER TABLE "conversations" ADD COLUMN "is_main" boolean DEFAULT false NOT NULL;