@vellumai/assistant 0.6.4 → 0.6.6

package/src/messaging/providers/slack/backfill.test.ts

@@ -0,0 +1,257 @@
+/**
+ * Tests for the daemon-side Slack backfill helpers.
+ *
+ * Verifies:
+ *  - Pass-through of channelId, threadTs, and the `before` cursor.
+ *  - Default limit of 50 when none is supplied; explicit limits override.
+ *  - resolveConnection() is invoked once per call so any cached read/write
+ *    auth mutation lands before the adapter method runs.
+ *  - Transient failure modes (timeout, 401, generic Slack API error, missing
+ *    connection) return [] instead of propagating the error.
+ *  - `channel_not_found` errors are rethrown so wrong-workspace configuration
+ *    bugs in multi-account setups surface loudly rather than silently
+ *    dropping context.
+ *  - `account` is threaded through to resolveConnection() when provided.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { OAuthConnection } from "../../../oauth/connection.js";
+import type { Message } from "../../provider-types.js";
+
+// ── Module mocks ────────────────────────────────────────────────────────────
+
+type ResolveConnectionFn = (
+  account?: string,
+) => Promise<OAuthConnection | undefined>;
+type GetHistoryFn = (
+  connection: OAuthConnection | undefined,
+  conversationId: string,
+  options?: { limit?: number; before?: string; after?: string },
+) => Promise<Message[]>;
+type GetThreadRepliesFn = (
+  connection: OAuthConnection | undefined,
+  conversationId: string,
+  threadId: string,
+  options?: { limit?: number },
+) => Promise<Message[]>;
+
+const resolveConnectionMock = mock<ResolveConnectionFn>(async () => undefined);
+const getHistoryMock = mock<GetHistoryFn>(async () => []);
+const getThreadRepliesMock = mock<GetThreadRepliesFn>(async () => []);
+
+mock.module("./adapter.js", () => ({
+  slackProvider: {
+    id: "slack",
+    displayName: "Slack",
+    credentialService: "slack",
+    capabilities: new Set(["threads"]),
+    resolveConnection: (account?: string) => resolveConnectionMock(account),
+    getHistory: (
+      connection: OAuthConnection | undefined,
+      conversationId: string,
+      options?: { limit?: number; before?: string; after?: string },
+    ) => getHistoryMock(connection, conversationId, options),
+    getThreadReplies: (
+      connection: OAuthConnection | undefined,
+      conversationId: string,
+      threadId: string,
+      options?: { limit?: number },
+    ) => getThreadRepliesMock(connection, conversationId, threadId, options),
+    // Stub the rest of the MessagingProvider surface as no-ops; the backfill
+    // helpers should never reach for these.
+    testConnection: async () => {
+      throw new Error("not used");
+    },
+    listConversations: async () => [],
+    search: async () => ({ total: 0, messages: [], hasMore: false }),
+    sendMessage: async () => {
+      throw new Error("not used");
+    },
+  },
+}));
+
+import { backfillDm, backfillThread } from "./backfill.js";
+
+function makeMessage(overrides: Partial<Message> = {}): Message {
+  return {
+    id: "1700000000.000100",
+    conversationId: "C123",
+    sender: { id: "U1", name: "Alice" },
+    text: "hello",
+    timestamp: 1700000000000,
+    platform: "slack",
+    ...overrides,
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("backfillThread", () => {
+  beforeEach(() => {
+    resolveConnectionMock.mockReset();
+    resolveConnectionMock.mockImplementation(async () => undefined);
+    getThreadRepliesMock.mockReset();
+    getThreadRepliesMock.mockImplementation(async () => []);
+    getHistoryMock.mockReset();
+    getHistoryMock.mockImplementation(async () => []);
+  });
+
+  test("passes channelId/threadTs through and defaults limit to 50", async () => {
+    const reply = makeMessage({
+      id: "1700000000.000200",
+      threadId: "1700000000.000100",
+    });
+    getThreadRepliesMock.mockImplementation(async () => [reply]);
+
+    const out = await backfillThread("C123", "1700000000.000100");
+
+    expect(resolveConnectionMock).toHaveBeenCalledTimes(1);
+    expect(getThreadRepliesMock).toHaveBeenCalledTimes(1);
+    const [conn, channel, thread, opts] = getThreadRepliesMock.mock.calls[0];
+    expect(conn).toBeUndefined();
+    expect(channel).toBe("C123");
+    expect(thread).toBe("1700000000.000100");
+    expect(opts).toEqual({ limit: 50 });
+    expect(out).toEqual([reply]);
+  });
+
+  test("respects explicit limit override", async () => {
+    await backfillThread("C123", "1700000000.000100", { limit: 10 });
+    const [, , , opts] = getThreadRepliesMock.mock.calls[0];
+    expect(opts).toEqual({ limit: 10 });
+  });
+
+  test("returns [] when getThreadReplies throws (generic Slack API error)", async () => {
+    getThreadRepliesMock.mockImplementation(async () => {
+      throw new Error("Slack API error: ratelimited");
+    });
+    const out = await backfillThread("C123", "1700000000.000100");
+    expect(out).toEqual([]);
+  });
+
+  test("rethrows channel_not_found so wrong-workspace config surfaces", async () => {
+    getThreadRepliesMock.mockImplementation(async () => {
+      throw new Error("Slack API error: channel_not_found");
+    });
+    await expect(backfillThread("C123", "1700000000.000100")).rejects.toThrow(
+      /channel_not_found/,
+    );
+  });
+
+  test("threads `account` through to resolveConnection", async () => {
+    await backfillThread("C123", "1700000000.000100", {
+      account: "team-acme",
+    });
+    expect(resolveConnectionMock).toHaveBeenCalledTimes(1);
+    expect(resolveConnectionMock.mock.calls[0][0]).toBe("team-acme");
+  });
+
+  test("returns [] when getThreadReplies throws (auth error)", async () => {
+    getThreadRepliesMock.mockImplementation(async () => {
+      const err = new Error("Slack API HTTP 401");
+      Object.assign(err, { status: 401 });
+      throw err;
+    });
+    const out = await backfillThread("C123", "1700000000.000100");
+    expect(out).toEqual([]);
+  });
+
+  test("returns [] when getThreadReplies throws (timeout)", async () => {
+    getThreadRepliesMock.mockImplementation(async () => {
+      throw new Error("ETIMEDOUT");
+    });
+    const out = await backfillThread("C123", "1700000000.000100");
+    expect(out).toEqual([]);
+  });
+
+  test("returns [] when resolveConnection throws (missing connection)", async () => {
+    resolveConnectionMock.mockImplementation(async () => {
+      throw new Error("no connection available");
+    });
+    const out = await backfillThread("C123", "1700000000.000100");
+    expect(out).toEqual([]);
+    // resolveConnection failed before getThreadReplies could be reached.
+    expect(getThreadRepliesMock).not.toHaveBeenCalled();
+  });
+});
+
+describe("backfillDm", () => {
+  beforeEach(() => {
+    resolveConnectionMock.mockReset();
+    resolveConnectionMock.mockImplementation(async () => undefined);
+    getHistoryMock.mockReset();
+    getHistoryMock.mockImplementation(async () => []);
+    getThreadRepliesMock.mockReset();
+    getThreadRepliesMock.mockImplementation(async () => []);
+  });
+
+  test("passes channelId through and defaults limit to 50, before undefined", async () => {
+    const msg = makeMessage();
+    getHistoryMock.mockImplementation(async () => [msg]);
+
+    const out = await backfillDm("D123");
+
+    expect(resolveConnectionMock).toHaveBeenCalledTimes(1);
+    expect(getHistoryMock).toHaveBeenCalledTimes(1);
+    const [conn, channel, opts] = getHistoryMock.mock.calls[0];
+    expect(conn).toBeUndefined();
+    expect(channel).toBe("D123");
+    expect(opts).toEqual({ limit: 50, before: undefined });
+    expect(out).toEqual([msg]);
+  });
+
+  test("respects explicit limit override and forwards `before` cursor", async () => {
+    await backfillDm("D123", { limit: 25, before: "1700000000.000099" });
+    const [, , opts] = getHistoryMock.mock.calls[0];
+    expect(opts).toEqual({ limit: 25, before: "1700000000.000099" });
+  });
+
+  test("returns [] when getHistory throws (generic Slack API error)", async () => {
+    getHistoryMock.mockImplementation(async () => {
+      throw new Error("Slack API error: not_in_channel");
+    });
+    const out = await backfillDm("D123");
+    expect(out).toEqual([]);
+  });
+
+  test("rethrows channel_not_found so wrong-workspace config surfaces", async () => {
+    getHistoryMock.mockImplementation(async () => {
+      throw new Error("Slack API error: channel_not_found");
+    });
+    await expect(backfillDm("D123")).rejects.toThrow(/channel_not_found/);
+  });
+
+  test("threads `account` through to resolveConnection", async () => {
+    await backfillDm("D123", { account: "team-acme" });
+    expect(resolveConnectionMock).toHaveBeenCalledTimes(1);
+    expect(resolveConnectionMock.mock.calls[0][0]).toBe("team-acme");
+  });
+
+  test("returns [] when getHistory throws (auth error)", async () => {
+    getHistoryMock.mockImplementation(async () => {
+      const err = new Error("Slack API HTTP 401");
+      Object.assign(err, { status: 401 });
+      throw err;
+    });
+    const out = await backfillDm("D123");
+    expect(out).toEqual([]);
+  });
+
+  test("returns [] when getHistory throws (timeout)", async () => {
+    getHistoryMock.mockImplementation(async () => {
+      throw new Error("ETIMEDOUT");
+    });
+    const out = await backfillDm("D123");
+    expect(out).toEqual([]);
+  });
+
+  test("returns [] when resolveConnection throws (missing connection)", async () => {
+    resolveConnectionMock.mockImplementation(async () => {
+      throw new Error("no connection available");
+    });
+    const out = await backfillDm("D123");
+    expect(out).toEqual([]);
+    expect(getHistoryMock).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,101 @@
+/**
+ * Daemon-side Slack backfill helpers.
+ *
+ * These wrap the existing slackProvider adapter methods so callers (thread
+ * recovery, DM context hydration) can fetch a small window of recent messages
+ * without re-implementing connection resolution or token routing.
+ *
+ * Best-effort semantics: transient or auth failures (timeout, 401, missing
+ * connection, generic Slack API errors) are logged at WARN and yield an empty
+ * array. Callers proceed without backfill rather than propagating the error.
+ *
+ * Exception: `channel_not_found` is rethrown. In multi-account Slack setups it
+ * typically signals that the resolved connection points at the wrong
+ * workspace, and silently returning [] would mask that misconfiguration. Pass
+ * the conversation's own account via `opts.account` so resolveConnection()
+ * picks the right workspace.
+ */
+import { getLogger } from "../../../util/logger.js";
+import type { Message } from "../../provider-types.js";
+import { slackProvider } from "./adapter.js";
+
+const log = getLogger("slack-backfill");
+
+const DEFAULT_LIMIT = 50;
+
+function isChannelNotFound(err: unknown): boolean {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /channel_not_found/i.test(msg);
+}
+
+/**
+ * Fetch the most recent messages in a Slack thread.
+ *
+ * Resolves the cached Slack connection, then delegates to
+ * `slackProvider.getThreadReplies()`. Returns the messages mapped to the
+ * platform-agnostic `Message` shape (with `threadId` already populated from
+ * `thread_ts`). Returns `[]` on transient errors; rethrows `channel_not_found`.
+ */
+export async function backfillThread(
+  channelId: string,
+  threadTs: string,
+  opts?: { limit?: number; account?: string },
+): Promise<Message[]> {
+  const limit = opts?.limit ?? DEFAULT_LIMIT;
+  try {
+    const connection = await slackProvider.resolveConnection?.(opts?.account);
+    if (!slackProvider.getThreadReplies) {
+      log.warn(
+        { channelId, threadTs },
+        "Slack provider does not implement getThreadReplies — returning []",
+      );
+      return [];
+    }
+    return await slackProvider.getThreadReplies(
+      connection,
+      channelId,
+      threadTs,
+      { limit },
+    );
+  } catch (err) {
+    if (isChannelNotFound(err)) {
+      throw err;
+    }
+    log.warn(
+      { channelId, threadTs, account: opts?.account, err },
+      "Slack thread backfill failed — returning []",
+    );
+    return [];
+  }
+}
+
+/**
+ * Fetch the most recent messages in a Slack DM (or any conversation).
+ *
+ * Resolves the cached Slack connection, then delegates to
+ * `slackProvider.getHistory()`. The `before` option, when provided, is passed
+ * through as Slack's `latest` cursor so callers can paginate backwards.
+ * Returns `[]` on transient errors; rethrows `channel_not_found`.
+ */
+export async function backfillDm(
+  channelId: string,
+  opts?: { limit?: number; before?: string; account?: string },
+): Promise<Message[]> {
+  const limit = opts?.limit ?? DEFAULT_LIMIT;
+  try {
+    const connection = await slackProvider.resolveConnection?.(opts?.account);
+    return await slackProvider.getHistory(connection, channelId, {
+      limit,
+      before: opts?.before,
+    });
+  } catch (err) {
+    if (isChannelNotFound(err)) {
+      throw err;
+    }
+    log.warn(
+      { channelId, before: opts?.before, account: opts?.account, err },
+      "Slack DM backfill failed — returning []",
+    );
+    return [];
+  }
+}

