@vellumai/assistant 0.10.3 → 0.10.4-staging.1

package/src/__tests__/helpers/seed-contact-channel.ts

@@ -0,0 +1,96 @@
+/**
+ * Test-only member seeding.
+ *
+ * Production identity upserts no longer write ACL columns (gateway-owned).
+ * Tests that simulate gateway-resolved members stamp the ACL columns directly
+ * and warm the member-verdict cache so verdict synthesis and the sync trust
+ * fallback resolve the intended trust.
+ */
+
+import { eq } from "drizzle-orm";
+
+import { isChannelId } from "../../channels/types.js";
+import { upsertContact } from "../../contacts/contact-store.js";
+import type {
+  ChannelPolicy,
+  ChannelStatus,
+  ContactRole,
+} from "../../contacts/types.js";
+import { getDb } from "../../memory/db-connection.js";
+import { contactChannels, contacts } from "../../memory/schema.js";
+import { setMemberVerdict } from "../../runtime/member-verdict-cache.js";
+
+export function seedContactChannel(params: {
+  sourceChannel: string;
+  externalUserId?: string;
+  externalChatId?: string;
+  displayName?: string;
+  username?: string;
+  contactId?: string;
+  role?: ContactRole;
+  status?: ChannelStatus;
+  policy?: string;
+  verifiedAt?: number | null;
+  verifiedVia?: string | null;
+  inviteId?: string | null;
+  revokedReason?: string | null;
+  blockedReason?: string | null;
+  principalId?: string | null;
+}): { contactId: string; channelId: string } {
+  const address = params.externalUserId ?? params.externalChatId;
+  if (!address) throw new Error("seedContactChannel requires an address");
+
+  const contact = upsertContact({
+    id: params.contactId,
+    displayName: params.displayName ?? address,
+    channels: [
+      {
+        type: params.sourceChannel,
+        address,
+        externalChatId: params.externalChatId ?? null,
+        inviteId: params.inviteId ?? null,
+      },
+    ],
+    reassignConflictingChannels: !!params.contactId,
+  });
+
+  const db = getDb();
+  if (params.role !== undefined || params.principalId !== undefined) {
+    const set: Record<string, unknown> = {};
+    if (params.role !== undefined) set.role = params.role;
+    if (params.principalId !== undefined) set.principalId = params.principalId;
+    db.update(contacts).set(set).where(eq(contacts.id, contact.id)).run();
+  }
+
+  const channel = contact.channels.find(
+    (ch) => ch.type === params.sourceChannel,
+  )!;
+  const aclSet: Record<string, unknown> = { updatedAt: Date.now() };
+  if (params.status !== undefined) aclSet.status = params.status;
+  if (params.policy !== undefined) aclSet.policy = params.policy;
+  if (params.verifiedAt !== undefined) aclSet.verifiedAt = params.verifiedAt;
+  if (params.verifiedVia !== undefined) aclSet.verifiedVia = params.verifiedVia;
+  if (params.revokedReason !== undefined)
+    aclSet.revokedReason = params.revokedReason;
+  if (params.blockedReason !== undefined)
+    aclSet.blockedReason = params.blockedReason;
+  db.update(contactChannels)
+    .set(aclSet)
+    .where(eq(contactChannels.id, channel.id))
+    .run();
+
+  // Warm the verdict cache so the sync trust fallback resolves this member, as
+  // a gateway verdict fetch would in production.
+  if (isChannelId(params.sourceChannel)) {
+    setMemberVerdict(params.sourceChannel, address, {
+      trustClass: params.role === "guardian" ? "guardian" : "unknown",
+      canonicalSenderId: address,
+      contactId: contact.id,
+      channelId: channel.id,
+      status: (params.status ?? "active") as ChannelStatus,
+      policy: (params.policy ?? "allow") as ChannelPolicy,
+    });
+  }
+
+  return { contactId: contact.id, channelId: channel.id };
+}

package/src/__tests__/inbound-invite-redemption.test.ts

