@vellumai/assistant 0.6.2 → 0.6.4

package/src/messaging/providers/slack/__tests__/adapter-token-routing.test.ts

@@ -0,0 +1,282 @@
+/**
+ * Guard test that verifies the Slack adapter routes reads and writes through
+ * the correct cached auth.
+ *
+ * Covers the bot-token-only case (reads and writes both use the bot token),
+ * the dual-token case (bot + user): reads MUST use the user token while
+ * content-creating writes (postMessage) MUST stay on the bot token so posts
+ * come from the bot identity, and the runtime fallback when a stored user
+ * token is rejected with an auth error.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { OAuthConnection } from "../../../../oauth/connection.js";
+import { credentialKey } from "../../../../security/credential-key.js";
+
+// ── Module mocks ────────────────────────────────────────────────────────────
+
+const getSecureKeyAsyncMock = mock(
+  async (_key: string): Promise<string | null> => null,
+);
+mock.module("../../../../security/secure-keys.js", () => ({
+  getSecureKeyAsync: getSecureKeyAsyncMock,
+}));
+
+// OAuth helpers are exercised only when no bot_token is cached. The adapter
+// imports them at module load — route them through a stub that signals any
+// OAuth fallback with a distinctive error so tests can assert on it.
+const OAUTH_FALLBACK_SENTINEL = "OAUTH_FALLBACK_NOT_STUBBED";
+mock.module("../../../../oauth/connection-resolver.js", () => ({
+  resolveOAuthConnection: async (): Promise<OAuthConnection> => {
+    throw new Error(OAUTH_FALLBACK_SENTINEL);
+  },
+}));
+mock.module("../../../../oauth/oauth-store.js", () => ({
+  isProviderConnected: async () => false,
+}));
+
+// Stub contact DB access so the adapter doesn't touch SQLite during the test.
+mock.module("../../../../contacts/contact-store.js", () => ({
+  findContactChannel: () => undefined,
+}));
+mock.module("../../../../contacts/contacts-write.js", () => ({
+  upsertContactChannel: () => {},
+}));
+
+import { slackProvider } from "../adapter.js";
+
+// ── fetch capture ───────────────────────────────────────────────────────────
+
+type CapturedRequest = {
+  url: string;
+  method: string;
+  authorization: string | null;
+};
+
+const captured: CapturedRequest[] = [];
+const originalFetch = globalThis.fetch;
+
+function installFetchStub() {
+  globalThis.fetch = (async (
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ): Promise<Response> => {
+    const url =
+      typeof input === "string"
+        ? input
+        : input instanceof URL
+          ? input.toString()
+          : input.url;
+    const method = (init?.method ?? "GET").toUpperCase();
+    const headers = new Headers(init?.headers ?? {});
+    captured.push({
+      url,
+      method,
+      authorization: headers.get("authorization"),
+    });
+
+    // Craft a minimal OK Slack API envelope per endpoint so the adapter's
+    // post-call mapping doesn't throw.
+    const body = fakeSlackResponse(url);
+    return new Response(JSON.stringify(body), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  }) as typeof fetch;
+}
+
+function fakeSlackResponse(url: string): Record<string, unknown> {
+  if (url.includes("/conversations.list")) {
+    return { ok: true, channels: [], response_metadata: { next_cursor: "" } };
+  }
+  if (url.includes("/conversations.history")) {
+    return { ok: true, messages: [], has_more: false };
+  }
+  if (url.includes("/conversations.mark")) {
+    return { ok: true };
+  }
+  if (url.includes("/chat.postMessage")) {
+    return { ok: true, ts: "1700000000.000100", channel: "C123" };
+  }
+  // Default envelope for any other method the adapter might call.
+  return { ok: true };
+}
+
+// ── Test setup ──────────────────────────────────────────────────────────────
+
+const BOT_TOKEN = "xoxb-BOT";
+const USER_TOKEN = "xoxp-USER";
+
+describe("Slack adapter token routing", () => {
+  beforeEach(() => {
+    captured.length = 0;
+    getSecureKeyAsyncMock.mockReset();
+    getSecureKeyAsyncMock.mockImplementation(async (key: string) => {
+      if (key === credentialKey("slack_channel", "bot_token")) return BOT_TOKEN;
+      return null;
+    });
+    installFetchStub();
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  test("bot-token only: reads and writes both authenticate with the bot token (regression guard for pre-user-token behavior)", async () => {
+    // With only a bot token stored, reads must fall back to the bot token
+    // so the adapter keeps working for installs that haven't re-consented
+    // the user scope. Writes stay on the bot token always.
+    const resolved = await slackProvider.resolveConnection!();
+    expect(resolved).toBeUndefined();
+
+    // Read path: listConversations → /conversations.list must use bot token.
+    await slackProvider.listConversations(undefined);
+    const readCall = captured.find((c) =>
+      c.url.includes("/conversations.list"),
+    );
+    expect(readCall).toBeDefined();
+    expect(readCall!.authorization).toBe(`Bearer ${BOT_TOKEN}`);
+
+    // Write path: sendMessage → /chat.postMessage must also use bot token.
+    await slackProvider.sendMessage(undefined, "C123", "hello");
+    const writeCall = captured.find((c) => c.url.includes("/chat.postMessage"));
+    expect(writeCall).toBeDefined();
+    expect(writeCall!.authorization).toBe(`Bearer ${BOT_TOKEN}`);
+  });
+
+  test("bot + user tokens: reads authenticate with the user token, writes with the bot token", async () => {
+    // With both tokens stored, reads MUST flip to the user token so the
+    // adapter can see channels the user is in but the bot isn't. Writes
+    // MUST stay on the bot token so posts come from the bot identity.
+    getSecureKeyAsyncMock.mockImplementation(async (key: string) => {
+      if (key === credentialKey("slack_channel", "bot_token")) return BOT_TOKEN;
+      if (key === credentialKey("slack_channel", "user_token"))
+        return USER_TOKEN;
+      return null;
+    });
+
+    const resolved = await slackProvider.resolveConnection!();
+    expect(resolved).toBeUndefined();
+
+    // Reads: listConversations → user token.
+    await slackProvider.listConversations(undefined);
+    const listCall = captured.find((c) =>
+      c.url.includes("/conversations.list"),
+    );
+    expect(listCall).toBeDefined();
+    expect(listCall!.authorization).toBe(`Bearer ${USER_TOKEN}`);
+
+    // Reads: getHistory → user token.
+    await slackProvider.getHistory(undefined, "C123");
+    const historyCall = captured.find((c) =>
+      c.url.includes("/conversations.history"),
+    );
+    expect(historyCall).toBeDefined();
+    expect(historyCall!.authorization).toBe(`Bearer ${USER_TOKEN}`);
+
+    // Writes: sendMessage → bot token.
+    await slackProvider.sendMessage(undefined, "C123", "hello");
+    const sendCall = captured.find((c) => c.url.includes("/chat.postMessage"));
+    expect(sendCall).toBeDefined();
+    expect(sendCall!.authorization).toBe(`Bearer ${BOT_TOKEN}`);
+
+    // markRead → user token. conversations.mark sets the read cursor for
+    // the authenticated identity, so it must use the same token whose unread
+    // counts the adapter exposes.
+    await slackProvider.markRead!(undefined, "C123", "1700000000.000100");
+    const markCall = captured.find((c) =>
+      c.url.includes("/conversations.mark"),
+    );
+    expect(markCall).toBeDefined();
+    expect(markCall!.authorization).toBe(`Bearer ${USER_TOKEN}`);
+  });
+
+  test("user token rejected: read calls fall back to bot token and stay on it", async () => {
+    // If the cached user token is revoked/expired, the next read returns
+    // invalid_auth (HTTP 200 with ok:false). The adapter must retry the call
+    // with the bot token and reset the read cache so subsequent reads in the
+    // same session don't re-hit the failure path.
+    getSecureKeyAsyncMock.mockImplementation(async (key: string) => {
+      if (key === credentialKey("slack_channel", "bot_token")) return BOT_TOKEN;
+      if (key === credentialKey("slack_channel", "user_token"))
+        return USER_TOKEN;
+      return null;
+    });
+
+    // Replace the default fetch stub: first user-token call to history fails
+    // with invalid_auth; everything else succeeds.
+    let userTokenHistoryCalls = 0;
+    globalThis.fetch = (async (
+      input: RequestInfo | URL,
+      init?: RequestInit,
+    ): Promise<Response> => {
+      const url =
+        typeof input === "string"
+          ? input
+          : input instanceof URL
+            ? input.toString()
+            : input.url;
+      const headers = new Headers(init?.headers ?? {});
+      const auth = headers.get("authorization");
+      captured.push({
+        url,
+        method: (init?.method ?? "GET").toUpperCase(),
+        authorization: auth,
+      });
+      if (
+        url.includes("/conversations.history") &&
+        auth === `Bearer ${USER_TOKEN}`
+      ) {
+        userTokenHistoryCalls += 1;
+        return new Response(
+          JSON.stringify({ ok: false, error: "invalid_auth" }),
+          { status: 200, headers: { "Content-Type": "application/json" } },
+        );
+      }
+      return new Response(JSON.stringify(fakeSlackResponse(url)), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }) as typeof fetch;
+
+    const resolved = await slackProvider.resolveConnection!();
+    expect(resolved).toBeUndefined();
+
+    // First read: tries user token, fails, retries with bot token.
+    await slackProvider.getHistory(undefined, "C123");
+    expect(userTokenHistoryCalls).toBe(1);
+    const historyCalls = captured.filter((c) =>
+      c.url.includes("/conversations.history"),
+    );
+    expect(historyCalls).toHaveLength(2);
+    expect(historyCalls[0].authorization).toBe(`Bearer ${USER_TOKEN}`);
+    expect(historyCalls[1].authorization).toBe(`Bearer ${BOT_TOKEN}`);
+
+    // Subsequent read: cache reset, only bot token is used (no retry needed).
+    captured.length = 0;
+    await slackProvider.getHistory(undefined, "C456");
+    const next = captured.filter((c) =>
+      c.url.includes("/conversations.history"),
+    );
+    expect(next).toHaveLength(1);
+    expect(next[0].authorization).toBe(`Bearer ${BOT_TOKEN}`);
+  });
+
+  test("user-token only (no bot token): falls through to the OAuth path", async () => {
+    // Edge case: if only a user token is stored with no bot token, we do NOT
+    // have Socket Mode credentials, so resolveConnection() falls through to
+    // the legacy OAuth path. The mocked resolveOAuthConnection throws, which
+    // documents current behavior — user-token-only without an OAuth
+    // connection is not a supported install configuration.
+    getSecureKeyAsyncMock.mockImplementation(async (key: string) => {
+      if (key === credentialKey("slack_channel", "user_token"))
+        return USER_TOKEN;
+      return null;
+    });
+
+    await expect(slackProvider.resolveConnection!()).rejects.toThrow(
+      OAUTH_FALLBACK_SENTINEL,
+    );
+  });
+});

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

@@ -25,6 +25,7 @@ import type {
   SendResult,
 } from "../../provider-types.js";
 import * as slack from "./client.js";
+import { SlackApiError } from "./client.js";
 import type {
   SlackConversation,
   SlackMessage,
@@ -35,27 +36,95 @@ import type {
 const userNameCache = new Map<string, string>();
 
 /**
- * Cached auth resolved during resolveConnection().
+ * Cached auth resolved during resolveConnection(), split by direction.
  *
- * For Socket Mode this holds a raw bot token string; for OAuth it holds the
+ * Read and write auth are tracked separately so reads can use a user OAuth
+ * token (xoxp-) — giving visibility into channels the user is in but the
+ * bot isn't — while writes continue to use the bot token (xoxb-) so posts
+ * come from the bot identity. When no user_token is stored, reads fall
+ * back to the bot token. If a stored user_token is rejected at runtime
+ * (revoked/expired), the read cache is reset to the bot token for the rest
+ * of the session — see runReadWithFallback().
+ *
+ * For Socket Mode these hold a raw bot token string; for OAuth they hold the
  * OAuthConnection. The Slack client functions accept both via their own
- * OAuthConnection | string union, so we can pass this value through directly.
+ * OAuthConnection | string union, so we can pass the cached value through
+ * directly.
  */
