@nexttylabs/echo 0.2.0

package/lib/webhooks/retry.ts

@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import { db } from "@/lib/db";
+import { webhooks, webhookEvents } from "@/lib/db/schema";
+import { eq, and, lte, lt } from "drizzle-orm";
+import { createHmac } from "crypto";
+import { logger } from "@/lib/logger";
+
+const processing = new Set<number>();
+
+function signPayload(payload: unknown, secret: string | null): string {
+  const payloadString = JSON.stringify(payload);
+  const hmac = createHmac("sha256", secret || "");
+  hmac.update(payloadString);
+  return `sha256=${hmac.digest("hex")}`;
+}
+
+function calculateNextRetry(retryCount: number): Date {
+  const delays = [60, 300, 900]; // 1min, 5min, 15min
+  const delay = delays[Math.min(retryCount, delays.length - 1)];
+  return new Date(Date.now() + delay * 1000);
+}
+
+async function retryWebhookEvent(
+  event: {
+    eventId: number;
+    webhookId: number;
+    eventType: string;
+    payload: unknown;
+    retryCount: number;
+    maxRetries: number;
+  },
+  webhook: { url: string; secret: string | null },
+): Promise<void> {
+  if (!db) return;
+
+  logger.info({ eventId: event.eventId, retryCount: event.retryCount }, "Retrying webhook");
+
+  await db
+    .update(webhookEvents)
+    .set({ status: "sending" })
+    .where(eq(webhookEvents.eventId, event.eventId));
+
+  try {
+    const signature = signPayload(event.payload, webhook.secret);
+    const timestamp = Date.now().toString();
+
+    const response = await fetch(webhook.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "Echo-Webhooks/1.0",
+        "X-Echo-Webhook-ID": event.eventId.toString(),
+        "X-Echo-Webhook-Event": event.eventType,
+        "X-Echo-Webhook-Signature": signature,
+        "X-Echo-Webhook-Timestamp": timestamp,
+      },
+      body: JSON.stringify(event.payload),
+    });
+
+    const responseText = await response.text();
+
+    if (response.ok) {
+      await db
+        .update(webhookEvents)
+        .set({
+          status: "delivered",
+          responseStatus: response.status,
+          responseBody: responseText.slice(0, 10000),
+          deliveredAt: new Date(),
+        })
+        .where(eq(webhookEvents.eventId, event.eventId));
+
+      logger.info({ eventId: event.eventId }, "Webhook retry succeeded");
+    } else {
+      await handleRetryFailure(event, response.status, responseText);
+    }
+  } catch (error) {
+    await handleRetryFailure(event, null, null);
+    logger.error({ eventId: event.eventId, err: error }, "Webhook retry error");
+  }
+}
+
+async function handleRetryFailure(
+  event: { eventId: number; retryCount: number; maxRetries: number },
+  responseStatus: number | null,
+  responseBody: string | null,
+): Promise<void> {
+  if (!db) return;
+
+  const newRetryCount = event.retryCount + 1;
+
+  if (newRetryCount >= event.maxRetries) {
+    await db
+      .update(webhookEvents)
+      .set({
+        status: "failed",
+        retryCount: newRetryCount,
+        responseStatus,
+        responseBody: responseBody?.slice(0, 10000),
+      })
+      .where(eq(webhookEvents.eventId, event.eventId));
+
+    logger.warn({ eventId: event.eventId }, "Webhook failed after max retries");
+  } else {
+    const nextRetryAt = calculateNextRetry(newRetryCount);
+
+    await db
+      .update(webhookEvents)
+      .set({
+        status: "pending",
+        retryCount: newRetryCount,
+        nextRetryAt,
+        responseStatus,
+        responseBody: responseBody?.slice(0, 10000),
+      })
+      .where(eq(webhookEvents.eventId, event.eventId));
+  }
+}
+
+export async function processFailedWebhooks(): Promise<void> {
+  if (!db) {
+    logger.error("Database not configured");
+    return;
+  }
+
+  const failedEvents = await db
+    .select({
+      eventId: webhookEvents.eventId,
+      webhookId: webhookEvents.webhookId,
+      eventType: webhookEvents.eventType,
+      payload: webhookEvents.payload,
+      retryCount: webhookEvents.retryCount,
+      maxRetries: webhookEvents.maxRetries,
+    })
+    .from(webhookEvents)
+    .where(
+      and(
+        eq(webhookEvents.status, "pending"),
+        lte(webhookEvents.nextRetryAt, new Date()),
+        lt(webhookEvents.retryCount, webhookEvents.maxRetries),
+      ),
+    )
+    .limit(10);
+
+  for (const event of failedEvents) {
+    if (processing.has(event.eventId)) {
+      continue;
+    }
+
+    processing.add(event.eventId);
+
+    try {
+      const webhook = await db.query.webhooks.findFirst({
+        where: eq(webhooks.webhookId, event.webhookId),
+      });
+
+      if (!webhook || !webhook.enabled) {
+        await db
+          .update(webhookEvents)
+          .set({ status: "failed" })
+          .where(eq(webhookEvents.eventId, event.eventId));
+        continue;
+      }
+
+      await retryWebhookEvent(event, webhook);
+    } catch (error) {
+      logger.error({ eventId: event.eventId, err: error }, "Failed to retry webhook");
+    } finally {
+      processing.delete(event.eventId);
+    }
+  }
+}

