vellum 0.2.14 → 0.3.2

package/src/messaging/providers/slack/adapter.ts

@@ -1,202 +0,0 @@
-/**
- * Slack messaging provider adapter.
- *
- * Maps Slack API responses to the platform-agnostic messaging types
- * and implements the MessagingProvider interface.
- */
-
-import type { MessagingProvider } from '../../provider.js';
-import type {
-  Conversation,
-  Message,
-  SearchResult,
-  SendResult,
-  ConnectionInfo,
-  ListOptions,
-  HistoryOptions,
-  SearchOptions,
-  SendOptions,
-} from '../../provider-types.js';
-import type { SlackConversation, SlackMessage, SlackSearchMatch } from './types.js';
-import * as slack from './client.js';
-
-// Cache user display names to avoid repeated API calls within a session
-const userNameCache = new Map<string, string>();
-
-async function resolveUserName(token: string, userId: string): Promise<string> {
-  if (!userId) return 'unknown';
-  const cached = userNameCache.get(userId);
-  if (cached) return cached;
-
-  try {
-    const resp = await slack.userInfo(token, userId);
-    const name = resp.user.profile?.display_name
-      || resp.user.profile?.real_name
-      || resp.user.real_name
-      || resp.user.name;
-    userNameCache.set(userId, name);
-    return name;
-  } catch {
-    return userId;
-  }
-}
-
-function mapConversationType(conv: SlackConversation): Conversation['type'] {
-  if (conv.is_im) return 'dm';
-  if (conv.is_mpim) return 'group';
-  if (conv.is_group) return 'group';
-  return 'channel';
-}
-
-function mapConversation(conv: SlackConversation): Conversation {
-  const latestTs = conv.latest?.ts ? parseFloat(conv.latest.ts) * 1000 : 0;
-  return {
-    id: conv.id,
-    name: conv.name ?? conv.id,
-    type: mapConversationType(conv),
-    platform: 'slack',
-    unreadCount: conv.unread_count_display ?? conv.unread_count ?? 0,
-    lastActivityAt: latestTs,
-    memberCount: conv.num_members,
-    topic: conv.topic?.value || undefined,
-    isArchived: conv.is_archived,
-    metadata: conv.is_im ? { dmUserId: conv.user } : undefined,
-  };
-}
-
-function mapMessage(msg: SlackMessage, channelId: string, senderName: string): Message {
-  return {
-    id: msg.ts,
-    conversationId: channelId,
-    sender: { id: msg.user ?? msg.bot_id ?? 'unknown', name: senderName },
-    text: msg.text,
-    timestamp: parseFloat(msg.ts) * 1000,
-    threadId: msg.thread_ts,
-    replyCount: msg.reply_count,
-    platform: 'slack',
-    reactions: msg.reactions?.map((r) => ({ name: r.name, count: r.count })),
-    hasAttachments: (msg.files?.length ?? 0) > 0,
-  };
-}
-
-function mapSearchMatch(match: SlackSearchMatch): Message {
-  return {
-    id: match.ts,
-    conversationId: match.channel.id,
-    sender: { id: match.user ?? 'unknown', name: match.username ?? 'unknown' },
-    text: match.text,
-    timestamp: parseFloat(match.ts) * 1000,
-    threadId: match.thread_ts,
-    platform: 'slack',
-    metadata: { permalink: match.permalink, channelName: match.channel.name },
-  };
-}
-
-export const slackProvider: MessagingProvider = {
-  id: 'slack',
-  displayName: 'Slack',
-  credentialService: 'integration:slack',
-  capabilities: new Set(['reactions', 'threads', 'leave_channel']),
-
-  async testConnection(token: string): Promise<ConnectionInfo> {
-    const resp = await slack.authTest(token);
-    return {
-      connected: true,
-      user: resp.user,
-      platform: 'slack',
-      metadata: { team: resp.team, teamId: resp.team_id, userId: resp.user_id },
-    };
-  },
-
-  async listConversations(token: string, options?: ListOptions): Promise<Conversation[]> {
-    const typeMap: Record<string, string> = {
-      channel: 'public_channel,private_channel',
-      dm: 'im',
-      group: 'mpim',
-    };
-
-    let types: string;
-    if (options?.types?.length) {
-      types = options.types.map((t) => typeMap[t] ?? t).join(',');
-    } else {
-      types = 'public_channel,private_channel,mpim,im';
-    }
-
-    const conversations: Conversation[] = [];
-    let cursor: string | undefined = options?.cursor;
-
-    // Paginate through all results
-    do {
-      const resp = await slack.listConversations(
-        token,
-        types,
-        options?.excludeArchived ?? true,
-        options?.limit ?? 200,
-        cursor,
-      );
-      conversations.push(...resp.channels.map(mapConversation));
-      cursor = resp.response_metadata?.next_cursor || undefined;
-    } while (cursor && (!options?.limit || conversations.length < options.limit));
-
-    // Resolve DM user names
-    for (const conv of conversations) {
-      if (conv.type === 'dm' && conv.metadata?.dmUserId) {
-        conv.name = await resolveUserName(token, conv.metadata.dmUserId as string);
-      }
-    }
-
-    return conversations;
-  },
-
-  async getHistory(token: string, conversationId: string, options?: HistoryOptions): Promise<Message[]> {
-    const resp = await slack.conversationHistory(
-      token,
-      conversationId,
-      options?.limit ?? 50,
-      options?.before,
-      options?.after,
-    );
-
-    const messages: Message[] = [];
-    for (const msg of resp.messages) {
-      const name = await resolveUserName(token, msg.user ?? '');
-      messages.push(mapMessage(msg, conversationId, name));
-    }
-
-    return messages;
-  },
-
-  async search(token: string, query: string, options?: SearchOptions): Promise<SearchResult> {
-    const resp = await slack.searchMessages(token, query, options?.count ?? 20);
-    return {
-      total: resp.messages.total,
-      messages: resp.messages.matches.map(mapSearchMatch),
-      hasMore: resp.messages.paging.page < resp.messages.paging.pages,
-    };
-  },
-
-  async sendMessage(token: string, conversationId: string, text: string, options?: SendOptions): Promise<SendResult> {
-    const resp = await slack.postMessage(token, conversationId, text, options?.threadId);
-    return {
-      id: resp.ts,
-      timestamp: parseFloat(resp.ts) * 1000,
-      conversationId: resp.channel,
-    };
-  },
-
-  async getThreadReplies(token: string, conversationId: string, threadId: string, options?: HistoryOptions): Promise<Message[]> {
-    const resp = await slack.conversationReplies(token, conversationId, threadId, options?.limit ?? 50);
-    const messages: Message[] = [];
-    for (const msg of resp.messages) {
-      const name = await resolveUserName(token, msg.user ?? '');
-      messages.push(mapMessage(msg, conversationId, name));
-    }
-    return messages;
-  },
-
-  async markRead(token: string, conversationId: string, messageId?: string): Promise<void> {
-    // Slack's conversations.mark requires a timestamp — use the provided one or "now"
-    const ts = messageId ?? String(Date.now() / 1000);
-    await slack.conversationMark(token, conversationId, ts);
-  },
-};