-let _cachedSlackAuth: OAuthConnection | string | null = null;
+let _cachedSlackWriteAuth: OAuthConnection | string | null = null;
+let _cachedSlackReadAuth: OAuthConnection | string | null = null;
 
 /**
  * Get the Slack auth value to pass to Slack client functions.
  * Prefers the explicit connection from the caller; falls back to the cached
- * value set during resolveConnection().
+ * write auth. Callers that care about read vs write semantics should use
+ * getReadAuth() / getWriteAuth() directly.
  */
 function getSlackAuth(connection?: OAuthConnection): OAuthConnection | string {
   if (connection) return connection;
-  if (_cachedSlackAuth) return _cachedSlackAuth;
+  if (_cachedSlackWriteAuth) return _cachedSlackWriteAuth;
+  if (_cachedSlackReadAuth) return _cachedSlackReadAuth;
   throw new Error(
     "Slack: no connection or cached token available. Was resolveConnection() called?",
   );
 }
 
+/**
+ * Resolve auth for read operations (listConversations, getHistory,
+ * conversation replies, search, users.info lookups).
+ */
+function getReadAuth(connection?: OAuthConnection): OAuthConnection | string {
+  if (connection) return connection;
+  if (_cachedSlackReadAuth) return _cachedSlackReadAuth;
+  return getSlackAuth(connection);
+}
+
+// SAFETY: content-creating writes (postMessage, updateMessage, deleteMessage,
+// reactions) MUST use the bot token. Using the user token would post as the
+// user, not as the bot. State-changing methods that target the authenticated
+// identity's own state (e.g. conversations.mark) should use the read auth so
+// the cursor matches the perspective the adapter exposes.
+/**
+ * Resolve auth for content-creating write operations (postMessage and any
+ * future reactions, joins, leaves, updates, or deletes).
+ */
+function getWriteAuth(connection?: OAuthConnection): OAuthConnection | string {
+  if (connection) return connection;
+  if (_cachedSlackWriteAuth) return _cachedSlackWriteAuth;
+  return getSlackAuth(connection);
+}
+
+/**
+ * Run a read-path Slack call, falling back to the bot token if the cached
+ * user token is rejected with an auth error. On fallback, the read cache is
+ * reset to the bot token so subsequent reads in this session don't re-pay
+ * the round trip. Caller-supplied connections are passed through unchanged
+ * (no fallback) since the caller owns that auth.
+ */
+async function runReadWithFallback<T>(
+  connection: OAuthConnection | undefined,
+  call: (auth: OAuthConnection | string) => Promise<T>,
+): Promise<T> {
+  if (connection) return call(connection);
+  const auth = getReadAuth(undefined);
+  const usingUserToken =
+    _cachedSlackWriteAuth !== null && _cachedSlackReadAuth !== _cachedSlackWriteAuth;
+  try {
+    return await call(auth);
+  } catch (err) {
+    if (
+      usingUserToken &&
+      err instanceof SlackApiError &&
+      err.status === 401 &&
+      _cachedSlackWriteAuth
+    ) {
+      _cachedSlackReadAuth = _cachedSlackWriteAuth;
+      return call(_cachedSlackWriteAuth);
+    }
+    throw err;
+  }
+}
+
 async function resolveUserName(
   auth: OAuthConnection | string,
   userId: string,
@@ -165,7 +234,7 @@ export const slackProvider: MessagingProvider = {
   id: "slack",
   displayName: "Slack",
   credentialService: "slack",
-  capabilities: new Set(["reactions", "threads", "leave_channel"]),
+  capabilities: new Set(["reactions", "threads", "join_channel", "leave_channel"]),
 
   async isConnected(): Promise<boolean> {
     // Socket Mode: check for bot token directly in credential store.
@@ -184,16 +253,26 @@ export const slackProvider: MessagingProvider = {
   ): Promise<OAuthConnection | undefined> {
     // Socket Mode: cache the raw bot token for use in adapter methods.
     // Token presence is sufficient — no connection row required.
+    //
+    // When a user_token is also stored, prefer it for reads so the adapter
+    // can see channels the user is in but the bot isn't (conversations.list,
+    // conversations.history, search.messages). Writes always stay on the
+    // bot token — see SAFETY note above getWriteAuth().
     const botToken = await getSecureKeyAsync(
       credentialKey("slack_channel", "bot_token"),
     );
+    const userToken = await getSecureKeyAsync(
+      credentialKey("slack_channel", "user_token"),
+    );
     if (botToken) {
-      _cachedSlackAuth = botToken;
+      _cachedSlackWriteAuth = botToken;
+      _cachedSlackReadAuth = userToken ?? botToken;
       return undefined;
     }
     // Preserve existing OAuth path for backwards compat.
     const conn = await resolveOAuthConnection("slack", { account });
-    _cachedSlackAuth = conn;
+    _cachedSlackWriteAuth = conn;
+    _cachedSlackReadAuth = conn;
     return conn;
   },
 
@@ -212,7 +291,6 @@ export const slackProvider: MessagingProvider = {
     connection: OAuthConnection | undefined,
     options?: ListOptions,
   ): Promise<Conversation[]> {
-    const auth = getSlackAuth(connection);
     const typeMap: Record<string, string> = {
       channel: "public_channel,private_channel",
       dm: "im",
@@ -228,16 +306,32 @@ export const slackProvider: MessagingProvider = {
 
     const conversations: Conversation[] = [];
     let cursor: string | undefined = options?.cursor;
+    let auth = getReadAuth(connection);
 
-    // Paginate through all results
+    // Paginate through all results. The first page is wrapped in
+    // runReadWithFallback so that a 401 on the user token retries with the
+    // bot token before we commit to the rest of the pagination.
+    let firstPage = true;
     do {
-      const resp = await slack.listConversations(
-        auth,
-        types,
-        options?.excludeArchived ?? true,
-        options?.limit ?? 200,
-        cursor,
-      );
+      const resp = firstPage
+        ? await runReadWithFallback(connection, async (a) => {
+            auth = a;
+            return slack.listConversations(
+              a,
+              types,
+              options?.excludeArchived ?? true,
+              options?.limit ?? 200,
+              cursor,
+            );
+          })
+        : await slack.listConversations(
+            auth,
+            types,
+            options?.excludeArchived ?? true,
+            options?.limit ?? 200,
+            cursor,
+          );
+      firstPage = false;
       conversations.push(...resp.channels.map(mapConversation));
       cursor = resp.response_metadata?.next_cursor || undefined;
     } while (
@@ -280,14 +374,17 @@ export const slackProvider: MessagingProvider = {
     conversationId: string,
     options?: HistoryOptions,
   ): Promise<Message[]> {
-    const auth = getSlackAuth(connection);
-    const resp = await slack.conversationHistory(
-      auth,
-      conversationId,
-      options?.limit ?? 50,
-      options?.before,
-      options?.after,
-    );
+    let auth: OAuthConnection | string = getReadAuth(connection);
+    const resp = await runReadWithFallback(connection, async (a) => {
+      auth = a;
+      return slack.conversationHistory(
+        a,
+        conversationId,
+        options?.limit ?? 50,
+        options?.before,
+        options?.after,
+      );
+    });
 
     const messages: Message[] = [];
     for (const msg of resp.messages) {
@@ -303,8 +400,9 @@ export const slackProvider: MessagingProvider = {
     query: string,
     options?: SearchOptions,
   ): Promise<SearchResult> {
-    const auth = getSlackAuth(connection);
-    const resp = await slack.searchMessages(auth, query, options?.count ?? 20);
+    const resp = await runReadWithFallback(connection, (auth) =>
+      slack.searchMessages(auth, query, options?.count ?? 20),
+    );
     return {
       total: resp.messages.total,
       messages: resp.messages.matches.map(mapSearchMatch),
@@ -318,7 +416,7 @@ export const slackProvider: MessagingProvider = {
     text: string,
     options?: SendOptions,
   ): Promise<SendResult> {
-    const auth = getSlackAuth(connection);
+    const auth = getWriteAuth(connection);
     const resp = await slack.postMessage(
       auth,
       conversationId,
@@ -338,13 +436,16 @@ export const slackProvider: MessagingProvider = {
     threadId: string,
     options?: HistoryOptions,
   ): Promise<Message[]> {
-    const auth = getSlackAuth(connection);
-    const resp = await slack.conversationReplies(
-      auth,
-      conversationId,
-      threadId,
-      options?.limit ?? 50,
-    );
+    let auth: OAuthConnection | string = getReadAuth(connection);
+    const resp = await runReadWithFallback(connection, async (a) => {
+      auth = a;
+      return slack.conversationReplies(
+        a,
+        conversationId,
+        threadId,
+        options?.limit ?? 50,
+      );
+    });
     const messages: Message[] = [];
     for (const msg of resp.messages) {
       const name = await resolveUserName(auth, msg.user ?? "");
@@ -358,9 +459,13 @@ export const slackProvider: MessagingProvider = {
     conversationId: string,
     messageId?: string,
   ): Promise<void> {
-    const auth = getSlackAuth(connection);
+    // conversations.mark sets the read cursor for the authenticated identity.
+    // It must use the same token as the read path so the cursor matches the
+    // perspective the adapter exposes (unread counts in listConversations).
     // Slack's conversations.mark requires a timestamp — use the provided one or "now"
     const ts = messageId ?? String(Date.now() / 1000);
-    await slack.conversationMark(auth, conversationId, ts);
+    await runReadWithFallback(connection, (auth) =>
+      slack.conversationMark(auth, conversationId, ts),
+    );
   },
 };

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

@@ -18,6 +18,7 @@ import type {
   SlackChatUpdateResponse,
   SlackConversationHistoryResponse,
   SlackConversationInfoResponse,
+  SlackConversationJoinResponse,
   SlackConversationLeaveResponse,
   SlackConversationMarkResponse,
   SlackConversationRepliesResponse,
@@ -517,6 +518,20 @@ export async function deleteMessage(
   );
 }
 
+export async function joinConversation(
+  connectionOrToken: OAuthConnection | string,
+  channel: string,
+): Promise<SlackConversationJoinResponse> {
+  return request<SlackConversationJoinResponse>(
+    connectionOrToken,
+    "conversations.join",
+    undefined,
+    {
+      channel,
+    },
+  );
+}
+
 export async function leaveConversation(
   connectionOrToken: OAuthConnection | string,
   channel: string,
@@ -530,3 +545,4 @@ export async function leaveConversation(
     },
   );
 }
+

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

@@ -119,6 +119,10 @@ export interface SlackConversationsOpenResponse extends SlackApiResponse {
 
 export type SlackReactionAddResponse = SlackApiResponse;
 
+export type SlackConversationJoinResponse = SlackApiResponse & {
+  channel?: SlackConversation;
+};
+
 export type SlackConversationLeaveResponse = SlackApiResponse;
 
 export interface SlackChatDeleteResponse extends SlackApiResponse {

package/src/notifications/decision-engine.ts

@@ -61,9 +61,9 @@ const PROMPT_VERSION = "v4";
 /**
  * Maximum character budget for identity context injected into the notification
  * decision prompt. We truncate to prevent oversized prompts when SOUL.md /
- * IDENTITY.md / USER.md are large — exceeding the provider context window
- * would cause the LLM call to fail and silently degrade to deterministic
- * fallback for all notifications.
+ * IDENTITY.md / users/<slug>.md are large — exceeding the provider context
+ * window would cause the LLM call to fail and silently degrade to
+ * deterministic fallback for all notifications.
  */
 const MAX_IDENTITY_CONTEXT_CHARS = 2000;
 

package/src/notifications/signal.ts

@@ -97,6 +97,11 @@ export const NOTIFICATION_SOURCE_EVENT_NAMES = [
     id: "voice.response_ready",
     description: "Voice response ready for playback",
   },
+  {
+    id: "credential.health_alert",
+    description:
+      "OAuth credential health issue detected (expired, revoked, missing scopes)",
+  },
 ] as const;
 
 export type NotificationSourceEventName =