package/lib/webhooks/sender.ts

@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import { db } from "@/lib/db";
+import { webhooks, webhookEvents } from "@/lib/db/schema";
+import { eq, and } from "drizzle-orm";
+import { createHmac } from "crypto";
+import { logger } from "@/lib/logger";
+import type { WebhookPayload } from "./events";
+
+function signPayload(payload: unknown, secret: string | null): string {
+  const payloadString = JSON.stringify(payload);
+  const hmac = createHmac("sha256", secret || "");
+  hmac.update(payloadString);
+  return `sha256=${hmac.digest("hex")}`;
+}
+
+function calculateNextRetry(retryCount: number): Date {
+  const delays = [60, 300, 900]; // 1min, 5min, 15min
+  const delay = delays[Math.min(retryCount, delays.length - 1)];
+  return new Date(Date.now() + delay * 1000);
+}
+
+export async function sendWebhook(
+  webhookId: number,
+  eventType: string,
+  payload: WebhookPayload,
+): Promise<void> {
+  if (!db) {
+    logger.error("Database not configured");
+    return;
+  }
+
+  const webhook = await db.query.webhooks.findFirst({
+    where: eq(webhooks.webhookId, webhookId),
+  });
+
+  if (!webhook || !webhook.enabled) {
+    logger.info({ webhookId }, "Webhook not found or disabled");
+    return;
+  }
+
+  if (!webhook.events.includes(eventType)) {
+    logger.info({ webhookId, eventType }, "Webhook not subscribed to event");
+    return;
+  }
+
+  const eventRecord = await db
+    .insert(webhookEvents)
+    .values({
+      webhookId,
+      eventType,
+      payload,
+      status: "sending",
+      retryCount: 0,
+      maxRetries: 3,
+    })
+    .returning();
+
+  const eventId = eventRecord[0].eventId;
+
+  try {
+    const signature = signPayload(payload, webhook.secret);
+    const timestamp = Date.now().toString();
+
+    const response = await fetch(webhook.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "Echo-Webhooks/1.0",
+        "X-Echo-Webhook-ID": eventId.toString(),
+        "X-Echo-Webhook-Event": eventType,
+        "X-Echo-Webhook-Signature": signature,
+        "X-Echo-Webhook-Timestamp": timestamp,
+      },
+      body: JSON.stringify(payload),
+    });
+
+    const responseText = await response.text();
+
+    if (response.ok) {
+      await db
+        .update(webhookEvents)
+        .set({
+          status: "delivered",
+          responseStatus: response.status,
+          responseBody: responseText.slice(0, 10000),
+          deliveredAt: new Date(),
+        })
+        .where(eq(webhookEvents.eventId, eventId));
+
+      logger.info(
+        { webhookId, eventId, status: response.status },
+        "Webhook delivered",
+      );
+    } else {
+      const nextRetryAt = calculateNextRetry(0);
+
+      await db
+        .update(webhookEvents)
+        .set({
+          status: "pending",
+          responseStatus: response.status,
+          responseBody: responseText.slice(0, 10000),
+          retryCount: 0,
+          nextRetryAt,
+        })
+        .where(eq(webhookEvents.eventId, eventId));
+
+      logger.warn(
+        { webhookId, eventId, status: response.status },
+        "Webhook failed, will retry",
+      );
+    }
+  } catch (error) {
+    const nextRetryAt = calculateNextRetry(0);
+
+    await db
+      .update(webhookEvents)
+      .set({
+        status: "pending",
+        retryCount: 0,
+        nextRetryAt,
+      })
+      .where(eq(webhookEvents.eventId, eventId));
+
+    logger.error({ webhookId, eventId, err: error }, "Webhook error, will retry");
+  }
+}
+
+export async function triggerWebhooks(
+  organizationId: string,
+  eventType: string,
+  payload: WebhookPayload,
+): Promise<void> {
+  if (!db) {
+    logger.error("Database not configured");
+    return;
+  }
+
+  const orgWebhooks = await db.query.webhooks.findMany({
+    where: and(
+      eq(webhooks.organizationId, organizationId),
+      eq(webhooks.enabled, true),
+    ),
+  });
+
+  const subscribedWebhooks = orgWebhooks.filter((w) =>
+    w.events.includes(eventType),
+  );
+
+  for (const webhook of subscribedWebhooks) {
+    sendWebhook(webhook.webhookId, eventType, payload).catch((error) => {
+      logger.error(
+        { webhookId: webhook.webhookId, err: error },
+        "Failed to queue webhook",
+      );
+    });
+  }
+
+  logger.info(
+    {
+      organizationId,
+      eventType,
+      count: subscribedWebhooks.length,
+    },
+    "Webhooks triggered",
+  );
+}

