@vellumai/assistant 0.3.19 → 0.3.21

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

@@ -0,0 +1,306 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterAll, beforeEach, describe, expect, mock, test } from 'bun:test';
+
+const testDir = mkdtempSync(join(tmpdir(), 'invite-redemption-service-test-'));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === 'darwin',
+  isLinux: () => process.platform === 'linux',
+  isWindows: () => process.platform === 'win32',
+  getSocketPath: () => join(testDir, 'test.sock'),
+  getPidPath: () => join(testDir, 'test.pid'),
+  getDbPath: () => join(testDir, 'test.db'),
+  getLogPath: () => join(testDir, 'test.log'),
+  ensureDataDir: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+import { getSqlite, initializeDb, resetDb } from '../memory/db.js';
+import { createInvite, revokeInvite as revokeStoreFn } from '../memory/ingress-invite-store.js';
+import { upsertMember } from '../memory/ingress-member-store.js';
+import { type InviteRedemptionOutcome,redeemInvite } from '../runtime/invite-redemption-service.js';
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+});
+
+function resetTables() {
+  getSqlite().run('DELETE FROM assistant_ingress_members');
+  getSqlite().run('DELETE FROM assistant_ingress_invites');
+}
+
+describe('invite-redemption-service', () => {
+  beforeEach(resetTables);
+
+  test('redeems a valid invite and returns typed outcome', () => {
+    const { rawToken, invite } = createInvite({ sourceChannel: 'telegram', maxUses: 1 });
+
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: 'telegram',
+      externalUserId: 'user-1',
+    });
+
+    expect(outcome.ok).toBe(true);
+    expect(outcome).toEqual({
+      ok: true,
+      type: 'redeemed',
+      memberId: expect.any(String),
+      inviteId: invite.id,
+    });
+  });
+
+  test('returns invalid_token for a bogus token', () => {
+    const outcome = redeemInvite({
+      rawToken: 'totally-bogus-token',
+      sourceChannel: 'telegram',
+      externalUserId: 'user-1',
+    });
+
+    expect(outcome).toEqual({ ok: false, reason: 'invalid_token' });
+  });
+
+  test('returns expired for an expired invite', () => {
+    // Create an invite that expired 1 ms ago
+    const { rawToken } = createInvite({
+      sourceChannel: 'telegram',
+      maxUses: 1,
+      expiresInMs: -1,
+    });
+
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: 'telegram',
+      externalUserId: 'user-1',
+    });
+
+    expect(outcome).toEqual({ ok: false, reason: 'expired' });
+  });
+
+  test('returns revoked for a revoked invite', () => {
+    const { rawToken, invite } = createInvite({
+      sourceChannel: 'telegram',
+      maxUses: 1,
+    });
+    revokeStoreFn(invite.id);
+
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: 'telegram',
+      externalUserId: 'user-1',
+    });
+
+    expect(outcome).toEqual({ ok: false, reason: 'revoked' });
+  });
+
+  test('returns max_uses_reached when invite is fully consumed', () => {
+    const { rawToken } = createInvite({ sourceChannel: 'telegram', maxUses: 1 });
+
+    // First redemption should succeed
+    const first = redeemInvite({
+      rawToken,
+      sourceChannel: 'telegram',
+      externalUserId: 'user-1',
+    });
+    expect(first.ok).toBe(true);
+
+    // Second attempt should fail — the invite is now fully redeemed
+    const second = redeemInvite({
+      rawToken,
+      sourceChannel: 'telegram',
+      externalUserId: 'user-2',
+    });
+
+    expect(second).toEqual({ ok: false, reason: 'max_uses_reached' });
+  });
+
+  test('returns channel_mismatch when redeeming on wrong channel', () => {
+    const { rawToken } = createInvite({ sourceChannel: 'telegram', maxUses: 1 });
+
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: 'sms',
+      externalUserId: 'user-1',
+    });
+
+    expect(outcome).toEqual({ ok: false, reason: 'channel_mismatch' });
+  });
+
+  test('returns missing_identity when no externalUserId or externalChatId', () => {
+    const { rawToken } = createInvite({ sourceChannel: 'telegram', maxUses: 1 });
+
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: 'telegram',
+    });
+
+    expect(outcome).toEqual({ ok: false, reason: 'missing_identity' });
+  });
+
+  test('returns already_member when user is already an active member', () => {
+    const { rawToken } = createInvite({ sourceChannel: 'telegram', maxUses: 5 });
+
+    // Pre-create an active member
+    upsertMember({
+      sourceChannel: 'telegram',
+      externalUserId: 'existing-user',
+      status: 'active',
+    });
+
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: 'telegram',
+      externalUserId: 'existing-user',
+    });
+
+    expect(outcome.ok).toBe(true);
+    expect((outcome as Extract<InviteRedemptionOutcome, { type: 'already_member' }>).type).toBe('already_member');
+    expect((outcome as Extract<InviteRedemptionOutcome, { type: 'already_member' }>).memberId).toEqual(expect.any(String));
+  });
+
+  test('returns invalid_token for a blocked member to avoid leaking membership status', () => {
+    const { rawToken } = createInvite({ sourceChannel: 'telegram', maxUses: 5 });
+
+    // Pre-create a blocked member — simulates a guardian-initiated block
+    upsertMember({
+      sourceChannel: 'telegram',
+      externalUserId: 'blocked-user',
+      status: 'blocked',
+    });
+
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: 'telegram',
+      externalUserId: 'blocked-user',
+    });
+
+    expect(outcome).toEqual({ ok: false, reason: 'invalid_token' });
+  });
+
+  test('does not return already_member for a revoked member', () => {
+    const { rawToken } = createInvite({ sourceChannel: 'telegram', maxUses: 5 });
+
+    // Pre-create a revoked member
+    const member = upsertMember({
+      sourceChannel: 'telegram',
+      externalUserId: 'revoked-user',
+      status: 'revoked',
+    });
+    expect(member.status).toBe('revoked');
+
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: 'telegram',
+      externalUserId: 'revoked-user',
+    });
+
+    // Should redeem, not return already_member
+    expect(outcome.ok).toBe(true);
+    expect((outcome as Extract<InviteRedemptionOutcome, { type: 'redeemed' }>).type).toBe('redeemed');
+  });
+
+  test('raw token is not present in the outcome object', () => {
+    const { rawToken } = createInvite({ sourceChannel: 'telegram', maxUses: 1 });
+
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: 'telegram',
+      externalUserId: 'user-1',
+    });
+
+    // Verify the raw token does not appear anywhere in the serialized outcome
+    const serialized = JSON.stringify(outcome);
+    expect(serialized).not.toContain(rawToken);
+  });
+
+  test('channel enforcement blocks cross-channel redemption (voice invite via slack)', () => {
+    const { rawToken } = createInvite({ sourceChannel: 'voice', maxUses: 1 });
+
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: 'slack',
+      externalUserId: 'user-1',
+    });
+
+    expect(outcome).toEqual({ ok: false, reason: 'channel_mismatch' });
+  });
+
+  test('returns invalid_token for an active member with a bogus token (no membership probing)', () => {
+    // Pre-create an active member
+    upsertMember({
+      sourceChannel: 'telegram',
+      externalUserId: 'probed-user',
+      status: 'active',
+    });
+
+    // Attempt to redeem with a bogus token — must NOT leak membership status
+    const outcome = redeemInvite({
+      rawToken: 'completely-bogus-token',
+      sourceChannel: 'telegram',
+      externalUserId: 'probed-user',
+    });
+
+    expect(outcome).toEqual({ ok: false, reason: 'invalid_token' });
+  });
+
+  test('returns expired for an active member with an expired invite token', () => {
+    // Create an expired invite
+    const { rawToken } = createInvite({
+      sourceChannel: 'telegram',
+      maxUses: 5,
+      expiresInMs: -1,
+    });
+
+    // Pre-create an active member
+    upsertMember({
+      sourceChannel: 'telegram',
+      externalUserId: 'expired-token-user',
+      status: 'active',
+    });
+
+    // Expired token must return expired, not already_member
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: 'telegram',
+      externalUserId: 'expired-token-user',
+    });
+
+    expect(outcome).toEqual({ ok: false, reason: 'expired' });
+  });
+
+  test('returns channel_mismatch for an active member with a valid token for a different channel', () => {
+    // Create an invite for SMS
+    const { rawToken } = createInvite({
+      sourceChannel: 'sms',
+      maxUses: 5,
+    });
+
+    // Pre-create an active member on telegram
+    upsertMember({
+      sourceChannel: 'telegram',
+      externalUserId: 'cross-channel-user',
+      status: 'active',
+    });
+
+    // Valid token for wrong channel must return channel_mismatch, not already_member
+    const outcome = redeemInvite({
+      rawToken,
+      sourceChannel: 'telegram',
+      externalUserId: 'cross-channel-user',
+    });
+
+    expect(outcome).toEqual({ ok: false, reason: 'channel_mismatch' });
+  });
+});

