@vellumai/assistant 0.4.42 → 0.4.44

package/src/twitter/router.ts

@@ -1,131 +0,0 @@
-/**
- * Strategy router for Twitter operations.
- * Selects OAuth or browser path based on the caller-provided strategy.
- */
-
-import type { PostTweetResult } from "./client.js";
-import {
-  postTweet as browserPostTweet,
-  SessionExpiredError,
-} from "./client.js";
-import {
-  oauthIsAvailable,
-  oauthPostTweet,
-  oauthSupportsOperation,
-} from "./oauth-client.js";
-
-export type TwitterStrategy = "oauth" | "browser" | "auto";
-
-export interface RoutedResult<T> {
-  result: T;
-  pathUsed: TwitterStrategy;
-}
-
-export interface RoutedError {
-  message: string;
-  pathUsed: TwitterStrategy;
-  suggestAlternative?: TwitterStrategy;
-  alternativeSetupHint?: string;
-}
-
-export async function routedPostTweet(
-  text: string,
-  opts: {
-    inReplyToTweetId?: string;
-    strategy: TwitterStrategy;
-    oauthToken?: string;
-  },
-): Promise<RoutedResult<PostTweetResult>> {
-  const strategy = opts.strategy;
-  const operation = opts.inReplyToTweetId ? "reply" : "post";
-
-  if (strategy === "oauth") {
-    // User explicitly wants OAuth
-    if (!oauthIsAvailable(opts.oauthToken)) {
-      throw Object.assign(
-        new Error(
-          "OAuth is not configured. Provide your X developer credentials here in the chat to set up OAuth, or switch to browser strategy: `assistant config set twitter.operationStrategy browser`.",
-        ),
-        {
-          pathUsed: "oauth" as const,
-          suggestAlternative: "browser" as const,
-        },
-      );
-    }
-    const result = await oauthPostTweet(text, {
-      inReplyToTweetId: opts.inReplyToTweetId,
-      oauthToken: opts.oauthToken!,
-    });
-    return {
-      result: {
-        tweetId: result.tweetId,
-        text: result.text,
-        url: result.url ?? `https://x.com/i/status/${result.tweetId}`,
-      },
-      pathUsed: "oauth",
-    };
-  }
-
-  if (strategy === "browser") {
-    // User explicitly wants browser
-    try {
-      const result = await browserPostTweet(text, {
-        inReplyToTweetId: opts.inReplyToTweetId,
-      });
-      return { result, pathUsed: "browser" };
-    } catch (err) {
-      if (err instanceof SessionExpiredError) {
-        throw Object.assign(err, {
-          pathUsed: "browser" as const,
-          suggestAlternative: "oauth" as const,
-        });
-      }
-      throw err;
-    }
-  }
-
-  // auto strategy: try OAuth first if available and supported, fallback to browser
-  let oauthError: Error | undefined;
-  if (oauthIsAvailable(opts.oauthToken) && oauthSupportsOperation(operation)) {
-    try {
-      const result = await oauthPostTweet(text, {
-        inReplyToTweetId: opts.inReplyToTweetId,
-        oauthToken: opts.oauthToken!,
-      });
-      return {
-        result: {
-          tweetId: result.tweetId,
-          text: result.text,
-          url: result.url ?? `https://x.com/i/status/${result.tweetId}`,
-        },
-        pathUsed: "oauth",
-      };
-    } catch (err) {
-      oauthError = err instanceof Error ? err : new Error(String(err));
-      // Fall through to browser
-    }
-  }
-
-  // Fallback to browser
-  try {
-    const result = await browserPostTweet(text, {
-      inReplyToTweetId: opts.inReplyToTweetId,
-    });
-    return { result, pathUsed: "browser" };
-  } catch (err) {
-    if (err instanceof SessionExpiredError) {
-      throw Object.assign(err, {
-        pathUsed: "auto" as const,
-        oauthError: oauthError?.message,
-      });
-    }
-    if (oauthError) {
-      const browserError = err instanceof Error ? err : new Error(String(err));
-      throw Object.assign(browserError, {
-        pathUsed: "auto" as const,
-        oauthError: oauthError.message,
-      });
-    }
-    throw err;
-  }
-}

package/src/twitter/session.ts

