@vellumai/assistant 0.8.3 → 0.8.4

package/src/runtime/routes/__tests__/sanity-routes.test.ts

@@ -0,0 +1,280 @@
+/**
+ * Unit tests for sanity-routes.ts.
+ *
+ * Drives the handler functions directly (bypassing the router) and mocks
+ * out secure-keys, the node:fs writes, and fetch so no real I/O occurs.
+ */
+
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module mocks — must appear before any imports of the module under test
+// ---------------------------------------------------------------------------
+
+let storedToken: string | undefined = undefined;
+
+mock.module("../../../security/secure-keys.js", () => ({
+  getSecureKeyAsync: async (_key: string) => storedToken,
+}));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+const FAKE_WORKSPACE = "/tmp/sanity-routes-test-workspace";
+
+mock.module("../../../util/platform.js", () => ({
+  getWorkspaceDir: () => FAKE_WORKSPACE,
+}));
+
+const writtenFiles = new Map<string, string>();
+
+mock.module("node:fs", () => ({
+  mkdirSync: () => {},
+  writeFileSync: (path: string, content: string) => {
+    writtenFiles.set(path, content);
+  },
+  // Expose the rest of node:fs unchanged so other imports still work.
+  // Bun's mock.module replaces only what we return, and the module under
+  // test only imports mkdirSync and writeFileSync from node:fs.
+}));
+
+// ---------------------------------------------------------------------------
+// Imports after mocks
+// ---------------------------------------------------------------------------
+
+import { ROUTES } from "../sanity-routes.js";
+import type { RouteDefinition, RouteHandlerArgs } from "../types.js";
+
+afterAll(() => {
+  mock.restore();
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function findHandler(operationId: string): RouteDefinition["handler"] {
+  const route = ROUTES.find((r) => r.operationId === operationId);
+  if (!route) throw new Error(`Route ${operationId} not found`);
+  return route.handler;
+}
+
+function makeArgs(body?: Record<string, unknown>): RouteHandlerArgs {
+  return { body };
+}
+
+const discoverHandler = findHandler("sanity_discover");
+const connectHandler = findHandler("sanity_connect");
+
+// ---------------------------------------------------------------------------
+// Fetch mock helpers
+// ---------------------------------------------------------------------------
+
+type FetchReturn = { status: number; json: () => unknown };
+let mockFetchImpl: ((url: string) => FetchReturn) | undefined = undefined;
+
+const originalFetch = globalThis.fetch;
+
+function mockFetch(url: string | URL | Request): Promise<Response> {
+  const urlStr =
+    typeof url === "string" ? url : url instanceof URL ? url.href : url.url;
+  if (!mockFetchImpl) throw new Error(`Unexpected fetch: ${urlStr}`);
+  const result = mockFetchImpl(urlStr);
+  return Promise.resolve({
+    ok: result.status >= 200 && result.status < 300,
+    status: result.status,
+    json: async () => result.json(),
+  } as Response);
+}
+
+beforeEach(() => {
+  writtenFiles.clear();
+  storedToken = undefined;
+  mockFetchImpl = undefined;
+
+  (globalThis as any).fetch = mockFetch;
+});
+
+afterEach(() => {
+  (globalThis as any).fetch = originalFetch;
+});
+
+// ---------------------------------------------------------------------------
+// POST /v1/sanity/discover — no stored token
+// ---------------------------------------------------------------------------
+
+describe("sanity_discover — no stored token", () => {
+  test("returns { error: 'no_token' } when token absent", async () => {
+    storedToken = undefined;
+    const result = await discoverHandler(makeArgs({}));
+    expect(result).toEqual({ error: "no_token" });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// POST /v1/sanity/discover — project listing
+// ---------------------------------------------------------------------------
+
+describe("sanity_discover — list projects", () => {
+  beforeEach(() => {
+    storedToken = "sk-test-token";
+  });
+
+  test("returns projects when API responds 200", async () => {
+    mockFetchImpl = () => ({
+      status: 200,
+      json: () => [
+        { id: "proj-a", displayName: "Project Alpha" },
+        { id: "proj-b", displayName: "Project Beta" },
+      ],
+    });
+
+    const result = await discoverHandler(makeArgs({}));
+    expect(result).toEqual({
+      projects: [
+        { id: "proj-a", displayName: "Project Alpha" },
+        { id: "proj-b", displayName: "Project Beta" },
+      ],
+    });
+  });
+
+  test("returns { error: 'token_scope_limited' } on 401", async () => {
+    mockFetchImpl = () => ({ status: 401, json: () => ({}) });
+    const result = await discoverHandler(makeArgs({}));
+    expect(result).toEqual({ error: "token_scope_limited" });
+  });
+
+  test("returns { error: 'token_scope_limited' } on 403", async () => {
+    mockFetchImpl = () => ({ status: 403, json: () => ({}) });
+    const result = await discoverHandler(makeArgs({}));
+    expect(result).toEqual({ error: "token_scope_limited" });
+  });
+
+  test("returns { error: 'discovery_failed' } on 500", async () => {
+    mockFetchImpl = () => ({ status: 500, json: () => ({}) });
+    const result = await discoverHandler(makeArgs({}));
+    expect(result).toEqual({ error: "discovery_failed" });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// POST /v1/sanity/discover — dataset listing (projectId provided)
+// ---------------------------------------------------------------------------
+
+describe("sanity_discover — list datasets", () => {
+  beforeEach(() => {
+    storedToken = "sk-test-token";
+  });
+
+  test("returns datasets when API responds 200", async () => {
+    mockFetchImpl = (url) => {
+      expect(url).toContain("/projects/my-project/datasets");
+      return {
+        status: 200,
+        json: () => [{ name: "production" }, { name: "staging" }],
+      };
+    };
+
+    const result = await discoverHandler(makeArgs({ projectId: "my-project" }));
+    expect(result).toEqual({
+      projectId: "my-project",
+      datasets: ["production", "staging"],
+    });
+  });
+
+  test("returns { error: 'token_scope_limited' } on 403 for dataset list", async () => {
+    mockFetchImpl = () => ({ status: 403, json: () => ({}) });
+    const result = await discoverHandler(makeArgs({ projectId: "my-project" }));
+    expect(result).toEqual({ error: "token_scope_limited" });
+  });
+
+  test("returns { error: 'discovery_failed' } on 500 for dataset list", async () => {
+    mockFetchImpl = () => ({ status: 500, json: () => ({}) });
+    const result = await discoverHandler(makeArgs({ projectId: "my-project" }));
+    expect(result).toEqual({ error: "discovery_failed" });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// POST /v1/sanity/connect
+// ---------------------------------------------------------------------------
+
+describe("sanity_connect", () => {
+  test("writes sidecar when token present and inputs valid", async () => {
+    storedToken = "sk-test-token";
+
+    const result = await connectHandler(
+      makeArgs({ projectId: "my-proj", dataset: "production" }),
+    );
+
+    expect(result).toEqual({ ok: true });
+
+    const expectedPath = `${FAKE_WORKSPACE}/data/sanity-connection.json`;
+    expect(writtenFiles.has(expectedPath)).toBe(true);
+    const written = JSON.parse(writtenFiles.get(expectedPath)!);
+    expect(written).toEqual({ projectId: "my-proj", dataset: "production" });
+  });
+
+  test("throws when no token is stored", async () => {
+    storedToken = undefined;
+
+    expect(
+      connectHandler(makeArgs({ projectId: "p", dataset: "production" })),
+    ).rejects.toThrow();
+  });
+
+  test("throws when projectId is empty", async () => {
+    storedToken = "sk-test-token";
+
+    expect(
+      connectHandler(makeArgs({ projectId: "  ", dataset: "production" })),
+    ).rejects.toThrow();
+  });
+
+  test("throws when dataset is empty", async () => {
+    storedToken = "sk-test-token";
+
+    expect(
+      connectHandler(makeArgs({ projectId: "my-proj", dataset: "" })),
+    ).rejects.toThrow();
+  });
+
+  test("does not return token in response", async () => {
+    storedToken = "sk-super-secret";
+
+    const result = (await connectHandler(
+      makeArgs({ projectId: "p", dataset: "d" }),
+    )) as Record<string, unknown>;
+
+    const resultStr = JSON.stringify(result);
+    expect(resultStr).not.toContain("sk-super-secret");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Policy key verification
+// ---------------------------------------------------------------------------
+
+describe("route policy keys", () => {
+  test("sanity_discover uses policyKey: secrets", () => {
+    const route = ROUTES.find((r) => r.operationId === "sanity_discover");
+    expect(route?.policyKey).toBe("secrets");
+  });
+
+  test("sanity_connect uses policyKey: secrets", () => {
+    const route = ROUTES.find((r) => r.operationId === "sanity_connect");
+    expect(route?.policyKey).toBe("secrets");
+  });
+});

package/src/runtime/routes/__tests__/slack-channel-routes.test.ts

@@ -0,0 +1,266 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+type MockSlackInfo = {
+  id: string;
+  name?: string;
+  nameNormalized?: string;
+} | null;
+
+type MockSlackResult = MockSlackInfo | { slackError: string };
+
+const slackInfoCalls: string[] = [];
+let slackInfoImpl: (channelId: string) => Promise<MockSlackResult> = async () =>
+  null;
+const syncInvalidations: string[][] = [];
+const originalFetch = globalThis.fetch;
+
+mock.module("../../../security/secure-keys.js", () => ({
+  getSecureKeyAsync: async () => "xoxb-test",
+}));
+
+mock.module("../../sync/sync-publisher.js", () => ({
+  publishSyncInvalidation: async (tags: string[]) => {
+    syncInvalidations.push([...tags]);
+  },
+}));
+
+import {
+  conversationMetadataSyncTag,
+  SYNC_TAGS,
+} from "../../../daemon/message-types/sync.js";
+import { createConversation } from "../../../memory/conversation-crud.js";
+import { getDb, resetDb } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import {
+  getBindingByConversation,
+  upsertBinding,
+} from "../../../memory/external-conversation-store.js";
+import { ROUTES } from "../slack-channel-routes.js";
+import type { RouteDefinition } from "../types.js";
+
+initializeDb();
+
+interface ResolveResponse {
+  channelId: string;
+  channelName?: string;
+  cached: boolean;
+  resolved: boolean;
+  reason?: string;
+}
+
+function resolveHandler(): RouteDefinition["handler"] {
+  const route = ROUTES.find(
+    (r) => r.operationId === "slack_channel_name_resolve",
+  );
+  if (!route) throw new Error("slack_channel_name_resolve route not found");
+  return route.handler;
+}
+
+const handler = resolveHandler();
+
+function clearTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM conversations");
+}
+
+function createBoundConversation(input: {
+  sourceChannel?: string;
+  externalChatId: string;
+  externalChatName?: string | null;
+  externalThreadId?: string | null;
+  externalUserId?: string | null;
+  displayName?: string | null;
+  username?: string | null;
+}): string {
+  const conversation = createConversation("Slack route test");
+  upsertBinding({
+    conversationId: conversation.id,
+    sourceChannel: input.sourceChannel ?? "slack",
+    externalChatId: input.externalChatId,
+    externalChatName: input.externalChatName,
+    externalThreadId: input.externalThreadId,
+    externalUserId: input.externalUserId,
+    displayName: input.displayName,
+    username: input.username,
+  });
+  return conversation.id;
+}
+
+async function resolve(conversationId: string): Promise<ResolveResponse> {
+  return (await handler({
+    pathParams: { conversationId },
+  })) as ResolveResponse;
+}
+
+function mockSlackFetch(): void {
+  globalThis.fetch = mock(async (input) => {
+    const url = new URL(String(input));
+    if (url.pathname !== "/api/conversations.info") {
+      throw new Error(`Unexpected Slack API request: ${url.pathname}`);
+    }
+
+    const channelId = url.searchParams.get("channel") ?? "";
+    slackInfoCalls.push(channelId);
+    const result = await slackInfoImpl(channelId);
+    if (result && "slackError" in result) {
+      return Response.json({ ok: false, error: result.slackError });
+    }
+
+    return Response.json({
+      ok: true,
+      channel: result
+        ? {
+            id: result.id,
+            name: result.name,
+            name_normalized: result.nameNormalized,
+          }
+        : undefined,
+    });
+  }) as unknown as typeof fetch;
+}
+
+beforeEach(() => {
+  clearTables();
+  slackInfoCalls.length = 0;
+  syncInvalidations.length = 0;
+  slackInfoImpl = async () => null;
+  mockSlackFetch();
+});
+
+afterAll(() => {
+  globalThis.fetch = originalFetch;
+  resetDb();
+  mock.restore();
+});
+
+describe("slack_channel_name_resolve", () => {
+  test("returns cached friendly name without calling Slack", async () => {
+    const conversationId = createBoundConversation({
+      externalChatId: "CACHED123",
+      externalChatName: "team-updates",
+    });
+
+    const result = await resolve(conversationId);
+
+    expect(result).toEqual({
+      channelId: "CACHED123",
+      channelName: "team-updates",
+      cached: true,
+      resolved: true,
+    });
+    expect(slackInfoCalls).toEqual([]);
+  });
+
+  test("resolves an unresolved channel ID and persists the returned name", async () => {
+    const conversationId = createBoundConversation({
+      externalChatId: "CRESOLVE123",
+      externalChatName: "CRESOLVE123",
+      externalThreadId: "1710000000.000100",
+      externalUserId: "U123",
+      displayName: "Alice",
+      username: "alice",
+    });
+    slackInfoImpl = async (channelId) => ({
+      id: channelId,
+      name: "engineering",
+    });
+
+    const result = await resolve(conversationId);
+
+    expect(slackInfoCalls).toEqual(["CRESOLVE123"]);
+    expect(result).toEqual({
+      channelId: "CRESOLVE123",
+      channelName: "engineering",
+      cached: false,
+      resolved: true,
+    });
+
+    const updated = getBindingByConversation(conversationId);
+    expect(updated?.externalChatName).toBe("engineering");
+    expect(updated?.externalThreadId).toBe("1710000000.000100");
+    expect(updated?.externalUserId).toBe("U123");
+    expect(updated?.displayName).toBe("Alice");
+    expect(updated?.username).toBe("alice");
+  });
+
+  test("publishes conversation sync tags after persisting a returned name", async () => {
+    const conversationId = createBoundConversation({
+      externalChatId: "CSYNC123",
+      externalChatName: "CSYNC123",
+    });
+    slackInfoImpl = async (channelId) => ({
+      id: channelId,
+      nameNormalized: "team-sync",
+    });
+
+    const result = await resolve(conversationId);
+
+    expect(result).toEqual({
+      channelId: "CSYNC123",
+      channelName: "team-sync",
+      cached: false,
+      resolved: true,
+    });
+    expect(syncInvalidations).toContainEqual([
+      SYNC_TAGS.conversationsList,
+      conversationMetadataSyncTag(conversationId),
+    ]);
+  });
+
+  test("does not call Slack for DM bindings", async () => {
+    const conversationId = createBoundConversation({
+      externalChatId: "D123",
+      externalChatName: null,
+    });
+
+    const result = await resolve(conversationId);
+
+    expect(result).toEqual({
+      channelId: "D123",
+      cached: false,
+      resolved: false,
+      reason: "dm",
+    });
+    expect(slackInfoCalls).toEqual([]);
+    expect(getBindingByConversation(conversationId)?.externalChatName).toBe(
+      null,
+    );
+  });
+
+  test("rejects non-Slack bindings", async () => {
+    const conversationId = createBoundConversation({
+      sourceChannel: "telegram",
+      externalChatId: "chat-123",
+    });
+
+    await expect(resolve(conversationId)).rejects.toMatchObject({
+      code: "NOT_FOUND",
+      statusCode: 404,
+    });
+    expect(slackInfoCalls).toEqual([]);
+  });
+
+  test("returns unresolved on Slack API failure without mutating the binding", async () => {
+    const conversationId = createBoundConversation({
+      externalChatId: "CFAIL123",
+      externalChatName: "CFAIL123",
+    });
+    const before = getBindingByConversation(conversationId);
+    slackInfoImpl = async () => ({ slackError: "missing_scope" });
+
+    const result = await resolve(conversationId);
+
+    expect(result).toEqual({
+      channelId: "CFAIL123",
+      cached: false,
+      resolved: false,
+      reason: "permission",
+    });
+    expect(slackInfoCalls).toEqual(["CFAIL123"]);
+
+    const after = getBindingByConversation(conversationId);
+    expect(after?.externalChatName).toBe("CFAIL123");
+    expect(after?.updatedAt).toBe(before?.updatedAt);
+  });
+});

package/src/runtime/routes/approval-routes.ts

@@ -78,7 +78,10 @@ function handleConfirm({ body }: RouteHandlerArgs) {
   // ACP permissions: resolve directly without a Conversation object.
   // No PermissionPrompter involved, so the route owns deregistration.
   if (interaction.directResolve) {
-    pendingInteractions.resolve(requestId);
+    pendingInteractions.resolve(
+      requestId,
+      effectiveDecision === "allow" ? "approved" : "rejected",
+    );
     interaction.directResolve(effectiveDecision as UserDecision);
     return { accepted: true };
   }