package/src/messaging/providers/slack/client.ts

@@ -1,198 +0,0 @@
-/**
- * Low-level Slack Web API wrapper.
- *
- * All methods take a user OAuth token and throw SlackApiError on failures.
- * Throws with status: 401 on auth errors for withValidToken compatibility.
- */
-
-import type {
-  SlackAuthTestResponse,
-  SlackConversationsListResponse,
-  SlackConversationsOpenResponse,
-  SlackConversationHistoryResponse,
-  SlackConversationRepliesResponse,
-  SlackUserInfoResponse,
-  SlackPostMessageResponse,
-  SlackSearchMessagesResponse,
-  SlackReactionAddResponse,
-  SlackConversationLeaveResponse,
-  SlackConversationMarkResponse,
-  SlackApiResponse,
-} from './types.js';
-
-const SLACK_API_BASE = 'https://slack.com/api';
-
-export class SlackApiError extends Error {
-  constructor(
-    public readonly status: number,
-    public readonly slackError: string,
-    message: string,
-  ) {
-    super(message);
-    this.name = 'SlackApiError';
-  }
-}
-
-async function request<T extends SlackApiResponse>(
-  token: string,
-  method: string,
-  params?: Record<string, string | undefined>,
-  body?: Record<string, unknown>,
-): Promise<T> {
-  let url = `${SLACK_API_BASE}/${method}`;
-  const headers: Record<string, string> = {
-    Authorization: `Bearer ${token}`,
-  };
-
-  let init: RequestInit;
-  if (body) {
-    headers['Content-Type'] = 'application/json; charset=utf-8';
-    init = { method: 'POST', headers, body: JSON.stringify(body) };
-  } else {
-    if (params) {
-      const searchParams = new URLSearchParams();
-      for (const [k, v] of Object.entries(params)) {
-        if (v !== undefined) searchParams.set(k, v);
-      }
-      url += `?${searchParams}`;
-    }
-    init = { method: 'GET', headers };
-  }
-
-  const resp = await fetch(url, init);
-  if (!resp.ok) {
-    throw new SlackApiError(resp.status, `http_${resp.status}`, `Slack API HTTP ${resp.status}`);
-  }
-
-  const data = (await resp.json()) as T;
-  if (!data.ok) {
-    const slackError = data.error ?? 'unknown_error';
-    // Map auth errors to 401 for token-manager retry
-    const status = ['invalid_auth', 'token_expired', 'token_revoked', 'not_authed'].includes(slackError) ? 401 : 400;
-    throw new SlackApiError(status, slackError, `Slack API error: ${slackError}`);
-  }
-
-  return data;
-}
-
-export async function authTest(token: string): Promise<SlackAuthTestResponse> {
-  return request<SlackAuthTestResponse>(token, 'auth.test');
-}
-
-export async function listConversations(
-  token: string,
-  types = 'public_channel,private_channel,mpim,im',
-  excludeArchived = true,
-  limit = 200,
-  cursor?: string,
-): Promise<SlackConversationsListResponse> {
-  return request<SlackConversationsListResponse>(token, 'conversations.list', {
-    types,
-    exclude_archived: String(excludeArchived),
-    limit: String(limit),
-    cursor,
-  });
-}
-
-export async function conversationHistory(
-  token: string,
-  channel: string,
-  limit = 50,
-  latest?: string,
-  oldest?: string,
-  cursor?: string,
-): Promise<SlackConversationHistoryResponse> {
-  return request<SlackConversationHistoryResponse>(token, 'conversations.history', {
-    channel,
-    limit: String(limit),
-    latest,
-    oldest,
-    cursor,
-  });
-}
-
-export async function conversationReplies(
-  token: string,
-  channel: string,
-  ts: string,
-  limit = 50,
-): Promise<SlackConversationRepliesResponse> {
-  return request<SlackConversationRepliesResponse>(token, 'conversations.replies', {
-    channel,
-    ts,
-    limit: String(limit),
-  });
-}
-
-export async function conversationMark(
-  token: string,
-  channel: string,
-  ts: string,
-): Promise<SlackConversationMarkResponse> {
-  return request<SlackConversationMarkResponse>(token, 'conversations.mark', undefined, {
-    channel,
-    ts,
-  });
-}
-
-export async function conversationsOpen(
-  token: string,
-  userId: string,
-): Promise<SlackConversationsOpenResponse> {
-  return request<SlackConversationsOpenResponse>(token, 'conversations.open', undefined, {
-    users: userId,
-  });
-}
-
-export async function userInfo(
-  token: string,
-  userId: string,
-): Promise<SlackUserInfoResponse> {
-  return request<SlackUserInfoResponse>(token, 'users.info', { user: userId });
-}
-
-export async function postMessage(
-  token: string,
-  channel: string,
-  text: string,
-  threadTs?: string,
-): Promise<SlackPostMessageResponse> {
-  const body: Record<string, unknown> = { channel, text };
-  if (threadTs) body.thread_ts = threadTs;
-  return request<SlackPostMessageResponse>(token, 'chat.postMessage', undefined, body);
-}
-
-export async function searchMessages(
-  token: string,
-  query: string,
-  count = 20,
-  page = 1,
-): Promise<SlackSearchMessagesResponse> {
-  return request<SlackSearchMessagesResponse>(token, 'search.messages', {
-    query,
-    count: String(count),
-    page: String(page),
-  });
-}
-
-export async function addReaction(
-  token: string,
-  channel: string,
-  timestamp: string,
-  name: string,
-): Promise<SlackReactionAddResponse> {
-  return request<SlackReactionAddResponse>(token, 'reactions.add', undefined, {
-    channel,
-    timestamp,
-    name,
-  });
-}
-
-export async function leaveConversation(
-  token: string,
-  channel: string,
-): Promise<SlackConversationLeaveResponse> {
-  return request<SlackConversationLeaveResponse>(token, 'conversations.leave', undefined, {
-    channel,
-  });
-}

