@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/conversation-sync-tags.test.ts

@@ -0,0 +1,235 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  conversationMetadataSyncTag,
+  SYNC_TAGS,
+} from "../daemon/message-types/sync.js";
+import {
+  projectAssistantMessage,
+  recordConversationSeenSignal,
+} from "../memory/conversation-attention-store.js";
+import { createConversation } from "../memory/conversation-crud.js";
+import { getDb, resetDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { ROUTES as CONVERSATION_LIST_ROUTES } from "../runtime/routes/conversation-list-routes.js";
+import { ROUTES as CONVERSATION_MANAGEMENT_ROUTES } from "../runtime/routes/conversation-management-routes.js";
+import type { RouteDefinition } from "../runtime/routes/types.js";
+import { waitFor } from "./helpers/wait-for.js";
+
+initializeDb();
+
+function clearTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM conversation_assistant_attention_state");
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+function findRoute(
+  routes: RouteDefinition[],
+  operationId: string,
+): RouteDefinition {
+  const route = routes.find(
+    (candidate) => candidate.operationId === operationId,
+  );
+  if (!route) {
+    throw new Error(`Route ${operationId} not found`);
+  }
+  return route;
+}
+
+async function captureEvents(
+  action: () => void | Promise<unknown>,
+  expectedCount: number,
+): Promise<AssistantEvent[]> {
+  const received: AssistantEvent[] = [];
+  const subscription = assistantEventHub.subscribe({
+    type: "process",
+    callback: (event) => {
+      received.push(event);
+    },
+  });
+  try {
+    await action();
+    await waitFor(() => received.length >= expectedCount, {
+      message: "Timed out waiting for conversation sync tag event",
+    });
+    return received;
+  } finally {
+    subscription.dispose();
+  }
+}
+
+describe("conversation sync tags", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  afterAll(() => {
+    resetDb();
+  });
+
+  test("rename emits legacy title/list events and conversation metadata sync tags", async () => {
+    const conversation = createConversation("Old title");
+    const route = findRoute(
+      CONVERSATION_MANAGEMENT_ROUTES,
+      "renameConversation",
+    );
+
+    const received = await captureEvents(() => {
+      route.handler({
+        pathParams: { id: conversation.id },
+        body: { name: "New title" },
+      });
+    }, 3);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_title_updated",
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[2]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(conversation.id),
+      ],
+    });
+  });
+
+  test("create emits legacy list invalidation and list/metadata sync tags", async () => {
+    const route = findRoute(
+      CONVERSATION_MANAGEMENT_ROUTES,
+      "createConversation",
+    );
+    let conversationId: string | undefined;
+
+    const received = await captureEvents(async () => {
+      const result = (await route.handler({
+        body: { conversationKey: "sync-create-test" },
+      })) as { id: string };
+      conversationId = result.id;
+    }, 2);
+
+    expect(conversationId).toBeDefined();
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(conversationId!),
+      ],
+    });
+  });
+
+  test("reorder emits list invalidation and metadata sync tags for touched conversations", async () => {
+    const first = createConversation("First");
+    const second = createConversation("Second");
+    const route = findRoute(
+      CONVERSATION_MANAGEMENT_ROUTES,
+      "reorderConversations",
+    );
+
+    const received = await captureEvents(() => {
+      route.handler({
+        body: {
+          updates: [
+            { conversationId: first.id, displayOrder: 1, isPinned: true },
+            { conversationId: second.id, displayOrder: 2, isPinned: false },
+          ],
+        },
+      });
+    }, 2);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(first.id),
+        conversationMetadataSyncTag(second.id),
+      ],
+    });
+  });
+
+  test("record seen emits list invalidation and metadata sync tags for the touched conversation", async () => {
+    const conversation = createConversation("Attention");
+    projectAssistantMessage({
+      conversationId: conversation.id,
+      messageId: "assistant-message-1",
+      messageAt: 1_700_000_000_000,
+    });
+    const route = findRoute(CONVERSATION_LIST_ROUTES, "recordConversationSeen");
+
+    const received = await captureEvents(() => {
+      route.handler({
+        body: {
+          conversationId: conversation.id,
+          sourceChannel: "vellum",
+          signalType: "macos_conversation_opened",
+          confidence: "explicit",
+          source: "test",
+        },
+      });
+    }, 2);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(conversation.id),
+      ],
+    });
+  });
+
+  test("mark unread emits list invalidation and metadata sync tags for the touched conversation", async () => {
+    const conversation = createConversation("Attention");
+    projectAssistantMessage({
+      conversationId: conversation.id,
+      messageId: "assistant-message-1",
+      messageAt: 1_700_000_000_000,
+    });
+    recordConversationSeenSignal({
+      conversationId: conversation.id,
+      sourceChannel: "vellum",
+      signalType: "macos_conversation_opened",
+      confidence: "explicit",
+      source: "test",
+    });
+    const route = findRoute(CONVERSATION_LIST_ROUTES, "markConversationUnread");
+
+    const received = await captureEvents(() => {
+      route.handler({
+        body: {
+          conversationId: conversation.id,
+        },
+      });
+    }, 2);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(conversation.id),
+      ],
+    });
+  });
+});

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -63,7 +63,11 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { enabled: false, v2: { enabled: false } },
+    memory: {
+      enabled: false,
+      v2: { enabled: false },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -61,7 +61,11 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { enabled: false, v2: { enabled: false } },
+    memory: {
+      enabled: false,
+      v2: { enabled: false },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/credential-security-invariants.test.ts

@@ -189,10 +189,10 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "messaging/providers/slack/adapter.ts", // Slack bot token lookup for Socket Mode connectivity check
       "credential-health/credential-health-service.ts", // proactive credential health monitoring
       "daemon/handlers/config-slack-channel.ts", // Slack channel config credential management
-      "providers/managed-proxy/context.ts", // managed proxy API key lookup for provider initialization
+      "providers/platform-proxy/context.ts", // managed proxy API key lookup for provider initialization
       "platform/client.ts", // platform client credential store fallback for standalone CLI auth
       "mcp/mcp-oauth-provider.ts", // MCP OAuth token/client/discovery persistence
-      "runtime/routes/integrations/slack/share.ts", // Slack share routes credential lookup
+      "runtime/routes/integrations/slack/token.ts", // shared Slack token resolver (bot/user token lookup for CLI use routes)
       "mcp/client.ts", // MCP client cached-token lookup
       "oauth/token-persistence.ts", // OAuth token persistence (set/delete tokens)
       "oauth/credential-token-resolver.ts", // centralized access-token key resolution for OAuth and manual-token providers
@@ -226,6 +226,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "runtime/routes/platform-routes.ts", // CLI platform connect/disconnect/status routes (CLI-migrated to IPC)
       "ipc/skill-routes/providers.ts", // host.providers.secureKeys.getProviderKey IPC route (out-of-process SkillHost companion)
       "daemon/external-plugins-bootstrap.ts", // reads credentials at plugin init (manifest.requiresCredential) via the CES-mediated getSecureKeyAsync path
+      "plugins/external-api.ts", // globalThis runtime bridge that exposes getSecureKeyAsync to dynamically-imported workspace plugins (compiled-binary plugin loading)
       "inbound/platform-callback-registration.ts", // managed credential lookup for platform base URL, assistant ID, and API key
       "tts/providers/elevenlabs-provider.ts", // ElevenLabs TTS API key lookup
       "tts/providers/deepgram-provider.ts", // Deepgram TTS API key lookup

package/src/__tests__/date-context.test.ts

@@ -4,6 +4,7 @@ import { UiConfigSchema } from "../config/schemas/platform.js";
 import {
   canonicalizeTimeZone,
   extractUserTimeZoneFromRecall,
+  formatLocalTimestamp,
   formatTurnTimestamp,
   resolveTurnTimezoneContext,
 } from "../daemon/date-context.js";
@@ -321,3 +322,47 @@ describe("formatTurnTimestamp", () => {
     expect(result).not.toContain("24:");
   });
 });