@@ -1,54 +0,0 @@
-/**
- * Twitter session persistence.
- * Delegates to the shared cookie-session primitive for CRUD and cookie header
- * logic; keeps Twitter-specific cookie validation and CSRF extraction.
- */
-
-import type { CookieSession } from "../util/cookie-session.js";
-import {
-  createSessionStore,
-  importFromRecordingBase,
-} from "../util/cookie-session.js";
-import { ConfigError } from "../util/errors.js";
-
-export type TwitterSession = CookieSession;
-
-const store = createSessionStore("twitter");
-
-export const loadSession: () => TwitterSession | null = store.loadSession;
-export const saveSession: (session: TwitterSession) => void = store.saveSession;
-export const clearSession: () => void = store.clearSession;
-export const getCookieHeader: (session: TwitterSession) => string =
-  store.getCookieHeader;
-
-/**
- * Import cookies from a Ride Shotgun recording file.
- */
-export function importFromRecording(recordingPath: string): TwitterSession {
-  try {
-    const session = importFromRecordingBase(recordingPath, (cookieNames) => {
-      // Require the two cookies that prove a logged-in Twitter session:
-      // the auth session cookie and the ct0 CSRF cookie.
-      if (!cookieNames.has("ct0") || !cookieNames.has(`auth_${"token"}`)) {
-        throw new ConfigError(
-          "Recording is missing required Twitter session cookies. " +
-            "Make sure you are logged in to x.com before recording.",
-        );
-      }
-    });
-    saveSession(session);
-    return session;
-  } catch (error) {
-    if (error instanceof ConfigError) throw error;
-    throw new ConfigError(
-      error instanceof Error ? error.message : String(error),
-    );
-  }
-}
-
-/**
- * Get the CSRF token from session cookies (ct0 cookie).
- */
-export function getCsrfToken(session: TwitterSession): string | undefined {
-  return session.cookies.find((c) => c.name === "ct0")?.value;
-}

package/src/util/cookie-session.ts

@@ -1,114 +0,0 @@
-/**
- * Shared cookie-session persistence primitive.
- * Provides session CRUD, cookie header building, and recording import
- * logic reusable across providers (Amazon, Twitter, etc.).
- */
-
-import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-
-import type {
-  ExtractedCredential,
-  SessionRecording,
-} from "../tools/browser/network-recording-types.js";
-import { ConfigError } from "./errors.js";
-import { getDataDir } from "./platform.js";
-
-export interface CookieSession {
-  cookies: ExtractedCredential[];
-  importedAt: string;
-  recordingId?: string;
-}
-
-export interface CookieSessionStore {
-  loadSession(): CookieSession | null;
-  saveSession(session: CookieSession): void;
-  clearSession(): void;
-  getCookieHeader(session: CookieSession): string;
-}
-
-/**
- * Factory that returns session CRUD operations scoped to a provider-specific
- * data directory (e.g. `~/.vellum/workspace/data/<providerKey>/session.json`).
- */
-export function createSessionStore(providerKey: string): CookieSessionStore {
-  function getSessionDir(): string {
-    return join(getDataDir(), providerKey);
-  }
-
-  function getSessionPath(): string {
-    return join(getSessionDir(), "session.json");
-  }
-
-  function loadSession(): CookieSession | null {
-    const path = getSessionPath();
-    if (!existsSync(path)) return null;
-    try {
-      return JSON.parse(readFileSync(path, "utf-8")) as CookieSession;
-    } catch {
-      return null;
-    }
-  }
-
-  function saveSession(session: CookieSession): void {
-    const dir = getSessionDir();
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    const path = getSessionPath();
-    writeFileSync(path, JSON.stringify(session, null, 2), {
-      mode: 0o600,
-    });
-    // writeFileSync mode only applies to newly created files; enforce on existing ones too
-    chmodSync(path, 0o600);
-  }
-
-  function clearSession(): void {
-    const path = getSessionPath();
-    if (existsSync(path)) {
-      unlinkSync(path);
-    }
-  }
-
-  function getCookieHeader(session: CookieSession): string {
-    return session.cookies.map((c) => `${c.name}=${c.value}`).join("; ");
-  }
-
-  return { loadSession, saveSession, clearSession, getCookieHeader };
-}
-
-/**
- * Parse a Ride Shotgun recording file and build a CookieSession,
- * delegating provider-specific cookie validation to the caller.
- *
- * Does NOT call saveSession — the caller saves after wrapping errors
- * with provider-specific error types if needed.
- */
-export function importFromRecordingBase(
-  recordingPath: string,
-  validate: (cookieNames: Set<string>) => void,
-): CookieSession {
-  if (!existsSync(recordingPath)) {
-    throw new ConfigError(`Recording not found: ${recordingPath}`);
-  }
-  const recording = JSON.parse(
-    readFileSync(recordingPath, "utf-8"),
-  ) as SessionRecording;
-  if (!recording.cookies?.length) {
-    throw new ConfigError("Recording contains no cookies");
-  }
-
-  const cookieNames = new Set(recording.cookies.map((c) => c.name));
-  validate(cookieNames);
-
-  return {
-    cookies: recording.cookies,
-    importedAt: new Date().toISOString(),
-    recordingId: recording.id,
-  };
-}