package/src/messaging/providers/slack/types.ts

@@ -1,119 +0,0 @@
-/** Slack Web API response types. */
-
-export interface SlackApiResponse {
-  ok: boolean;
-  error?: string;
-}
-
-export interface SlackAuthTestResponse extends SlackApiResponse {
-  url: string;
-  team: string;
-  user: string;
-  team_id: string;
-  user_id: string;
-}
-
-export interface SlackConversation {
-  id: string;
-  name?: string;
-  is_channel?: boolean;
-  is_group?: boolean;
-  is_im?: boolean;
-  is_mpim?: boolean;
-  is_archived?: boolean;
-  is_member?: boolean;
-  topic?: { value: string };
-  purpose?: { value: string };
-  num_members?: number;
-  unread_count?: number;
-  unread_count_display?: number;
-  latest?: SlackMessage;
-  user?: string;
-}
-
-export interface SlackConversationsListResponse extends SlackApiResponse {
-  channels: SlackConversation[];
-  response_metadata?: { next_cursor?: string };
-}
-
-export interface SlackMessage {
-  type: string;
-  subtype?: string;
-  ts: string;
-  user?: string;
-  bot_id?: string;
-  text: string;
-  thread_ts?: string;
-  reply_count?: number;
-  reactions?: Array<{ name: string; count: number; users: string[] }>;
-  files?: Array<{ id: string; name: string; mimetype: string }>;
-}
-
-export interface SlackConversationHistoryResponse extends SlackApiResponse {
-  messages: SlackMessage[];
-  has_more: boolean;
-  response_metadata?: { next_cursor?: string };
-}
-
-export interface SlackConversationRepliesResponse extends SlackApiResponse {
-  messages: SlackMessage[];
-  has_more: boolean;
-}
-
-export interface SlackUser {
-  id: string;
-  name: string;
-  real_name?: string;
-  profile?: {
-    display_name?: string;
-    real_name?: string;
-    email?: string;
-    image_48?: string;
-  };
-  is_bot?: boolean;
-  deleted?: boolean;
-}
-
-export interface SlackUsersListResponse extends SlackApiResponse {
-  members: SlackUser[];
-  response_metadata?: { next_cursor?: string };
-}
-
-export interface SlackUserInfoResponse extends SlackApiResponse {
-  user: SlackUser;
-}
-
-export interface SlackPostMessageResponse extends SlackApiResponse {
-  channel: string;
-  ts: string;
-  message: SlackMessage;
-}
-
-export interface SlackSearchMessagesResponse extends SlackApiResponse {
-  messages: {
-    total: number;
-    matches: SlackSearchMatch[];
-    paging: { count: number; total: number; page: number; pages: number };
-  };
-}
-
-export interface SlackSearchMatch {
-  iid: string;
-  ts: string;
-  text: string;
-  user?: string;
-  username?: string;
-  channel: { id: string; name: string };
-  permalink: string;
-  thread_ts?: string;
-}
-
-export interface SlackConversationsOpenResponse extends SlackApiResponse {
-  channel: { id: string };
-}
-
-export type SlackReactionAddResponse = SlackApiResponse;
-
-export type SlackConversationLeaveResponse = SlackApiResponse;
-
-export type SlackConversationMarkResponse = SlackApiResponse;