package/src/__tests__/ipc-snapshot.test.ts

@@ -731,6 +731,27 @@ const clientMessages: Record<ClientMessageType, ClientMessage> = {
     type: 'voice_config_update',
     activationKey: 'fn',
   },
+  generate_avatar: {
+    type: 'generate_avatar',
+    description: 'a friendly purple cat with green eyes wearing a tiny hat',
+  },
+  guardian_actions_pending_request: {
+    type: 'guardian_actions_pending_request',
+    conversationId: 'conv-guardian-001',
+  },
+  guardian_action_decision: {
+    type: 'guardian_action_decision',
+    requestId: 'req-guardian-001',
+    action: 'approve_once',
+    conversationId: 'conv-guardian-001',
+  },
+  reorder_threads: {
+    type: 'reorder_threads',
+    updates: [
+      { sessionId: 'sess-001', displayOrder: 0, isPinned: false },
+      { sessionId: 'sess-002', displayOrder: 1, isPinned: true },
+    ],
+  },
 };
 
 // ---------------------------------------------------------------------------
@@ -2020,6 +2041,42 @@ const serverMessages: Record<ServerMessageType, ServerMessage> = {
     emoji: '',
     home: '',
   },
+  avatar_updated: {
+    type: 'avatar_updated',
+    avatarPath: '/Users/test/.vellum/workspace/data/avatar/custom-avatar.png',
+  },
+  generate_avatar_response: {
+    type: 'generate_avatar_response',
+    success: true,
+    error: undefined,
+  },
+  guardian_actions_pending_response: {
+    type: 'guardian_actions_pending_response',
+    conversationId: 'conv-guardian-001',
+    prompts: [
+      {
+        requestId: 'req-guardian-001',
+        requestCode: 'REQ-GU',
+        state: 'pending',
+        questionText: 'Approve tool: bash',
+        toolName: 'bash',
+        actions: [
+          { action: 'approve_once', label: 'Approve once' },
+          { action: 'reject', label: 'Reject' },
+        ],
+        expiresAt: 1700100000000,
+        conversationId: 'conv-guardian-001',
+        callSessionId: null,
+      },
+    ],
+  },
+  guardian_action_decision_response: {
+    type: 'guardian_action_decision_response',
+    applied: true,
+    reason: undefined,
+    requestId: 'req-guardian-001',
+    userText: undefined,
+  },
 };
 
 // ---------------------------------------------------------------------------