@@ -76,6 +76,9 @@ mock.module("../ipc/gateway-client.js", () => ({
     params?: Record<string, unknown>,
   ) => {
     gatewayIpcCalls.push({ method, params });
+    if (method === "contacts_get_rich") {
+      return richContactForId(params?.contactId as string);
+    }
     if (method === "record_invite_redemption") {
       return { ok: true, updated: true, mirrored: true };
     }
@@ -86,15 +89,88 @@ mock.module("../ipc/gateway-client.js", () => ({
   },
 }));
 
+// Serves contacts_get_rich (the gateway ACL read backing the gate-status
+// fallback) from the seeded local contact, so gate resolution sources status
+// from the gateway path rather than the local channel column.
+function richContactForId(contactId: string | undefined) {
+  if (!contactId) return undefined;
+  const contact = getContact(contactId);
+  if (!contact) return undefined;
+  // ACL columns live on the still-present DB rows, not the slimmed interfaces;
+  // read them raw to build the gateway-rich response the production read parses.
+  const contactRole = (
+    getSqlite()
+      .query("SELECT role FROM contacts WHERE id = ?")
+      .get(contact.id) as { role: string } | undefined
+  )?.role;
+  return {
+    ok: true,
+    contact: {
+      id: contact.id,
+      displayName: contact.displayName,
+      role: contactRole ?? "contact",
+      interactionCount: contact.interactionCount,
+      createdAt: contact.createdAt,
+      updatedAt: contact.updatedAt,
+      channels: contact.channels.map((c) => {
+        const acl = rawChannelAcl(c.id);
+        return {
+          id: c.id,
+          contactId: c.contactId,
+          type: c.type,
+          address: c.address,
+          isPrimary: c.isPrimary,
+          externalUserId: c.externalChatId,
+          status: acl.status,
+          policy: acl.policy,
+          verifiedAt: acl.verifiedAt,
+          verifiedVia: acl.verifiedVia,
+          lastSeenAt: acl.lastSeenAt,
+          interactionCount: acl.interactionCount,
+          lastInteraction: acl.lastInteraction,
+          revokedReason: acl.revokedReason,
+          blockedReason: acl.blockedReason,
+        };
+      }),
+    },
+  };
+}
+
+/** Read a channel's ACL columns straight off the still-present DB row. */
+function rawChannelAcl(channelId: string) {
+  return getSqlite()
+    .query(
+      `SELECT status, policy, verified_at AS verifiedAt, verified_via AS verifiedVia,
+              last_seen_at AS lastSeenAt, interaction_count AS interactionCount,
+              last_interaction AS lastInteraction, revoked_reason AS revokedReason,
+              blocked_reason AS blockedReason
+         FROM contact_channels WHERE id = ?`,
+    )
+    .get(channelId) as {
+    status: string;
+    policy: string;
+    verifiedAt: number | null;
+    verifiedVia: string | null;
+    lastSeenAt: number | null;
+    interactionCount: number;
+    lastInteraction: number | null;
+    revokedReason: string | null;
+    blockedReason: string | null;
+  };
+}
+
 import {
   findContactChannel,
+  getContact,
   upsertContact,
 } from "../contacts/contact-store.js";
-import { upsertContactChannel } from "../contacts/contacts-write.js";
-import { getDb } from "../memory/db-connection.js";
+import { getDb, getSqlite } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { createInvite, revokeInvite } from "../memory/invite-store.js";
-import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
+import {
+  handleChannelInbound,
+  seedContactChannel,
+} from "./helpers/channel-test-adapter.js";
 
 await initializeDb();
 
@@ -192,13 +268,13 @@ describe("inbound invite redemption intercept", () => {
     expect(json.memberId).toEqual(expect.any(String));
     expect(json.denied).toBeUndefined();
 
-    // Verify the user is now an active member
+    // The local mirror persists the member identity row; the gateway owns the
+    // active ACL verdict.
     const result = findContactChannel({
       channelType: "telegram",
       address: "user-invite-123",
     });
     expect(result).not.toBeNull();
-    expect(result!.channel.status).toBe("active");
 
     // The activation is written to the gateway via upsert_verified_channel.
     expect(
@@ -337,7 +413,7 @@ describe("inbound invite redemption intercept", () => {
 
   test("existing active member sending normal message is unaffected", async () => {
     // Pre-create an active member
-    upsertContactChannel({
+    seedContactChannel({
       sourceChannel: "telegram",
       externalUserId: "user-active-member",
       externalChatId: "chat-active",
@@ -391,7 +467,7 @@ describe("inbound invite redemption intercept", () => {
     });
 
     // Pre-create an active member that will click the invite link
-    upsertContactChannel({
+    seedContactChannel({
       sourceChannel: "telegram",
       externalUserId: "user-already-active",
       externalChatId: "chat-invite-test",
@@ -414,7 +490,7 @@ describe("inbound invite redemption intercept", () => {
   test("reactivation via invite preserves existing guardian-managed member display name", async () => {
     // Pre-create a revoked member named "Jeff" — the invite should preserve
     // that guardian-assigned name rather than overwriting with the Telegram name.
-    upsertContactChannel({
+    seedContactChannel({
       sourceChannel: "telegram",
       externalUserId: "user-invite-123",
       externalChatId: "chat-invite-test",
@@ -423,7 +499,7 @@ describe("inbound invite redemption intercept", () => {
       displayName: "Jeff",
     });
 
-    // Look up the contact that upsertContactChannel created so we can use
+    // Look up the contact that the seed created so we can use
     // its ID as the invite's contactId (satisfies the FK constraint).
     const existing = findContactChannel({
       channelType: "telegram",
@@ -453,7 +529,8 @@ describe("inbound invite redemption intercept", () => {
       externalChatId: "chat-invite-test",
     });
     expect(result).not.toBeNull();
-    expect(result!.channel.status).toBe("active");
+    // The gateway owns reactivation; the local mirror preserves the
+    // guardian-assigned display name rather than the raw platform identity.
     expect(result!.contact.displayName).toBe("Jeff");
   });
 });