package/src/messaging/providers/telegram-bot/adapter.ts

@@ -1,162 +0,0 @@
-/**
- * Telegram Bot messaging provider adapter.
- *
- * Enables proactive outbound messaging to Telegram chats via the gateway's
- * /deliver/telegram endpoint. Unlike Slack/Gmail which use direct API calls
- * with OAuth tokens, Telegram delivery is proxied through the gateway which
- * owns the bot token and handles Telegram API retries.
- *
- * The `token` parameter in MessagingProvider methods is unused for Telegram
- * because delivery is authenticated via the gateway's bearer token, not
- * a per-user OAuth token.
- */
-
-import type { MessagingProvider } from '../../provider.js';
-import type {
-  Conversation,
-  Message,
-  SearchResult,
-  SendResult,
-  ConnectionInfo,
-  ListOptions,
-  HistoryOptions,
-  SearchOptions,
-  SendOptions,
-} from '../../provider-types.js';
-import { getSecureKey } from '../../../security/secure-keys.js';
-import { readHttpToken } from '../../../util/platform.js';
-import { getOrCreateConversation } from '../../../memory/conversation-key-store.js';
-import * as externalConversationStore from '../../../memory/external-conversation-store.js';
-import * as telegram from './client.js';
-
-/** Resolve the gateway base URL, preferring GATEWAY_INTERNAL_BASE_URL if set. */
-function getGatewayUrl(): string {
-  if (process.env.GATEWAY_INTERNAL_BASE_URL) {
-    return process.env.GATEWAY_INTERNAL_BASE_URL.replace(/\/+$/, "");
-  }
-  const port = Number(process.env.GATEWAY_PORT) || 7830;
-  return `http://127.0.0.1:${port}`;
-}
-
-/** Read the runtime HTTP bearer token used to authenticate with the gateway. */
-function getBearerToken(): string {
-  const token = readHttpToken();
-  if (!token) {
-    throw new Error('No runtime HTTP bearer token available — is the daemon running?');
-  }
-  return token;
-}
-
-/** Read the Telegram bot token from the credential vault. */
-function getBotToken(): string | undefined {
-  return getSecureKey('credential:telegram:bot_token');
-}
-
-export const telegramBotMessagingProvider: MessagingProvider = {
-  id: 'telegram',
-  displayName: 'Telegram',
-  credentialService: 'telegram',
-  capabilities: new Set(['send']),
-
-  /**
-   * Custom connectivity check. The standard registry check looks for
-   * credential:telegram:access_token, but the Telegram bot token is
-   * stored as credential:telegram:bot_token. This method lets the
-   * registry detect that Telegram credentials exist.
-   *
-   * Both bot_token and webhook_secret are required — the gateway's
-   * /deliver/telegram endpoint rejects requests without the webhook
-   * secret, so partial credentials would cause every send to fail.
-   */
-  isConnected(): boolean {
-    return getBotToken() !== undefined && !!getSecureKey('credential:telegram:webhook_secret');
-  },
-
-  async testConnection(_token: string): Promise<ConnectionInfo> {
-    const botToken = getBotToken();
-    if (!botToken) {
-      return {
-        connected: false,
-        user: 'unknown',
-        platform: 'telegram',
-        metadata: { error: 'No bot token found. Run the telegram-setup skill.' },
-      };
-    }
-
-    try {
-      const resp = await telegram.getMe(botToken);
-      if (!resp.ok || !resp.result) {
-        return {
-          connected: false,
-          user: 'unknown',
-          platform: 'telegram',
-          metadata: { error: resp.description ?? 'getMe failed' },
-        };
-      }
-
-      return {
-        connected: true,
-        user: resp.result.username ?? resp.result.first_name,
-        platform: 'telegram',
-        metadata: {
-          botId: resp.result.id,
-          botUsername: resp.result.username,
-          botName: resp.result.first_name,
-        },
-      };
-    } catch (e) {
-      return {
-        connected: false,
-        user: 'unknown',
-        platform: 'telegram',
-        metadata: { error: e instanceof Error ? e.message : 'getMe failed' },
-      };
-    }
-  },
-
-  async sendMessage(_token: string, conversationId: string, text: string, _options?: SendOptions): Promise<SendResult> {
-    const gatewayUrl = getGatewayUrl();
-    const bearerToken = getBearerToken();
-
-    await telegram.sendMessage(gatewayUrl, bearerToken, conversationId, text);
-
-    // Upsert external conversation binding so deleted/reset syncs are
-    // resurrected when an outbound message is sent. This ensures the
-    // conversation key mapping and binding exist for the next inbound.
-    try {
-      const sourceChannel = 'telegram';
-      const conversationKey = `${sourceChannel}:${conversationId}`;
-      const { conversationId: internalId } = getOrCreateConversation(conversationKey);
-      externalConversationStore.upsertOutboundBinding({
-        conversationId: internalId,
-        sourceChannel,
-        externalChatId: conversationId,
-      });
-    } catch {
-      // Best-effort — don't fail the send if binding upsert fails
-    }
-
-    return {
-      id: `tg-${Date.now()}`,
-      timestamp: Date.now(),
-      conversationId,
-    };
-  },
-
-  // Telegram Bot API does not support listing conversations. Bots only
-  // interact with chats where users have initiated contact or the bot
-  // has been added to a group.
-  async listConversations(_token: string, _options?: ListOptions): Promise<Conversation[]> {
-    return [];
-  },
-
-  // Telegram Bot API does not provide message history retrieval.
-  async getHistory(_token: string, _conversationId: string, _options?: HistoryOptions): Promise<Message[]> {
-    return [];
-  },
-
-  // Telegram Bot API does not support message search.
-  async search(_token: string, _query: string, _options?: SearchOptions): Promise<SearchResult> {
-    return { total: 0, messages: [], hasMore: false };
-  },
-};