stagent 0.5.0 → 0.6.0

package/src/lib/channels/poller.ts

@@ -0,0 +1,268 @@
+/**
+ * Channel Poller — background service that polls bidirectional channels
+ * for inbound messages when webhooks can't reach the server (e.g., localhost).
+ *
+ * Runs alongside the scheduler via instrumentation.ts.
+ * Only polls channels with direction="bidirectional" and status="active".
+ */
+
+import { db } from "@/lib/db";
+import { channelConfigs } from "@/lib/db/schema";
+import { eq, and } from "drizzle-orm";
+import { telegramAdapter } from "./telegram-adapter";
+import { handleInboundMessage } from "./gateway";
+import type { InboundMessage } from "./types";
+
+const POLL_INTERVAL_MS = 5_000; // 5 seconds
+let intervalHandle: ReturnType<typeof setInterval> | null = null;
+
+/** Per-channel offset tracking (in-memory, resets on restart). */
+const channelOffsets = new Map<string, number>();
+
+/** Per-channel Slack timestamp tracking (in-memory). */
+const slackTimestamps = new Map<string, string>();
+
+/** Lock to prevent overlapping ticks. */
+let ticking = false;
+
+export function startChannelPoller(): void {
+  if (intervalHandle !== null) return;
+  intervalHandle = setInterval(() => {
+    tickPoller().catch((err) => {
+      console.error("[channel-poller] tick error:", err);
+    });
+  }, POLL_INTERVAL_MS);
+  console.log(`[channel-poller] started — polling every ${POLL_INTERVAL_MS / 1000}s`);
+}
+
+export function stopChannelPoller(): void {
+  if (intervalHandle !== null) {
+    clearInterval(intervalHandle);
+    intervalHandle = null;
+    console.log("[channel-poller] stopped");
+  }
+}
+
+async function tickPoller(): Promise<void> {
+  if (ticking) return; // Skip if previous tick still running
+  ticking = true;
+  try {
+    // Find all active bidirectional channels
+    const channels = db
+      .select()
+      .from(channelConfigs)
+      .where(
+        and(
+          eq(channelConfigs.direction, "bidirectional"),
+          eq(channelConfigs.status, "active")
+        )
+      )
+      .all();
+
+    for (const channel of channels) {
+      try {
+        await pollChannel(channel);
+      } catch (err) {
+        console.error(`[channel-poller] error polling ${channel.channelType}/${channel.id}:`, err);
+      }
+    }
+  } finally {
+    ticking = false;
+  }
+}
+
+async function pollChannel(
+  channel: typeof channelConfigs.$inferSelect
+): Promise<void> {
+  if (channel.channelType === "telegram") {
+    await pollTelegram(channel);
+  } else if (channel.channelType === "slack") {
+    await pollSlack(channel);
+  }
+  // Webhook channels are push-based — no polling needed
+}
+
+async function pollTelegram(
+  channel: typeof channelConfigs.$inferSelect
+): Promise<void> {
+  let parsedConfig: Record<string, unknown>;
+  try {
+    parsedConfig = JSON.parse(channel.config) as Record<string, unknown>;
+  } catch {
+    return;
+  }
+
+  const botToken = parsedConfig.botToken as string;
+  if (!botToken) return;
+
+  const offset = channelOffsets.get(channel.id);
+  const params: Record<string, unknown> = { timeout: 0, limit: 20 };
+  if (offset) {
+    params.offset = offset;
+  }
+
+  let updates: TelegramUpdate[];
+  try {
+    const res = await fetch(
+      `https://api.telegram.org/bot${botToken}/getUpdates`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(params),
+      }
+    );
+    const data = (await res.json()) as { ok: boolean; result: TelegramUpdate[] };
+    if (!data.ok) return;
+    updates = data.result;
+  } catch {
+    return; // Network error — retry next tick
+  }
+
+  if (updates.length === 0) return;
+
+  let maxUpdateId = 0;
+  for (const update of updates) {
+    if (update.update_id > maxUpdateId) {
+      maxUpdateId = update.update_id;
+    }
+
+    const message = telegramAdapter.parseInbound!(update, {});
+    if (!message || message.isBot) continue;
+
+    try {
+      await handleInboundMessage({
+        channelConfigId: channel.id,
+        message,
+      });
+    } catch (err) {
+      console.error(`[channel-poller] error processing telegram update ${update.update_id}:`, err);
+    }
+  }
+
+  // Advance offset so Telegram doesn't return these again
+  if (maxUpdateId > 0) {
+    const nextOffset = maxUpdateId + 1;
+    channelOffsets.set(channel.id, nextOffset);
+
+    // Acknowledge with Telegram
+    try {
+      await fetch(
+        `https://api.telegram.org/bot${botToken}/getUpdates`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ offset: nextOffset, timeout: 0 }),
+        }
+      );
+    } catch {
+      // Non-fatal
+    }
+  }
+}
+
+async function pollSlack(
+  channel: typeof channelConfigs.$inferSelect
+): Promise<void> {
+  let parsedConfig: Record<string, unknown>;
+  try {
+    parsedConfig = JSON.parse(channel.config) as Record<string, unknown>;
+  } catch {
+    return;
+  }
+
+  const botToken = parsedConfig.botToken as string;
+  const slackChannelId = parsedConfig.slackChannelId as string;
+  if (!botToken || !slackChannelId) return;
+
+  // Use oldest timestamp to only fetch new messages
+  const oldest = slackTimestamps.get(channel.id);
+
+  const params = new URLSearchParams({
+    channel: slackChannelId,
+    limit: "20",
+  });
+  if (oldest) {
+    params.set("oldest", oldest);
+  }
+
+  let messages: SlackMessage[];
+  try {
+    const res = await fetch(
+      `https://slack.com/api/conversations.history?${params.toString()}`,
+      {
+        headers: { Authorization: `Bearer ${botToken}` },
+      }
+    );
+    const data = (await res.json()) as {
+      ok: boolean;
+      messages?: SlackMessage[];
+      error?: string;
+    };
+    if (!data.ok || !data.messages) return;
+    messages = data.messages;
+  } catch {
+    return; // Network error — retry next tick
+  }
+
+  if (messages.length === 0) return;
+
+  // Slack returns newest first — reverse to process chronologically
+  messages.reverse();
+
+  let maxTs = oldest ?? "0";
+  for (const msg of messages) {
+    // Skip bot messages, subtypes (joins, edits), and already-seen messages
+    if (msg.bot_id || msg.subtype) continue;
+    if (oldest && msg.ts <= oldest) continue;
+
+    if (msg.ts > maxTs) {
+      maxTs = msg.ts;
+    }
+
+    const inbound: InboundMessage = {
+      text: msg.text ?? "",
+      senderId: msg.user,
+      senderName: msg.user,
+      externalThreadId: msg.thread_ts ?? msg.ts,
+      externalMessageId: msg.ts,
+      isBot: !!msg.bot_id,
+    };
+
+    if (!inbound.text) continue;
+
+    try {
+      await handleInboundMessage({
+        channelConfigId: channel.id,
+        message: inbound,
+      });
+    } catch (err) {
+      console.error(`[channel-poller] error processing slack message ${msg.ts}:`, err);
+    }
+  }
+
+  // Track the latest timestamp so we don't re-process
+  if (maxTs > (oldest ?? "0")) {
+    slackTimestamps.set(channel.id, maxTs);
+  }
+}
+
+interface SlackMessage {
+  type: string;
+  text?: string;
+  user?: string;
+  bot_id?: string;
+  subtype?: string;
+  ts: string;
+  thread_ts?: string;
+}
+
+interface TelegramUpdate {
+  update_id: number;
+  message?: {
+    message_id: number;
+    from?: { id: number; is_bot: boolean; first_name: string };
+    chat: { id: number; type: string };
+    date: number;
+    text?: string;
+  };
+}

