@vellumai/assistant 0.8.2 → 0.8.4

package/src/daemon/handlers/__tests__/config-a2a-complete.test.ts

@@ -0,0 +1,248 @@
+/**
+ * Tests for A2A invite completion handler (sender side).
+ *
+ * Uses the real DB (via `initializeDb()`) and the test preload which sets
+ * `VELLUM_WORKSPACE_DIR` to a per-file temp directory.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../../config/loader.js";
+import {
+  getAssistantContactMetadata,
+  getContact,
+} from "../../../contacts/contact-store.js";
+import { getSqlite } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import { findById } from "../../../memory/invite-store.js";
+import { completeA2AInvite, createA2AInvite } from "../config-a2a.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const sqlite = getSqlite();
+  sqlite.run("DELETE FROM assistant_ingress_invites");
+  sqlite.run("DELETE FROM assistant_contact_metadata");
+  sqlite.run("DELETE FROM contact_channels");
+  sqlite.run("DELETE FROM contacts");
+}
+
+function setConfig(opts: {
+  a2aEnabled?: boolean;
+  publicBaseUrl?: string;
+  ingressEnabled?: boolean;
+}): void {
+  const raw = loadRawConfig();
+  if (opts.a2aEnabled !== undefined) {
+    setNestedValue(raw, "a2a.enabled", opts.a2aEnabled);
+  }
+  if (opts.publicBaseUrl !== undefined) {
+    setNestedValue(raw, "ingress.publicBaseUrl", opts.publicBaseUrl);
+  }
+  if (opts.ingressEnabled !== undefined) {
+    setNestedValue(raw, "ingress.enabled", opts.ingressEnabled);
+  }
+  saveRawConfig(raw);
+  invalidateConfigCache();
+}
+
+const ACCEPTOR = {
+  assistantId: "acceptor-assistant-123",
+  displayName: "Acceptor Bot",
+  gatewayUrl: "https://acceptor.example.com",
+};
+
+describe("completeA2AInvite", () => {
+  beforeEach(() => {
+    resetTables();
+    setConfig({
+      a2aEnabled: false,
+      publicBaseUrl: "https://sender.example.com",
+      ingressEnabled: true,
+    });
+  });
+
+  test("happy path: promotes placeholder contact and returns sender identity", () => {
+    const created = createA2AInvite({});
+    expect(created.success).toBe(true);
+
+    const result = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.sender).toBeDefined();
+    expect(result.sender!.assistantId).toBe("sender-platform-id-789");
+    expect(result.sender!.gatewayUrl).toBe("https://sender.example.com");
+    expect(result.sender!.displayName).toBeDefined();
+    expect(result.error).toBeUndefined();
+
+    // Verify the placeholder contact was promoted
+    const invite = findById(created.inviteId!);
+    expect(invite).not.toBeNull();
+
+    const contact = getContact(invite!.contactId);
+    expect(contact).not.toBeNull();
+    expect(contact!.displayName).toBe("Acceptor Bot");
+    expect(contact!.channels).toHaveLength(1);
+    expect(contact!.channels[0]!.type).toBe("a2a");
+    expect(contact!.channels[0]!.status).toBe("active");
+    expect(contact!.channels[0]!.policy).toBe("allow");
+  });
+
+  test("contact channel address is acceptor.assistantId.toLowerCase()", () => {
+    const created = createA2AInvite({});
+    const acceptorWithUppercase = {
+      ...ACCEPTOR,
+      assistantId: "UPPER-Case-ID-123",
+    };
+
+    const result = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: acceptorWithUppercase,
+    });
+    expect(result.success).toBe(true);
+
+    const invite = findById(created.inviteId!);
+    const contact = getContact(invite!.contactId);
+    expect(contact!.channels[0]!.address).toBe("upper-case-id-123");
+    expect(contact!.channels[0]!.externalUserId).toBe("UPPER-Case-ID-123");
+  });
+
+  test("assistantContactMetadata has correct assistantId and gatewayUrl", () => {
+    const created = createA2AInvite({});
+    const result = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+    expect(result.success).toBe(true);
+
+    const invite = findById(created.inviteId!);
+    const metadata = getAssistantContactMetadata(invite!.contactId);
+    expect(metadata).not.toBeNull();
+    expect(metadata!.species).toBe("vellum");
+    expect(metadata!.metadata).toEqual({
+      assistantId: "acceptor-assistant-123",
+      gatewayUrl: "https://acceptor.example.com",
+    });
+  });
+
+  test("invalid token returns not_found error", () => {
+    const result = completeA2AInvite({
+      token: "invalid-token-that-does-not-exist",
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("not_found");
+  });
+
+  test("expired invite returns expired error", () => {
+    // Create an invite that expires immediately
+    const created = createA2AInvite({ expiresInHours: 0 });
+    expect(created.success).toBe(true);
+
+    // The invite was just created with 0 hours expiry, so expiresAt ~= now
+    // Manually expire it by updating the DB
+    const sqlite = getSqlite();
+    sqlite.run(
+      "UPDATE assistant_ingress_invites SET expires_at = ? WHERE id = ?",
+      [Date.now() - 1000, created.inviteId!],
+    );
+
+    const result = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("expired");
+  });
+
+  test("already-redeemed by same acceptor returns idempotent success", () => {
+    const created = createA2AInvite({});
+    expect(created.success).toBe(true);
+
+    // First completion
+    const first = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+    expect(first.success).toBe(true);
+
+    // Second completion with same acceptor
+    const second = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+    expect(second.success).toBe(true);
+  });
+
+  test("already-redeemed by different acceptor returns error", () => {
+    const created = createA2AInvite({});
+    expect(created.success).toBe(true);
+
+    // First completion
+    const first = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+    expect(first.success).toBe(true);
+
+    // Second completion with different acceptor
+    const second = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: {
+        assistantId: "different-assistant-456",
+        displayName: "Different Bot",
+        gatewayUrl: "https://different.example.com",
+      },
+    });
+
+    expect(second.success).toBe(false);
+    expect(second.error).toBe("already_redeemed_by_other");
+  });
+
+  test("fails before claiming token when public base URL is not configured", () => {
+    const created = createA2AInvite({});
+    expect(created.success).toBe(true);
+
+    setConfig({ publicBaseUrl: "", ingressEnabled: true });
+
+    const result = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("public base URL");
+
+    // Verify the invite was NOT consumed
+    const invite = findById(created.inviteId!);
+    expect(invite!.status).toBe("active");
+    expect(invite!.useCount).toBe(0);
+  });
+});

package/src/daemon/handlers/__tests__/config-a2a-invite.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Tests for A2A invite creation handler.
+ *
+ * Uses the real DB (via `initializeDb()`) and the test preload which sets
+ * `VELLUM_WORKSPACE_DIR` to a per-file temp directory.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../../config/loader.js";
+import { getContact } from "../../../contacts/contact-store.js";
+import { getSqlite } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import { findById } from "../../../memory/invite-store.js";
+import { createA2AInvite, getA2AConfig } from "../config-a2a.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const sqlite = getSqlite();
+  sqlite.run("DELETE FROM assistant_ingress_invites");
+  sqlite.run("DELETE FROM assistant_contact_metadata");
+  sqlite.run("DELETE FROM contact_channels");
+  sqlite.run("DELETE FROM contacts");
+}
+
+function setConfig(opts: {
+  a2aEnabled?: boolean;
+  publicBaseUrl?: string;
+  ingressEnabled?: boolean;
+}): void {
+  const raw = loadRawConfig();
+  if (opts.a2aEnabled !== undefined) {
+    setNestedValue(raw, "a2a.enabled", opts.a2aEnabled);
+  }
+  if (opts.publicBaseUrl !== undefined) {
+    setNestedValue(raw, "ingress.publicBaseUrl", opts.publicBaseUrl);
+  }
+  if (opts.ingressEnabled !== undefined) {
+    setNestedValue(raw, "ingress.enabled", opts.ingressEnabled);
+  }
+  saveRawConfig(raw);
+  invalidateConfigCache();
+}
+
+describe("createA2AInvite", () => {
+  beforeEach(() => {
+    resetTables();
+    setConfig({
+      a2aEnabled: false,
+      publicBaseUrl: "https://example.vellum.ai",
+      ingressEnabled: true,
+    });
+  });
+
+  test("returns success with inviteId, token, expiresAt, senderGatewayUrl", () => {
+    const result = createA2AInvite({});
+    expect(result.success).toBe(true);
+    expect(result.inviteId).toBeDefined();
+    expect(result.token).toBeDefined();
+    expect(result.expiresAt).toBeDefined();
+    expect(result.senderGatewayUrl).toBe("https://example.vellum.ai");
+    expect(result.error).toBeUndefined();
+  });
+
+  test("creates invite in DB with source_channel=a2a, status=active, max_uses=1", () => {
+    const result = createA2AInvite({});
+    expect(result.inviteId).toBeDefined();
+
+    const invite = findById(result.inviteId!);
+    expect(invite).not.toBeNull();
+    expect(invite!.sourceChannel).toBe("a2a");
+    expect(invite!.status).toBe("active");
+    expect(invite!.maxUses).toBe(1);
+  });
+
+  test("auto-enables A2A if not already on", () => {
+    // A2A starts disabled
+    expect(getA2AConfig().enabled).toBe(false);
+
+    const result = createA2AInvite({});
+    expect(result.success).toBe(true);
+
+    // A2A should now be enabled
+    expect(getA2AConfig().enabled).toBe(true);
+  });
+
+  test("creates placeholder contact with no channels, bound to invite via contactId", () => {
+    const result = createA2AInvite({});
+    expect(result.inviteId).toBeDefined();
+
+    const invite = findById(result.inviteId!);
+    expect(invite).not.toBeNull();
+
+    const contact = getContact(invite!.contactId);
+    expect(contact).not.toBeNull();
+    expect(contact!.displayName).toBe("Pending A2A invite");
+    expect(contact!.channels).toHaveLength(0);
+  });
+
+  test("returns error when public base URL is not configured", () => {
+    setConfig({
+      a2aEnabled: false,
+      publicBaseUrl: "",
+      ingressEnabled: true,
+    });
+
+    const result = createA2AInvite({});
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("public base URL");
+  });
+
+  test("custom expiry via expiresInHours", () => {
+    const before = Date.now();
+    const result = createA2AInvite({ expiresInHours: 24 });
+    const after = Date.now();
+    expect(result.success).toBe(true);
+
+    const invite = findById(result.inviteId!);
+    expect(invite).not.toBeNull();
+
+    const expectedMinMs = before + 24 * 60 * 60 * 1000;
+    const expectedMaxMs = after + 24 * 60 * 60 * 1000;
+    expect(invite!.expiresAt).toBeGreaterThanOrEqual(expectedMinMs);
+    expect(invite!.expiresAt).toBeLessThanOrEqual(expectedMaxMs);
+  });
+
+  test("default expiry is 72 hours", () => {
+    const before = Date.now();
+    const result = createA2AInvite({});
+    const after = Date.now();
+    expect(result.success).toBe(true);
+
+    const invite = findById(result.inviteId!);
+    expect(invite).not.toBeNull();
+
+    const expectedMinMs = before + 72 * 60 * 60 * 1000;
+    const expectedMaxMs = after + 72 * 60 * 60 * 1000;
+    expect(invite!.expiresAt).toBeGreaterThanOrEqual(expectedMinMs);
+    expect(invite!.expiresAt).toBeLessThanOrEqual(expectedMaxMs);
+  });
+});

package/src/daemon/handlers/__tests__/config-a2a-redeem.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Tests for A2A invite redemption handler (receiver side).
+ *
+ * Uses the real DB (via `initializeDb()`) and the test preload which sets
+ * `VELLUM_WORKSPACE_DIR` to a per-file temp directory.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../../config/loader.js";
+import {
+  getAssistantContactMetadata,
+  getContact,
+} from "../../../contacts/contact-store.js";
+import { getSqlite } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import { getA2AConfig, redeemA2AInvite } from "../config-a2a.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const sqlite = getSqlite();
+  sqlite.run("DELETE FROM assistant_contact_metadata");
+  sqlite.run("DELETE FROM contact_channels");
+  sqlite.run("DELETE FROM contacts");
+}
+
+function setConfig(opts: { a2aEnabled?: boolean }): void {
+  const raw = loadRawConfig();
+  if (opts.a2aEnabled !== undefined) {
+    setNestedValue(raw, "a2a.enabled", opts.a2aEnabled);
+  }
+  saveRawConfig(raw);
+  invalidateConfigCache();
+}
+
+const SENDER = {
+  assistantId: "sender-assistant-123",
+  displayName: "Sender Bot",
+  gatewayUrl: "https://sender.example.com",
+};
+
+describe("redeemA2AInvite", () => {
+  beforeEach(() => {
+    resetTables();
+    setConfig({ a2aEnabled: false });
+  });
+
+  test("happy path: creates local contact with sender identity", () => {
+    const result = redeemA2AInvite({ sender: SENDER });
+
+    expect(result.success).toBe(true);
+    expect(result.contactId).toBeDefined();
+    expect(result.alreadyConnected).toBeUndefined();
+    expect(result.error).toBeUndefined();
+
+    const contact = getContact(result.contactId!);
+    expect(contact).not.toBeNull();
+    expect(contact!.displayName).toBe("Sender Bot");
+    expect(contact!.channels).toHaveLength(1);
+    expect(contact!.channels[0]!.type).toBe("a2a");
+    expect(contact!.channels[0]!.status).toBe("active");
+    expect(contact!.channels[0]!.policy).toBe("allow");
+  });
+
+  test("idempotency: already-connected sender returns alreadyConnected", () => {
+    const first = redeemA2AInvite({ sender: SENDER });
+    expect(first.success).toBe(true);
+
+    const second = redeemA2AInvite({ sender: SENDER });
+    expect(second.success).toBe(true);
+    expect(second.alreadyConnected).toBe(true);
+    expect(second.contactId).toBe(first.contactId);
+  });
+
+  test("auto-enables A2A if disabled", () => {
+    setConfig({ a2aEnabled: false });
+
+    const result = redeemA2AInvite({ sender: SENDER });
+    expect(result.success).toBe(true);
+
+    // Verify A2A was auto-enabled by checking config
+    const config = getA2AConfig();
+    expect(config.enabled).toBe(true);
+  });
+
+  test("assistantContactMetadata has correct assistantId and gatewayUrl", () => {
+    const result = redeemA2AInvite({ sender: SENDER });
+    expect(result.success).toBe(true);
+
+    const metadata = getAssistantContactMetadata(result.contactId!);
+    expect(metadata).not.toBeNull();
+    expect(metadata!.species).toBe("vellum");
+    expect(metadata!.metadata).toEqual({
+      assistantId: "sender-assistant-123",
+      gatewayUrl: "https://sender.example.com",
+    });
+  });
+
+  test("channel address uses sender.assistantId.toLowerCase()", () => {
+    const senderWithUppercase = {
+      ...SENDER,
+      assistantId: "UPPER-Case-SENDER-ID",
+    };
+
+    const result = redeemA2AInvite({ sender: senderWithUppercase });
+    expect(result.success).toBe(true);
+
+    const contact = getContact(result.contactId!);
+    expect(contact!.channels[0]!.address).toBe("upper-case-sender-id");
+    expect(contact!.channels[0]!.externalUserId).toBe("UPPER-Case-SENDER-ID");
+  });
+
+  test("does not make outbound fetch calls", () => {
+    // This test verifies that redeemA2AInvite is purely local — no fetch mock
+    // is installed. If it tried to fetch, the call would fail and the test
+    // would throw.
+    const result = redeemA2AInvite({ sender: SENDER });
+    expect(result.success).toBe(true);
+  });
+});

package/src/daemon/handlers/__tests__/config-a2a.test.ts

@@ -0,0 +1,95 @@
+/**
+ * Tests for A2A config handler.
+ *
+ * Uses the real DB (via `initializeDb()`) and the test preload which sets
+ * `VELLUM_WORKSPACE_DIR` to a per-file temp directory.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../../config/loader.js";
+import { getSqlite } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import { clearA2AConfig, getA2AConfig, setA2AConfig } from "../config-a2a.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const sqlite = getSqlite();
+  sqlite.run("DELETE FROM assistant_contact_metadata");
+  sqlite.run("DELETE FROM contact_channels");
+  sqlite.run("DELETE FROM contacts");
+}
+
+function setConfigEnabled(enabled: boolean): void {
+  const raw = loadRawConfig();
+  setNestedValue(raw, "a2a.enabled", enabled);
+  saveRawConfig(raw);
+  invalidateConfigCache();
+}
+
+describe("getA2AConfig", () => {
+  beforeEach(() => {
+    resetTables();
+    setConfigEnabled(false);
+  });
+
+  test("returns enabled: false when a2a is disabled", () => {
+    const result = getA2AConfig();
+    expect(result.success).toBe(true);
+    expect(result.enabled).toBe(false);
+    expect(result.activeConnections).toBe(0);
+  });
+
+  test("returns enabled: true when a2a is enabled", () => {
+    setConfigEnabled(true);
+    const result = getA2AConfig();
+    expect(result.success).toBe(true);
+    expect(result.enabled).toBe(true);
+  });
+});
+
+describe("setA2AConfig", () => {
+  beforeEach(() => {
+    resetTables();
+    setConfigEnabled(false);
+  });
+
+  test("enables a2a in config", () => {
+    const result = setA2AConfig();
+    expect(result.success).toBe(true);
+    expect(result.enabled).toBe(true);
+  });
+
+  test("is idempotent", () => {
+    setA2AConfig();
+    const result = setA2AConfig();
+    expect(result.success).toBe(true);
+    expect(result.enabled).toBe(true);
+  });
+});
+
+describe("clearA2AConfig", () => {
+  beforeEach(() => {
+    resetTables();
+    setConfigEnabled(true);
+  });
+
+  test("disables a2a in config", () => {
+    const result = clearA2AConfig();
+    expect(result.success).toBe(true);
+    expect(result.enabled).toBe(false);
+  });
+});