package/src/messaging/providers/slack/message-metadata.test.ts

@@ -0,0 +1,316 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  mergeSlackMetadata,
+  readSlackMetadata,
+  type SlackMessageMetadata,
+  writeSlackMetadata,
+} from "./message-metadata.js";
+
+describe("readSlackMetadata", () => {
+  test("tolerates null and undefined", () => {
+    expect(readSlackMetadata(null)).toBeNull();
+    expect(readSlackMetadata(undefined)).toBeNull();
+  });
+
+  test("returns null on JSON parse error", () => {
+    expect(readSlackMetadata("not-json")).toBeNull();
+    expect(readSlackMetadata("{")).toBeNull();
+  });
+
+  test("returns null when the payload is not an object", () => {
+    expect(readSlackMetadata(JSON.stringify("string"))).toBeNull();
+    expect(readSlackMetadata(JSON.stringify(42))).toBeNull();
+    expect(readSlackMetadata(JSON.stringify(null))).toBeNull();
+    expect(readSlackMetadata(JSON.stringify([{ source: "slack" }]))).toBeNull();
+  });
+
+  test("rejects metadata whose source is not slack", () => {
+    const raw = JSON.stringify({
+      source: "telegram",
+      channelId: "C123",
+      channelTs: "1700000000.000100",
+      eventKind: "message",
+    });
+    expect(readSlackMetadata(raw)).toBeNull();
+  });
+
+  test("rejects payloads with malformed optional fields", () => {
+    const badThreadTs = JSON.stringify({
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000000.000100",
+      eventKind: "message",
+      threadTs: 42, // should be string
+    });
+    const badReactionOp = JSON.stringify({
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000000.000100",
+      eventKind: "reaction",
+      reaction: {
+        emoji: "thumbsup",
+        targetChannelTs: "1700000000.000100",
+        op: "bogus",
+      },
+    });
+    const badEditedAt = JSON.stringify({
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000000.000100",
+      eventKind: "message",
+      editedAt: "not-a-number",
+    });
+    expect(readSlackMetadata(badThreadTs)).toBeNull();
+    expect(readSlackMetadata(badReactionOp)).toBeNull();
+    expect(readSlackMetadata(badEditedAt)).toBeNull();
+  });
+
+  test("strips unknown top-level keys from the returned object", () => {
+    const raw = JSON.stringify({
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000000.000100",
+      eventKind: "message",
+      userMessageChannel: "channel:abc",
+      provenanceTrustClass: "trusted_contact",
+    });
+    const parsed = readSlackMetadata(raw);
+    expect(parsed).toEqual({
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000000.000100",
+      eventKind: "message",
+    });
+  });
+
+  test("rejects payloads missing required fields", () => {
+    const noChannelId = JSON.stringify({
+      source: "slack",
+      channelTs: "1700000000.000100",
+      eventKind: "message",
+    });
+    const noChannelTs = JSON.stringify({
+      source: "slack",
+      channelId: "C123",
+      eventKind: "message",
+    });
+    const badEventKind = JSON.stringify({
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000000.000100",
+      eventKind: "totally-bogus",
+    });
+    expect(readSlackMetadata(noChannelId)).toBeNull();
+    expect(readSlackMetadata(noChannelTs)).toBeNull();
+    expect(readSlackMetadata(badEventKind)).toBeNull();
+  });
+
+  test("parses a fully populated message metadata payload", () => {
+    const meta: SlackMessageMetadata = {
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000000.000100",
+      threadTs: "1699999999.000000",
+      displayName: "Alice",
+      eventKind: "message",
+      editedAt: 1700000123,
+    };
+    const parsed = readSlackMetadata(JSON.stringify(meta));
+    expect(parsed).toEqual(meta);
+  });
+
+  test("parses a reaction metadata payload", () => {
+    const meta: SlackMessageMetadata = {
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000050.000200",
+      eventKind: "reaction",
+      reaction: {
+        emoji: "thumbsup",
+        actorDisplayName: "Bob",
+        targetChannelTs: "1700000000.000100",
+        op: "added",
+      },
+    };
+    const parsed = readSlackMetadata(JSON.stringify(meta));
+    expect(parsed).toEqual(meta);
+  });
+});
+
+describe("writeSlackMetadata", () => {
+  test("round-trips through readSlackMetadata", () => {
+    const meta: SlackMessageMetadata = {
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000000.000100",
+      threadTs: "1699999999.000000",
+      displayName: "Alice",
+      eventKind: "message",
+    };
+    const raw = writeSlackMetadata(meta);
+    expect(typeof raw).toBe("string");
+    expect(readSlackMetadata(raw)).toEqual(meta);
+  });
+
+  test("round-trips reaction metadata", () => {
+    const meta: SlackMessageMetadata = {
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000050.000200",
+      eventKind: "reaction",
+      reaction: {
+        emoji: "eyes",
+        targetChannelTs: "1700000000.000100",
+        op: "removed",
+      },
+    };
+    const raw = writeSlackMetadata(meta);
+    expect(readSlackMetadata(raw)).toEqual(meta);
+  });
+});
+
+describe("mergeSlackMetadata", () => {
+  const baseMeta: SlackMessageMetadata = {
+    source: "slack",
+    channelId: "C123",
+    channelTs: "1700000000.000100",
+    threadTs: "1699999999.000000",
+    displayName: "Alice",
+    eventKind: "message",
+  };
+
+  test("preserves unrelated existing fields", () => {
+    const existing = writeSlackMetadata(baseMeta);
+    const merged = mergeSlackMetadata(existing, { editedAt: 1700000123 });
+    const parsed = readSlackMetadata(merged);
+    expect(parsed).toEqual({ ...baseMeta, editedAt: 1700000123 });
+  });
+
+  test("overrides fields present in both existing and patch", () => {
+    const existing = writeSlackMetadata(baseMeta);
+    const merged = mergeSlackMetadata(existing, { displayName: "Alicia" });
+    const parsed = readSlackMetadata(merged);
+    expect(parsed?.displayName).toBe("Alicia");
+    expect(parsed?.channelId).toBe(baseMeta.channelId);
+  });
+
+  test("ignores undefined patch fields rather than wiping existing values", () => {
+    const existing = writeSlackMetadata(baseMeta);
+    const merged = mergeSlackMetadata(existing, { displayName: undefined });
+    const parsed = readSlackMetadata(merged);
+    expect(parsed?.displayName).toBe(baseMeta.displayName);
+  });
+
+  test("supports marking a message deleted while keeping prior fields", () => {
+    const existing = writeSlackMetadata(baseMeta);
+    const merged = mergeSlackMetadata(existing, { deletedAt: 1700000200 });
+    const parsed = readSlackMetadata(merged);
+    expect(parsed).toEqual({ ...baseMeta, deletedAt: 1700000200 });
+  });
+
+  test("constructs valid metadata when existing is null and patch supplies required fields", () => {
+    const merged = mergeSlackMetadata(null, {
+      source: "slack",
+      channelId: "C999",
+      channelTs: "1700000300.000400",
+      eventKind: "message",
+      displayName: "Carol",
+    });
+    expect(readSlackMetadata(merged)).toEqual({
+      source: "slack",
+      channelId: "C999",
+      channelTs: "1700000300.000400",
+      eventKind: "message",
+      displayName: "Carol",
+    });
+  });
+
+  test("constructs valid metadata when existing fails to parse as slack", () => {
+    const merged = mergeSlackMetadata("garbage", {
+      source: "slack",
+      channelId: "C111",
+      channelTs: "1700000400.000500",
+      eventKind: "message",
+    });
+    expect(readSlackMetadata(merged)).toEqual({
+      source: "slack",
+      channelId: "C111",
+      channelTs: "1700000400.000500",
+      eventKind: "message",
+    });
+  });
+
+  test("forces source to slack even if patch attempts to override it", () => {
+    const existing = writeSlackMetadata(baseMeta);
+    const merged = mergeSlackMetadata(existing, {
+      // @ts-expect-error - intentional bad input to verify the guard
+      source: "telegram",
+      displayName: "Mallory",
+    });
+    const parsed = readSlackMetadata(merged);
+    expect(parsed?.source).toBe("slack");
+    expect(parsed?.displayName).toBe("Mallory");
+  });
+
+  test("preserves unrelated non-slack top-level keys from the existing blob", () => {
+    const existing = JSON.stringify({
+      userMessageChannel: "channel:abc",
+      provenanceTrustClass: "trusted_contact",
+      forkSourceMessageId: "msg-parent-1",
+    });
+    const merged = mergeSlackMetadata(existing, {
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000000.000100",
+      eventKind: "message",
+    });
+    const rawParsed = JSON.parse(merged) as Record<string, unknown>;
+    expect(rawParsed.userMessageChannel).toBe("channel:abc");
+    expect(rawParsed.provenanceTrustClass).toBe("trusted_contact");
+    expect(rawParsed.forkSourceMessageId).toBe("msg-parent-1");
+    expect(rawParsed.source).toBe("slack");
+    expect(rawParsed.channelId).toBe("C123");
+    expect(readSlackMetadata(merged)).toEqual({
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000000.000100",
+      eventKind: "message",
+    });
+  });
+
+  test("preserves non-slack keys when patching an already-slack-tagged blob", () => {
+    const existing = JSON.stringify({
+      ...baseMeta,
+      userMessageChannel: "channel:abc",
+    });
+    const merged = mergeSlackMetadata(existing, { editedAt: 1700000999 });
+    const rawParsed = JSON.parse(merged) as Record<string, unknown>;
+    expect(rawParsed.userMessageChannel).toBe("channel:abc");
+    expect(readSlackMetadata(merged)).toEqual({
+      ...baseMeta,
+      editedAt: 1700000999,
+    });
+  });
+
+  test("preserves nested reaction metadata across a patch", () => {
+    const reactionMeta: SlackMessageMetadata = {
+      source: "slack",
+      channelId: "C123",
+      channelTs: "1700000050.000200",
+      eventKind: "reaction",
+      reaction: {
+        emoji: "thumbsup",
+        targetChannelTs: "1700000000.000100",
+        op: "added",
+      },
+    };
+    const existing = writeSlackMetadata(reactionMeta);
+    const merged = mergeSlackMetadata(existing, {
+      displayName: "Bob",
+    });
+    const parsed = readSlackMetadata(merged);
+    expect(parsed?.reaction).toEqual(reactionMeta.reaction);
+    expect(parsed?.displayName).toBe("Bob");
+  });
+});