package/src/lib/channels/registry.ts

@@ -0,0 +1,90 @@
+import { db } from "@/lib/db";
+import { channelConfigs } from "@/lib/db/schema";
+import { eq, inArray } from "drizzle-orm";
+import type { ChannelAdapter, ChannelMessage, ChannelDeliveryResult } from "./types";
+import { slackAdapter } from "./slack-adapter";
+import { telegramAdapter } from "./telegram-adapter";
+import { webhookAdapter } from "./webhook-adapter";
+
+const adapters: Record<string, ChannelAdapter> = {
+  slack: slackAdapter,
+  telegram: telegramAdapter,
+  webhook: webhookAdapter,
+};
+
+/**
+ * Get a channel adapter by type.
+ */
+export function getChannelAdapter(channelType: string): ChannelAdapter {
+  const adapter = adapters[channelType];
+  if (!adapter) {
+    throw new Error(`Unknown channel type: ${channelType}`);
+  }
+  return adapter;
+}
+
+/**
+ * Send a message to multiple channels by their config IDs.
+ * Skips disabled channels. Returns results for each channel attempted.
+ */
+export async function sendToChannels(
+  channelIds: string[],
+  message: ChannelMessage
+): Promise<ChannelDeliveryResult[]> {
+  if (channelIds.length === 0) return [];
+
+  const configs = await db
+    .select()
+    .from(channelConfigs)
+    .where(inArray(channelConfigs.id, channelIds));
+
+  const results: ChannelDeliveryResult[] = [];
+
+  for (const config of configs) {
+    if (config.status === "disabled") {
+      results.push({
+        success: false,
+        channelId: config.id,
+        error: "Channel is disabled",
+      });
+      continue;
+    }
+
+    const adapter = adapters[config.channelType];
+    if (!adapter) {
+      results.push({
+        success: false,
+        channelId: config.id,
+        error: `Unknown channel type: ${config.channelType}`,
+      });
+      continue;
+    }
+
+    let parsedConfig: Record<string, unknown>;
+    try {
+      parsedConfig = JSON.parse(config.config) as Record<string, unknown>;
+    } catch {
+      results.push({
+        success: false,
+        channelId: config.id,
+        error: "Invalid channel config JSON",
+      });
+      continue;
+    }
+
+    const result = await adapter.send(message, parsedConfig);
+    results.push({ ...result, channelId: config.id });
+
+    // Update test status based on send result
+    const now = new Date();
+    db.update(channelConfigs)
+      .set({
+        testStatus: result.success ? "ok" : "failed",
+        updatedAt: now,
+      })
+      .where(eq(channelConfigs.id, config.id))
+      .run();
+  }
+
+  return results;
+}