package/lib/webhooks/verify.ts

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import { createHmac, timingSafeEqual } from "crypto";
+
+export function verifyWebhookSignature(
+  payload: string,
+  signature: string,
+  secret: string,
+): boolean {
+  const hmac = createHmac("sha256", secret);
+  hmac.update(payload);
+  const expectedSignature = `sha256=${hmac.digest("hex")}`;
+
+  try {
+    return timingSafeEqual(
+      Buffer.from(signature),
+      Buffer.from(expectedSignature),
+    );
+  } catch {
+    return false;
+  }
+}

package/lib/workers/feedback-processor.ts

@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Background AI processing for feedback
+ * MVP: Uses setTimeout + in-memory queue
+ * Future: BullMQ + Redis for production scalability
+ */
+
+import { classifyFeedback } from "@/lib/services/ai/classifier";
+import { suggestTags } from "@/lib/services/ai/tag-suggester";
+import {
+  findDuplicates,
+  type FeedbackForDuplicateCheck,
+} from "@/lib/services/ai/duplicate-detector";
+import { db } from "@/lib/db";
+import {
+  feedback,
+  aiProcessingResults,
+  duplicateFeedback,
+} from "@/lib/db/schema";
+import { eq, and, isNull, ne } from "drizzle-orm";
+import { logger } from "@/lib/logger";
+
+export interface ProcessingJob {
+  feedbackId: number;
+  title: string;
+  description: string;
+  organizationId: string;
+}
+
+/**
+ * Process AI tasks for a single feedback item
+ */
+export async function processFeedback(job: ProcessingJob): Promise<void> {
+  if (
+    !db ||
+    typeof db.update !== "function" ||
+    typeof db.insert !== "function" ||
+    typeof db.select !== "function"
+  ) {
+    logger.error("Database not available for AI processing");
+    return;
+  }
+
+  const startTime = Date.now();
+
+  try {
+    logger.info({ feedbackId: job.feedbackId }, "Starting AI processing");
+
+    // Update status to processing
+    await db
+      .update(feedback)
+      .set({ processingStatus: "processing" })
+      .where(eq(feedback.feedbackId, job.feedbackId));
+
+    // 1. Classification
+    const classification = classifyFeedback(job.title, job.description);
+
+    // 2. Tag suggestions
+    const tagSuggestions = suggestTags(job.title, job.description);
+
+    // 3. Duplicate detection
+    const existingFeedbacks: FeedbackForDuplicateCheck[] = await db
+      .select({
+        feedbackId: feedback.feedbackId,
+        title: feedback.title,
+        description: feedback.description,
+      })
+      .from(feedback)
+      .where(
+        and(
+          eq(feedback.organizationId, job.organizationId),
+          isNull(feedback.deletedAt),
+          ne(feedback.feedbackId, job.feedbackId),
+        ),
+      );
+
+    const duplicateCandidates = findDuplicates(
+      job.title,
+      job.description,
+      existingFeedbacks,
+      job.feedbackId,
+      0.75,
+    );
+
+    const processingTime = Date.now() - startTime;
+
+    // Save processing results
+    await db.insert(aiProcessingResults).values({
+      feedbackId: job.feedbackId,
+      classification,
+      tagSuggestions: tagSuggestions.map((t) => ({
+        name: t.name,
+        slug: t.slug,
+        confidence: t.confidence,
+      })),
+      duplicateCandidates: duplicateCandidates.map((d) => ({
+        feedbackId: d.feedbackId,
+        similarity: d.similarity,
+      })),
+      processingTime,
+      status: "completed",
+    });
+
+    // Save duplicate candidates to duplicate_feedback table
+    for (const duplicate of duplicateCandidates) {
+      await db
+        .insert(duplicateFeedback)
+        .values({
+          originalFeedbackId: job.feedbackId,
+          duplicateFeedbackId: duplicate.feedbackId,
+          similarity: duplicate.similarity,
+          status: "pending",
+        })
+        .onConflictDoNothing();
+    }
+
+    // Update feedback status
+    await db
+      .update(feedback)
+      .set({
+        processingStatus: "completed",
+        processedAt: new Date(),
+      })
+      .where(eq(feedback.feedbackId, job.feedbackId));
+
+    logger.info(
+      {
+        feedbackId: job.feedbackId,
+        processingTime,
+        duplicatesFound: duplicateCandidates.length,
+        tagsFound: tagSuggestions.length,
+      },
+      "AI processing completed",
+    );
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+
+    logger.error(
+      {
+        feedbackId: job.feedbackId,
+        error: errorMessage,
+      },
+      "AI processing failed",
+    );
+
+    // Update status to failed
+    await db
+      .update(feedback)
+      .set({ processingStatus: "failed" })
+      .where(eq(feedback.feedbackId, job.feedbackId));
+
+    // Save failure record
+    await db.insert(aiProcessingResults).values({
+      feedbackId: job.feedbackId,
+      processingTime: Date.now() - startTime,
+      status: "failed",
+      errorMessage,
+    });
+  }
+}
+
+// MVP: Simple in-memory queue
+const processingQueue: ProcessingJob[] = [];
+let isProcessing = false;
+
+/**
+ * Add a feedback item to the processing queue
+ */
+export function enqueueFeedbackProcessing(job: ProcessingJob): void {
+  processingQueue.push(job);
+
+  if (!isProcessing) {
+    processQueue();
+  }
+}
+
+/**
+ * Process items from the queue
+ */
+async function processQueue(): Promise<void> {
+  if (processingQueue.length === 0) {
+    isProcessing = false;
+    return;
+  }
+
+  isProcessing = true;
+  const job = processingQueue.shift();
+
+  if (job) {
+    // Delay to avoid blocking the response
+    setTimeout(async () => {
+      await processFeedback(job);
+      processQueue();
+    }, 100);
+  }
+}
+
+/**
+ * Retry failed processing for a feedback item
+ */
+export async function retryFailedProcessing(feedbackId: number): Promise<void> {
+  if (!db) {
+    throw new Error("Database not available");
+  }
+
+  const feedbackData = await db
+    .select({
+      feedbackId: feedback.feedbackId,
+      title: feedback.title,
+      description: feedback.description,
+      organizationId: feedback.organizationId,
+    })
+    .from(feedback)
+    .where(eq(feedback.feedbackId, feedbackId))
+    .limit(1);
+
+  if (feedbackData.length === 0) {
+    throw new Error("Feedback not found");
+  }
+
+  const data = feedbackData[0];
+
+  enqueueFeedbackProcessing({
+    feedbackId: data.feedbackId,
+    title: data.title,
+    description: data.description || "",
+    organizationId: data.organizationId,
+  });
+}
+
+/**
+ * Get queue status (for monitoring)
+ */
+export function getQueueStatus(): { queueLength: number; isProcessing: boolean } {
+  return {
+    queueLength: processingQueue.length,
+    isProcessing,
+  };
+}