package/src/__tests__/notification-decision-fallback.test.ts

@@ -0,0 +1,88 @@
+/**
+ * Regression tests for notification decision fallback copy.
+ *
+ * Ensures fallback decisions still produce human-friendly copy when the
+ * decision-model call is unavailable.
+ */
+
+import { describe, expect, mock, test } from 'bun:test';
+
+mock.module('../channels/config.js', () => ({
+  getDeliverableChannels: () => ['vellum', 'telegram', 'sms'],
+}));
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({
+    notifications: {
+      decisionModelIntent: 'latency-optimized',
+    },
+  }),
+}));
+
+mock.module('../notifications/decisions-store.js', () => ({
+  createDecision: () => {},
+}));
+
+mock.module('../notifications/preference-summary.js', () => ({
+  getPreferenceSummary: () => undefined,
+}));
+
+mock.module('../notifications/thread-candidates.js', () => ({
+  buildThreadCandidates: () => undefined,
+  serializeCandidatesForPrompt: () => undefined,
+}));
+
+mock.module('../providers/provider-send-message.js', () => ({
+  getConfiguredProvider: () => null,
+  createTimeout: () => ({
+    signal: new AbortController().signal,
+    cleanup: () => {},
+  }),
+  extractToolUse: () => null,
+  userMessage: (text: string) => ({ role: 'user', content: text }),
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { evaluateSignal } from '../notifications/decision-engine.js';
+import type { NotificationSignal } from '../notifications/signal.js';
+import type { NotificationChannel } from '../notifications/types.js';
+
+function makeSignal(overrides?: Partial<NotificationSignal>): NotificationSignal {
+  return {
+    signalId: 'sig-fallback-guardian-1',
+    assistantId: 'self',
+    createdAt: Date.now(),
+    sourceChannel: 'voice',
+    sourceSessionId: 'call-session-1',
+    sourceEventName: 'guardian.question',
+    contextPayload: {
+      questionText: 'What is the gate code?',
+    },
+    attentionHints: {
+      requiresAction: true,
+      urgency: 'high',
+      isAsyncBackground: false,
+      visibleInSourceNow: false,
+    },
+    ...overrides,
+  };
+}
+
+describe('notification decision fallback copy', () => {
+  test('uses human-friendly template copy for guardian.question', async () => {
+    const signal = makeSignal();
+    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+
+    expect(decision.fallbackUsed).toBe(true);
+    expect(decision.renderedCopy.vellum?.title).toBe('Guardian Question');
+    expect(decision.renderedCopy.vellum?.body).toBe('What is the gate code?');
+    expect(decision.renderedCopy.vellum?.title).not.toBe('guardian.question');
+    expect(decision.renderedCopy.vellum?.body).not.toContain('Action required: guardian.question');
+  });
+});