+
+// ---------------------------------------------------------------------------
+// formatLocalTimestamp
+// ---------------------------------------------------------------------------
+
+describe("formatLocalTimestamp", () => {
+  // 2026-05-11T17:30:00Z is 10:30 PDT (UTC-7, DST in effect).
+  const utcMidday = Date.parse("2026-05-11T17:30:00Z");
+
+  test("defaults to UTC when no timeZone is provided", () => {
+    expect(formatLocalTimestamp(utcMidday)).toBe("2026-05-11 17:30:00");
+  });
+
+  test("explicit UTC matches the no-timezone default", () => {
+    expect(formatLocalTimestamp(utcMidday, "UTC")).toBe("2026-05-11 17:30:00");
+  });
+
+  test("renders in America/Los_Angeles when configured", () => {
+    expect(formatLocalTimestamp(utcMidday, "America/Los_Angeles")).toBe(
+      "2026-05-11 10:30:00",
+    );
+  });
+
+  test("renders in Asia/Tokyo when configured", () => {
+    // UTC+9 — 17:30 UTC is 02:30 next-day local.
+    expect(formatLocalTimestamp(utcMidday, "Asia/Tokyo")).toBe(
+      "2026-05-12 02:30:00",
+    );
+  });
+
+  test("handles a DST spring-forward boundary correctly", () => {
+    // 2026-03-08 06:30:00Z is 01:30 EST. The 02:00 → 03:00 spring-forward
+    // in America/New_York happens at 07:00 UTC. 07:30 UTC is 03:30 EDT.
+    const beforeJump = Date.parse("2026-03-08T06:30:00Z");
+    const afterJump = Date.parse("2026-03-08T07:30:00Z");
+
+    expect(formatLocalTimestamp(beforeJump, "America/New_York")).toBe(
+      "2026-03-08 01:30:00",
+    );
+    expect(formatLocalTimestamp(afterJump, "America/New_York")).toBe(
+      "2026-03-08 03:30:00",
+    );
+  });
+});

