@vellumai/assistant 0.6.0 → 0.6.2

package/src/cli/commands/__tests__/email-register.test.ts

@@ -0,0 +1,186 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getMockFetchCalls,
+  mockFetch,
+  resetMockFetch,
+} from "../../../__tests__/mock-fetch.js";
+import { _setOverridesForTesting } from "../../../config/assistant-feature-flags.js";
+import { setPlatformAssistantId } from "../../../config/env.js";
+import { credentialKey } from "../../../security/credential-key.js";
+import {
+  _resetBackend,
+  setSecureKeyAsync,
+} from "../../../security/secure-keys.js";
+import { runAssistantCommand } from "../../__tests__/run-assistant-command.js";
+
+const ASSISTANT_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+const API_KEY_CREDENTIAL = credentialKey("vellum", "assistant_api_key");
+
+beforeEach(async () => {
+  process.exitCode = 0;
+  _resetBackend();
+  resetMockFetch();
+  _setOverridesForTesting({ "email-channel": true });
+  setPlatformAssistantId(ASSISTANT_ID);
+  await setSecureKeyAsync(API_KEY_CREDENTIAL, "test-api-key");
+});
+
+afterEach(() => {
+  resetMockFetch();
+  _setOverridesForTesting({});
+  setPlatformAssistantId(undefined);
+  _resetBackend();
+});
+
+describe("assistant email register", () => {
+  test("successful registration calls correct URL and body", async () => {
+    mockFetch(
+      "/email-addresses/",
+      { method: "POST" },
+      {
+        body: {
+          id: "550e8400-e29b-41d4-a716-446655440000",
+          address: "mybot@vellum.me",
+          created_at: "2026-04-04T21:00:00Z",
+        },
+        status: 201,
+      },
+    );
+
+    await runAssistantCommand("email", "register", "mybot");
+
+    const calls = getMockFetchCalls();
+    expect(calls).toHaveLength(1);
+    expect(calls[0].path).toBe(
+      `/v1/assistants/${ASSISTANT_ID}/email-addresses/`,
+    );
+    expect(calls[0].init.method).toBe("POST");
+    expect(JSON.parse(calls[0].init.body as string)).toEqual({
+      username: "mybot",
+    });
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("--json outputs structured response", async () => {
+    mockFetch(
+      "/email-addresses/",
+      { method: "POST" },
+      {
+        body: {
+          id: "550e8400-e29b-41d4-a716-446655440000",
+          address: "support@vellum.me",
+          created_at: "2026-04-04T21:00:00Z",
+        },
+        status: 201,
+      },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "register",
+      "support",
+    );
+
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.address).toBe("support@vellum.me");
+    expect(parsed.id).toBe("550e8400-e29b-41d4-a716-446655440000");
+    expect(parsed.created_at).toBe("2026-04-04T21:00:00Z");
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("duplicate address returns error", async () => {
+    mockFetch(
+      "/email-addresses/",
+      { method: "POST" },
+      {
+        body: {
+          assistant_id: ["This assistant already has an email address."],
+        },
+        status: 400,
+      },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "register",
+      "mybot",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("already has an email address");
+  });
+
+  test("missing platform credentials returns error", async () => {
+    // Remove the API key so create() returns null
+    _resetBackend();
+    setPlatformAssistantId(undefined);
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "register",
+      "mybot",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Platform credentials not configured");
+  });
+
+  test("missing assistant ID returns error", async () => {
+    setPlatformAssistantId("");
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "register",
+      "mybot",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Assistant ID");
+  });
+
+  test("platform 5xx returns error", async () => {
+    mockFetch(
+      "/email-addresses/",
+      { method: "POST" },
+      { body: { detail: "Internal server error" }, status: 500 },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "register",
+      "mybot",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Internal server error");
+  });
+
+  test("username validation error from platform is surfaced", async () => {
+    mockFetch(
+      "/email-addresses/",
+      { method: "POST" },
+      { body: { username: ["Enter a valid value."] }, status: 400 },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "register",
+      "invalid username!",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("valid value");
+  });
+});

package/src/cli/commands/__tests__/email-send.test.ts

@@ -0,0 +1,291 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getMockFetchCalls,
+  mockFetch,
+  resetMockFetch,
+} from "../../../__tests__/mock-fetch.js";
+import { _setOverridesForTesting } from "../../../config/assistant-feature-flags.js";
+import { setPlatformAssistantId } from "../../../config/env.js";
+import { credentialKey } from "../../../security/credential-key.js";
+import {
+  _resetBackend,
+  setSecureKeyAsync,
+} from "../../../security/secure-keys.js";
+import { runAssistantCommand } from "../../__tests__/run-assistant-command.js";
+
+const ASSISTANT_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+const ADDRESS_ID = "550e8400-e29b-41d4-a716-446655440000";
+const ADDRESS = "mybot@vellum.me";
+const API_KEY_CREDENTIAL = credentialKey("vellum", "assistant_api_key");
+
+function mockListAddresses(
+  addresses: { id: string; address: string }[] = [
+    { id: ADDRESS_ID, address: ADDRESS },
+  ],
+  status = 200,
+): void {
+  mockFetch("/email-addresses/", {}, { body: { results: addresses }, status });
+}
+
+function mockSendSuccess(deliveryId = "del_abc123", status = 202): void {
+  mockFetch(
+    "/runtime-proxy/email/send/",
+    { method: "POST" },
+    { body: { delivery_id: deliveryId, status: "accepted" }, status },
+  );
+}
+
+beforeEach(async () => {
+  process.exitCode = 0;
+  _resetBackend();
+  resetMockFetch();
+  _setOverridesForTesting({ "email-channel": true });
+  setPlatformAssistantId(ASSISTANT_ID);
+  await setSecureKeyAsync(API_KEY_CREDENTIAL, "test-api-key");
+});
+
+afterEach(() => {
+  resetMockFetch();
+  _setOverridesForTesting({});
+  setPlatformAssistantId(undefined);
+  _resetBackend();
+});
+
+describe("assistant email send", () => {
+  test("successful send with --body and --subject", async () => {
+    mockListAddresses();
+    mockSendSuccess();
+
+    await runAssistantCommand(
+      "email",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Hi there",
+    );
+
+    const calls = getMockFetchCalls();
+    expect(calls).toHaveLength(2);
+
+    // First call: list addresses to resolve "from"
+    expect(calls[0].path).toBe(
+      `/v1/assistants/${ASSISTANT_ID}/email-addresses/`,
+    );
+
+    // Second call: send via runtime proxy
+    expect(calls[1].path).toBe("/v1/runtime-proxy/email/send/");
+    expect(calls[1].init.method).toBe("POST");
+
+    const payload = JSON.parse(calls[1].init.body as string);
+    expect(payload.to).toBe("user@example.com");
+    expect(payload.from_address).toBe(ADDRESS);
+    expect(payload.subject).toBe("Hello");
+    expect(payload.text).toBe("Hi there");
+
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("--json outputs structured response", async () => {
+    mockListAddresses();
+    mockSendSuccess("del_xyz789");
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Test",
+      "-b",
+      "Body",
+    );
+
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.delivery_id).toBe("del_xyz789");
+    expect(parsed.status).toBe("accepted");
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("no registered address returns error", async () => {
+    mockListAddresses([]);
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Body",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("No email address registered");
+  });
+
+  test("missing body returns error", async () => {
+    // Force isTTY to true so stdin fallback is skipped
+    const origIsTTY = process.stdin.isTTY;
+    process.stdin.isTTY = true as unknown as boolean;
+
+    mockListAddresses();
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+    );
+
+    process.stdin.isTTY = origIsTTY;
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Email body is required");
+  });
+
+  test("send endpoint failure surfaces error detail", async () => {
+    mockListAddresses();
+    mockFetch(
+      "/runtime-proxy/email/send/",
+      { method: "POST" },
+      {
+        body: { detail: "From address not owned by this assistant." },
+        status: 403,
+      },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Body",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("not owned by this assistant");
+  });
+
+  test("list addresses failure returns error", async () => {
+    mockFetch(
+      "/email-addresses/",
+      {},
+      { body: { detail: "Internal server error" }, status: 500 },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Body",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Failed to list email addresses");
+  });
+
+  test("missing platform credentials returns error", async () => {
+    _resetBackend();
+    setPlatformAssistantId(undefined);
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Body",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Platform credentials not configured");
+  });
+
+  test("missing assistant ID returns error", async () => {
+    setPlatformAssistantId("");
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Body",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Assistant ID");
+  });
+
+  test("send without subject omits subject from payload", async () => {
+    mockListAddresses();
+    mockSendSuccess();
+
+    await runAssistantCommand(
+      "email",
+      "send",
+      "user@example.com",
+      "-b",
+      "Body only, no subject",
+    );
+
+    const calls = getMockFetchCalls();
+    const payload = JSON.parse(calls[1].init.body as string);
+    expect(payload.subject).toBeUndefined();
+    expect(payload.text).toBe("Body only, no subject");
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("suppressed recipient error is surfaced", async () => {
+    mockListAddresses();
+    mockFetch(
+      "/runtime-proxy/email/send/",
+      { method: "POST" },
+      {
+        body: {
+          detail:
+            "Recipient user@example.com is suppressed due to prior bounce or spam complaint.",
+        },
+        status: 422,
+      },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Body",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("suppressed");
+  });
+});

package/src/cli/commands/__tests__/email-status.test.ts

@@ -0,0 +1,181 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getMockFetchCalls,
+  mockFetch,
+  resetMockFetch,
+} from "../../../__tests__/mock-fetch.js";
+import { _setOverridesForTesting } from "../../../config/assistant-feature-flags.js";
+import { setPlatformAssistantId } from "../../../config/env.js";
+import { credentialKey } from "../../../security/credential-key.js";
+import {
+  _resetBackend,
+  deleteSecureKeyAsync,
+  setSecureKeyAsync,
+} from "../../../security/secure-keys.js";
+import { runAssistantCommand } from "../../__tests__/run-assistant-command.js";
+
+const ASSISTANT_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+const ADDRESS_ID = "550e8400-e29b-41d4-a716-446655440000";
+const ADDRESS = "mybot@vellum.me";
+const API_KEY_CREDENTIAL = credentialKey("vellum", "assistant_api_key");
+
+function mockListAddresses(
+  addresses: { id: string; address: string }[] = [
+    { id: ADDRESS_ID, address: ADDRESS },
+  ],
+  status = 200,
+): void {
+  mockFetch("/email-addresses/", {}, { body: { results: addresses }, status });
+}
+
+function mockStatusSuccess(
+  overrides?: Partial<{
+    address: string;
+    status: string;
+    usage: { sent_today: number; daily_limit: number; received_today: number };
+  }>,
+): void {
+  mockFetch(
+    `/email-addresses/${ADDRESS_ID}/status/`,
+    {},
+    {
+      body: {
+        address: overrides?.address ?? ADDRESS,
+        status: overrides?.status ?? "active",
+        usage: overrides?.usage ?? {
+          sent_today: 12,
+          daily_limit: 100,
+          received_today: 5,
+        },
+      },
+      status: 200,
+    },
+  );
+}
+
+let savedCesUrl: string | undefined;
+let savedContainerized: string | undefined;
+
+beforeEach(async () => {
+  process.exitCode = 0;
+
+  // Force encrypted-store backend so setSecureKeyAsync works in sandbox
+  savedCesUrl = process.env.CES_CREDENTIAL_URL;
+  savedContainerized = process.env.IS_CONTAINERIZED;
+  delete process.env.CES_CREDENTIAL_URL;
+  delete process.env.IS_CONTAINERIZED;
+
+  _resetBackend();
+  resetMockFetch();
+  _setOverridesForTesting({ "email-channel": true });
+  setPlatformAssistantId(ASSISTANT_ID);
+  await setSecureKeyAsync(API_KEY_CREDENTIAL, "test-api-key");
+});
+
+afterEach(() => {
+  resetMockFetch();
+  _setOverridesForTesting({});
+  setPlatformAssistantId(undefined);
+  _resetBackend();
+
+  // Restore env
+  if (savedCesUrl !== undefined) process.env.CES_CREDENTIAL_URL = savedCesUrl;
+  else delete process.env.CES_CREDENTIAL_URL;
+  if (savedContainerized !== undefined)
+    process.env.IS_CONTAINERIZED = savedContainerized;
+  else delete process.env.IS_CONTAINERIZED;
+});
+
+describe("assistant email status", () => {
+  test("successful status shows address and usage", async () => {
+    mockListAddresses();
+    mockStatusSuccess();
+
+    const output = await runAssistantCommand("email", "--json", "status");
+
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.address).toBe(ADDRESS);
+    expect(parsed.status).toBe("active");
+    expect(parsed.usage.sent_today).toBe(12);
+    expect(parsed.usage.daily_limit).toBe(100);
+    expect(parsed.usage.received_today).toBe(5);
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("calls correct URLs in order", async () => {
+    mockListAddresses();
+    mockStatusSuccess();
+
+    await runAssistantCommand("email", "--json", "status");
+
+    const calls = getMockFetchCalls();
+    expect(calls).toHaveLength(2);
+    expect(calls[0].path).toContain(
+      `/v1/assistants/${ASSISTANT_ID}/email-addresses/`,
+    );
+    expect(calls[1].path).toContain(
+      `/v1/assistants/${ASSISTANT_ID}/email-addresses/${ADDRESS_ID}/status/`,
+    );
+  });
+
+  test("no registered address returns error", async () => {
+    mockListAddresses([]);
+
+    const output = await runAssistantCommand("email", "--json", "status");
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("No email address registered");
+  });
+
+  test("list endpoint failure returns error", async () => {
+    mockFetch(
+      "/email-addresses/",
+      {},
+      { body: { detail: "Internal server error" }, status: 500 },
+    );
+
+    const output = await runAssistantCommand("email", "--json", "status");
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Failed to list email addresses");
+  });
+
+  test("status endpoint failure returns error", async () => {
+    mockListAddresses();
+    mockFetch(
+      `/email-addresses/${ADDRESS_ID}/status/`,
+      {},
+      { body: { detail: "Service unavailable" }, status: 503 },
+    );
+
+    const output = await runAssistantCommand("email", "--json", "status");
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Service unavailable");
+  });
+
+  test("missing platform credentials returns error", async () => {
+    // Delete the API key so create() returns null
+    await deleteSecureKeyAsync(API_KEY_CREDENTIAL);
+
+    const output = await runAssistantCommand("email", "--json", "status");
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Platform credentials not configured");
+  });
+
+  test("missing assistant ID returns error", async () => {
+    setPlatformAssistantId("");
+
+    const output = await runAssistantCommand("email", "--json", "status");
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Assistant ID");
+  });
+});