package/src/lib/channels/slack-adapter.ts

@@ -0,0 +1,188 @@
+import { createHmac, timingSafeEqual } from "crypto";
+import type { ChannelAdapter, ChannelMessage, ChannelDeliveryResult, InboundMessage } from "./types";
+
+/**
+ * Convert basic Markdown to Slack mrkdwn format.
+ * - **bold** -> *bold*
+ * - `code` stays as-is
+ * - Links stay as-is
+ */
+function toSlackMrkdwn(md: string): string {
+  return md
+    .replace(/\*\*(.+?)\*\*/g, "*$1*") // bold
+    .replace(/~~(.+?)~~/g, "~$1~"); // strikethrough
+}
+
+export const slackAdapter: ChannelAdapter = {
+  channelType: "slack",
+
+  async send(message: ChannelMessage, config: Record<string, unknown>): Promise<ChannelDeliveryResult> {
+    const webhookUrl = config.webhookUrl as string;
+    if (!webhookUrl) {
+      return { success: false, error: "Missing webhookUrl in config" };
+    }
+
+    const text = message.format === "markdown"
+      ? toSlackMrkdwn(`*${message.subject}*\n\n${message.body}`)
+      : `${message.subject}\n\n${message.body}`;
+
+    try {
+      const res = await fetch(webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text }),
+      });
+
+      if (!res.ok) {
+        const body = await res.text();
+        return { success: false, error: `Slack webhook returned ${res.status}: ${body}` };
+      }
+
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  },
+
+  async testConnection(config: Record<string, unknown>): Promise<{ ok: boolean; error?: string }> {
+    const webhookUrl = config.webhookUrl as string;
+    if (!webhookUrl) {
+      return { ok: false, error: "Missing webhookUrl" };
+    }
+
+    try {
+      const res = await fetch(webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text: "Stagent channel test - connection OK" }),
+      });
+
+      if (!res.ok) {
+        const body = await res.text();
+        return { ok: false, error: `Webhook returned ${res.status}: ${body}` };
+      }
+
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  },
+
+  // ── Bidirectional support ────────────────────────────────────────────
+
+  parseInbound(rawBody: unknown): InboundMessage | null {
+    const payload = rawBody as SlackEventPayload;
+    const event = payload?.event;
+    if (!event || event.type !== "message" || !event.text) return null;
+
+    // Filter bot messages and message_changed subtypes
+    if (event.bot_id || event.subtype) return null;
+
+    return {
+      text: event.text,
+      senderName: event.user,
+      senderId: event.user,
+      // Use thread_ts if in a thread, otherwise message ts becomes the thread root
+      externalThreadId: event.thread_ts ?? event.ts,
+      externalMessageId: event.ts,
+      isBot: !!event.bot_id,
+      raw: rawBody,
+    };
+  },
+
+  verifySignature(
+    rawBody: string,
+    headers: Record<string, string>,
+    config: Record<string, unknown>
+  ): boolean {
+    const signingSecret = config.signingSecret as string;
+    if (!signingSecret) return false;
+
+    const timestamp = headers["x-slack-request-timestamp"];
+    const signature = headers["x-slack-signature"];
+    if (!timestamp || !signature) return false;
+
+    // Reject requests older than 5 minutes (replay attack protection)
+    const now = Math.floor(Date.now() / 1000);
+    if (Math.abs(now - Number(timestamp)) > 300) return false;
+
+    const sigBasestring = `v0:${timestamp}:${rawBody}`;
+    const mySignature = `v0=${createHmac("sha256", signingSecret)
+      .update(sigBasestring)
+      .digest("hex")}`;
+
+    try {
+      return timingSafeEqual(
+        Buffer.from(mySignature, "utf8"),
+        Buffer.from(signature, "utf8")
+      );
+    } catch {
+      return false;
+    }
+  },
+
+  async sendReply(
+    message: ChannelMessage,
+    config: Record<string, unknown>,
+    threadId?: string
+  ): Promise<ChannelDeliveryResult> {
+    const botToken = config.botToken as string;
+    const channelId = config.slackChannelId as string;
+
+    if (!botToken || !channelId) {
+      return { success: false, error: "Missing botToken or slackChannelId for reply" };
+    }
+
+    const text = message.body || message.subject;
+    if (!text) {
+      return { success: false, error: "Empty message body" };
+    }
+
+    try {
+      const res = await fetch("https://slack.com/api/chat.postMessage", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${botToken}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          channel: channelId,
+          text: toSlackMrkdwn(text),
+          ...(threadId ? { thread_ts: threadId } : {}),
+        }),
+      });
+
+      const data = (await res.json()) as {
+        ok: boolean;
+        ts?: string;
+        error?: string;
+      };
+
+      if (!data.ok) {
+        return { success: false, error: data.error ?? `Slack API error` };
+      }
+
+      return { success: true, externalId: data.ts };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  },
+};
+
+// ── Slack event types (minimal subset) ─────────────────────────────────
+
+interface SlackEventPayload {
+  type: string; // "url_verification" | "event_callback"
+  challenge?: string;
+  token?: string;
+  event?: {
+    type: string; // "message"
+    text?: string;
+    user?: string;
+    bot_id?: string;
+    subtype?: string;
+    ts?: string;
+    thread_ts?: string;
+    channel?: string;
+  };
+}