package/src/__tests__/db-slack-external-content-normalization.test.ts

@@ -0,0 +1,301 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../memory/db-connection.js";
+import { createMessagesFts } from "../memory/migrations/116-messages-fts.js";
+import { migrateNormalizeSlackExternalContent } from "../memory/migrations/249-normalize-slack-external-content.js";
+import * as schema from "../memory/schema.js";
+import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
+import { wrapUntrustedContent } from "../security/untrusted-content.js";
+
+interface MessageRow {
+  id: string;
+  content: string;
+  metadata: string | null;
+}
+
+interface FtsRow {
+  content: string;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function bootstrapConversationTables(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE messages (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      metadata TEXT
+    );
+
+    INSERT INTO conversations (id, title, created_at, updated_at)
+    VALUES ('conv-slack', 'Slack conversation', 1000, 1000);
+  `);
+}
+
+function slackEnvelope(
+  channelTs: string,
+  extra: Record<string, unknown> = {},
+): string {
+  return JSON.stringify({
+    userMessageChannel: "slack",
+    assistantMessageChannel: "slack",
+    slackMeta: writeSlackMetadata({
+      source: "slack",
+      channelId: "C0123",
+      channelTs,
+      eventKind: "message",
+      displayName: "@alice",
+    }),
+    ...extra,
+  });
+}
+
+function slackBackfillEnvelope(
+  channelTs: string,
+  extra: Record<string, unknown> = {},
+): string {
+  const { slackFiles, ...outerExtra } = extra;
+  return JSON.stringify({
+    slackMeta: writeSlackMetadata({
+      source: "slack",
+      channelId: "C0123",
+      channelTs,
+      eventKind: "message",
+      displayName: "@alice",
+      ...(Array.isArray(slackFiles) ? { slackFiles } : {}),
+    }),
+    ...outerExtra,
+  });
+}
+
+function insertMessage(
+  raw: Database,
+  id: string,
+  content: string,
+  metadata: string,
+  role = "user",
+): void {
+  raw
+    .query(
+      /*sql*/ `
+        INSERT INTO messages (id, conversation_id, role, content, created_at, metadata)
+        VALUES (?, 'conv-slack', ?, ?, 1000, ?)
+      `,
+    )
+    .run(id, role, content, metadata);
+}
+
+function getRows(raw: Database): Record<string, MessageRow> {
+  const rows = raw
+    .query(`SELECT id, content, metadata FROM messages ORDER BY id`)
+    .all() as MessageRow[];
+  return Object.fromEntries(rows.map((row) => [row.id, row]));
+}
+
+function getFtsContent(raw: Database, messageId: string): string {
+  const row = raw
+    .query(`SELECT content FROM messages_fts WHERE message_id = ?`)
+    .get(messageId) as FtsRow | null;
+  return row?.content ?? "";
+}
+
+describe("migrateNormalizeSlackExternalContent", () => {
+  test("normalizes complete Slack envelopes and leaves unrelated rows unchanged", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapConversationTables(raw);
+    createMessagesFts(db);
+
+    const wrappedPlain = wrapUntrustedContent("plain Slack text", {
+      source: "slack",
+      sourceDetail: "@alice",
+    });
+    const wrappedBlock = wrapUntrustedContent("block Slack text", {
+      source: "slack",
+      sourceDetail: "@alice",
+    });
+    const jsonContent = JSON.stringify([
+      { type: "text", text: wrappedBlock },
+      {
+        type: "image",
+        source: { type: "base64", media_type: "image/png", data: "aGVsbG8=" },
+      },
+      { type: "file", source: { type: "file_id", file_id: "file_1" } },
+    ]);
+    const nonSlackWrapped = wrapUntrustedContent("web text", {
+      source: "web",
+      sourceDetail: "https://example.com",
+    });
+    const guardianMetadata = slackEnvelope("1700000003.000000", {
+      provenanceTrustClass: "guardian",
+    });
+    const liveRawMissingProvenanceMetadata = slackEnvelope("1700000007.000000");
+    const legacyGuardianMetadata = slackBackfillEnvelope("1700000004.000000");
+    const legacyGuardianJsonContent = JSON.stringify([
+      { type: "text", text: "guardian image caption" },
+      {
+        type: "image",
+        source: { type: "base64", media_type: "image/png", data: "aGVsbG8=" },
+      },
+    ]);
+    const ambiguousAttachmentOnlyMetadata = slackBackfillEnvelope(
+      "1700000006.000000",
+      {
+        slackFiles: [
+          {
+            id: "F0123",
+            name: "example.png",
+            mimetype: "image/png",
+          },
+        ],
+      },
+    );
+    const ambiguousAttachmentOnlyContent = JSON.stringify([
+      {
+        type: "image",
+        source: { type: "base64", media_type: "image/png", data: "aGVsbG8=" },
+      },
+    ]);
+
+    insertMessage(
+      raw,
+      "slack-plain",
+      wrappedPlain,
+      slackEnvelope("1700000000.000000"),
+    );
+    insertMessage(
+      raw,
+      "slack-json",
+      jsonContent,
+      slackEnvelope("1700000001.000000"),
+    );
+    insertMessage(
+      raw,
+      "non-slack",
+      nonSlackWrapped,
+      JSON.stringify({ userMessageChannel: "web" }),
+    );
+    insertMessage(raw, "guardian-raw", "guardian Slack text", guardianMetadata);
+    insertMessage(
+      raw,
+      "live-raw-missing-provenance",
+      "live raw Slack text",
+      liveRawMissingProvenanceMetadata,
+    );
+    insertMessage(
+      raw,
+      "legacy-guardian-raw",
+      "legacy guardian Slack text",
+      legacyGuardianMetadata,
+    );
+    insertMessage(
+      raw,
+      "legacy-guardian-json",
+      legacyGuardianJsonContent,
+      slackBackfillEnvelope("1700000005.000000"),
+    );
+    insertMessage(
+      raw,
+      "ambiguous-attachment-only",
+      ambiguousAttachmentOnlyContent,
+      ambiguousAttachmentOnlyMetadata,
+    );
+
+    migrateNormalizeSlackExternalContent(db);
+    const afterFirstRun = getRows(raw);
+    migrateNormalizeSlackExternalContent(db);
+    const afterSecondRun = getRows(raw);
+
+    expect(afterSecondRun).toEqual(afterFirstRun);
+
+    expect(afterFirstRun["slack-plain"]?.content).toBe("plain Slack text");
+    const plainMetadata = JSON.parse(
+      afterFirstRun["slack-plain"]!.metadata!,
+    ) as Record<string, unknown>;
+    expect(plainMetadata.provenanceTrustClass).toBe("unknown");
+    expect(typeof plainMetadata.slackMeta).toBe("string");
+
+    const normalizedBlocks = JSON.parse(afterFirstRun["slack-json"]!.content);
+    expect(normalizedBlocks).toEqual([
+      { type: "text", text: "block Slack text" },
+      {
+        type: "image",
+        source: { type: "base64", media_type: "image/png", data: "aGVsbG8=" },
+      },
+      { type: "file", source: { type: "file_id", file_id: "file_1" } },
+    ]);
+    const jsonMetadata = JSON.parse(
+      afterFirstRun["slack-json"]!.metadata!,
+    ) as Record<string, unknown>;
+    expect(jsonMetadata.provenanceTrustClass).toBe("unknown");
+
+    expect(afterFirstRun["non-slack"]?.content).toBe(nonSlackWrapped);
+    expect(afterFirstRun["non-slack"]?.metadata).toBe(
+      JSON.stringify({ userMessageChannel: "web" }),
+    );
+
+    expect(afterFirstRun["guardian-raw"]?.content).toBe("guardian Slack text");
+    expect(afterFirstRun["guardian-raw"]?.metadata).toBe(guardianMetadata);
+
+    expect(afterFirstRun["live-raw-missing-provenance"]?.content).toBe(
+      "live raw Slack text",
+    );
+    expect(afterFirstRun["live-raw-missing-provenance"]?.metadata).toBe(
+      liveRawMissingProvenanceMetadata,
+    );
+
+    expect(afterFirstRun["legacy-guardian-raw"]?.content).toBe(
+      "legacy guardian Slack text",
+    );
+    const legacyGuardianMetadataAfter = JSON.parse(
+      afterFirstRun["legacy-guardian-raw"]!.metadata!,
+    ) as Record<string, unknown>;
+    expect(legacyGuardianMetadataAfter.provenanceTrustClass).toBe("guardian");
+    expect(legacyGuardianMetadataAfter.provenanceSourceChannel).toBe("slack");
+
+    expect(afterFirstRun["legacy-guardian-json"]?.content).toBe(
+      legacyGuardianJsonContent,
+    );
+    const legacyGuardianJsonMetadataAfter = JSON.parse(
+      afterFirstRun["legacy-guardian-json"]!.metadata!,
+    ) as Record<string, unknown>;
+    expect(legacyGuardianJsonMetadataAfter.provenanceTrustClass).toBe(
+      "guardian",
+    );
+
+    expect(afterFirstRun["ambiguous-attachment-only"]?.content).toBe(
+      ambiguousAttachmentOnlyContent,
+    );
+    expect(afterFirstRun["ambiguous-attachment-only"]?.metadata).toBe(
+      ambiguousAttachmentOnlyMetadata,
+    );
+
+    expect(getFtsContent(raw, "slack-plain")).toBe("plain Slack text");
+    expect(getFtsContent(raw, "slack-json")).toContain("block Slack text");
+    expect(getFtsContent(raw, "slack-json")).not.toContain("<external_content");
+  });
+});