package/src/watcher/providers/slack.ts

@@ -1,282 +0,0 @@
-/**
- * Slack watcher provider — polls for new DMs, mentions, and channel messages.
- *
- * Uses the conversations.history API with a timestamp watermark.
- * On first poll, captures the current time as the watermark (start from "now").
- * Subsequent polls fetch messages newer than the watermark across configured
- * channels, DM channels, and member channels.
- */
-
-import * as slack from "../../messaging/providers/slack/client.js";
-import { withValidToken } from "../../security/token-manager.js";
-import { getLogger } from "../../util/logger.js";
-import { truncate } from "../../util/truncate.js";
-import type {
-  FetchResult,
-  WatcherItem,
-  WatcherProvider,
-} from "../provider-types.js";
-
-const log = getLogger("watcher:slack");
-
-/**
- * Provider-specific configuration for the Slack watcher.
- *
- * When `channels` is specified, those channels are monitored for ALL messages
- * (not just mentions). When omitted or empty, the legacy behavior applies:
- * @mentions in the top 20 member channels.
- *
- * ## Socket Mode Redundancy
- *
- * When the gateway is running with Socket Mode enabled, it already receives
- * real-time events for @mentions, DMs, and active thread replies. The watcher's
- * polling is therefore redundant for those event types. Set
- * `socketModeActive: true` to skip polling for DMs and @mentions that Socket
- * Mode already covers. The watcher will still poll for configured `channels`
- * (all-message monitoring) since Socket Mode only forwards messages where the
- * bot is mentioned or in active threads.
- *
- * @deprecated The polling-based watcher for DMs and @mentions is superseded by
- * Socket Mode in the gateway. Once Socket Mode is confirmed stable, the DM and
- * mention-polling code paths can be removed entirely.
- */
-interface SlackWatcherConfig {
-  /** Channel IDs to watch for all messages (e.g. ["C01234ABCDE"]).
-   *  When non-empty, replaces the default "top 20 member channels for mentions" behavior. */
-  channels?: string[];
-  /** When true, also monitor DMs and group DMs (default: true). */
-  includeDMs?: boolean;
-  /**
-   * When true, skip polling for DMs and @mentions since the gateway's Socket
-   * Mode connection already delivers those events in real-time. The watcher
-   * will still poll explicitly configured `channels` for all-message monitoring.
-   */
-  socketModeActive?: boolean;
-}
-
-function messageToItem(
-  msg: { ts: string; text: string; user?: string; channel: string },
-  eventType: string,
-  channelName: string,
-): WatcherItem {
-  return {
-    externalId: `${msg.channel}:${msg.ts}`,
-    eventType,
-    summary: `Slack ${eventType.replace("slack_", "")}: ${truncate(
-      msg.text,
-      100,
-    )}`,
-    payload: {
-      channel: msg.channel,
-      channelName,
-      ts: msg.ts,
-      user: msg.user,
-      text: msg.text,
-    },
-    timestamp: parseFloat(msg.ts) * 1000,
-  };
-}
-
-/**
- * Poll a single channel for new messages since the watermark, paginating
- * through all results. Returns items and the latest timestamp seen.
- */
-async function pollChannel(
-  token: string,
-  channelId: string,
-  channelName: string,
-  eventType: string,
-  watermark: string,
-  userId: string,
-): Promise<{ items: WatcherItem[]; latestTs: string }> {
-  const items: WatcherItem[] = [];
-  let channelLatestTs = watermark;
-  let cursor: string | undefined;
-
-  do {
-    const histResp = await slack.conversationHistory(
-      token,
-      channelId,
-      100,
-      undefined,
-      watermark,
-      cursor,
-    );
-    for (const msg of histResp.messages) {
-      if (msg.user === userId) continue;
-      if (parseFloat(msg.ts) <= parseFloat(watermark)) continue;
-
-      items.push(
-        messageToItem({ ...msg, channel: channelId }, eventType, channelName),
-      );
-
-      if (parseFloat(msg.ts) > parseFloat(channelLatestTs)) {
-        channelLatestTs = msg.ts;
-      }
-    }
-    cursor = histResp.has_more
-      ? histResp.response_metadata?.next_cursor
-      : undefined;
-  } while (cursor);
-
-  return { items, latestTs: channelLatestTs };
-}
-
-export const slackProvider: WatcherProvider = {
-  id: "slack",
-  displayName: "Slack",
-  requiredCredentialService: "integration:slack",
-
-  async getInitialWatermark(_credentialService: string): Promise<string> {
-    // Start from "now" — use current epoch seconds as the timestamp watermark
-    return String(Date.now() / 1000);
-  },
-
-  async fetchNew(
-    credentialService: string,
-    watermark: string | null,
-    config: Record<string, unknown>,
-    _watcherKey: string,
-  ): Promise<FetchResult> {
-    return withValidToken(credentialService, async (token) => {
-      if (!watermark) {
-        return { items: [], watermark: String(Date.now() / 1000) };
-      }
-
-      const slackConfig = config as SlackWatcherConfig;
-
-      // Normalize channels: config is persisted as untyped JSON, so a caller
-      // could provide a bare string instead of an array. Coerce to string[]
-      // and filter out any non-string entries to prevent iterating characters.
-      const rawChannels = slackConfig.channels;
-      const watchChannels: string[] = (
-        Array.isArray(rawChannels)
-          ? rawChannels.filter((ch): ch is string => typeof ch === "string")
-          : typeof rawChannels === "string"
-            ? [rawChannels]
-            : []
-      ).filter((ch) => ch.trim().length > 0);
-
-      const includeDMs =
-        typeof slackConfig.includeDMs === "boolean"
-          ? slackConfig.includeDMs
-          : true;
-
-      const socketModeActive = slackConfig.socketModeActive === true;
-      if (socketModeActive) {
-        log.info(
-          "Socket Mode active — skipping DM and @mention polling (handled by gateway)",
-        );
-      }
-
-      const authResp = await slack.authTest(token);
-      const userId = authResp.user_id;
-
-      const items: WatcherItem[] = [];
-      let latestTs = watermark;
-
-      // ── DM / Group DM polling ──────────────────────────────────────
-      // Skip when Socket Mode is active — the gateway already delivers DM events in real-time.
-      if (includeDMs && !socketModeActive) {
-        const convResp = await slack.listConversations(
-          token,
-          "im,mpim",
-          false,
-          100,
-        );
-        for (const channel of convResp.channels) {
-          try {
-            const channelName = channel.name ?? channel.user ?? channel.id;
-            const eventType = channel.is_im ? "slack_dm" : "slack_group_dm";
-            const result = await pollChannel(
-              token,
-              channel.id,
-              channelName,
-              eventType,
-              watermark,
-              userId,
-            );
-            items.push(...result.items);
-            if (parseFloat(result.latestTs) > parseFloat(latestTs)) {
-              latestTs = result.latestTs;
-            }
-          } catch (err) {
-            log.debug(
-              { channelId: channel.id, err },
-              "Skipping channel in Slack watcher",
-            );
-          }
-        }
-      }
-
-      // ── Configured channel polling (all messages) ──────────────────
-      if (watchChannels.length > 0) {
-        for (const channelId of watchChannels) {
-          try {
-            const result = await pollChannel(
-              token,
-              channelId,
-              channelId,
-              "slack_channel_message",
-              watermark,
-              userId,
-            );
-            items.push(...result.items);
-            if (parseFloat(result.latestTs) > parseFloat(latestTs)) {
-              latestTs = result.latestTs;
-            }
-          } catch (err) {
-            log.debug(
-              { channelId, err },
-              "Skipping configured channel in Slack watcher",
-            );
-          }
-        }
-      } else if (!socketModeActive) {
-        // Legacy behavior: check top 20 member channels for @mentions only.
-        // Skipped when Socket Mode is active — the gateway already delivers
-        // app_mention events in real-time.
-        const memberConvResp = await slack.listConversations(
-          token,
-          "public_channel,private_channel",
-          true,
-          50,
-        );
-        for (const channel of memberConvResp.channels.slice(0, 20)) {
-          try {
-            const histResp = await slack.conversationHistory(
-              token,
-              channel.id,
-              5,
-              undefined,
-              watermark,
-            );
-            for (const msg of histResp.messages) {
-              if (parseFloat(msg.ts) <= parseFloat(watermark)) continue;
-              if (msg.text.includes(`<@${userId}>`)) {
-                items.push(
-                  messageToItem(
-                    { ...msg, channel: channel.id },
-                    "slack_mention",
-                    channel.name ?? channel.id,
-                  ),
-                );
-                if (parseFloat(msg.ts) > parseFloat(latestTs)) {
-                  latestTs = msg.ts;
-                }
-              }
-            }
-          } catch {
-            // Skip unreadable channels
-          }
-        }
-      }
-
-      log.info(
-        { count: items.length, watermark: latestTs },
-        "Slack: fetched new messages",
-      );
-      return { items, watermark: latestTs };
-    });
-  },
-};