@haiai/haiai 0.1.2

package/tests/email-conformance.test.ts

@@ -0,0 +1,289 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { HaiClient } from '../src/client.js';
+import { generateTestKeypair as generateKeypair } from './setup.js';
+import {
+  EmailNotActiveError,
+  RecipientNotFoundError,
+  RateLimitedError,
+} from '../src/errors.js';
+import type {
+  EmailVerificationResultV2,
+  FieldStatus,
+} from '../src/types.js';
+
+// ---------------------------------------------------------------------------
+// Fixture loading
+// ---------------------------------------------------------------------------
+
+interface ConformanceFixture {
+  verification_result_v2_schema: {
+    required_fields: Record<string, string>;
+    field_status_values: string[];
+  };
+  api_contracts: {
+    sign_email: { method: string; path: string; request_content_type: string };
+    verify_email: { method: string; path: string; request_content_type: string };
+    send_email: { excluded_fields: string[] };
+  };
+  mock_verify_response: { json: Record<string, unknown> };
+}
+
+function loadConformanceFixture(): ConformanceFixture {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const fixturePath = resolve(here, '../../fixtures/email_conformance.json');
+  return JSON.parse(readFileSync(fixturePath, 'utf-8')) as ConformanceFixture;
+}
+
+async function makeClient(baseUrl: string): Promise<HaiClient> {
+  const keypair = generateKeypair();
+  const client = await HaiClient.fromCredentials('test-agent-001', keypair.privateKeyPem, { url: baseUrl, privateKeyPassphrase: 'keygen-password' });
+  client.agentEmail = 'test@hai.ai';
+  return client;
+}
+
+// ---------------------------------------------------------------------------
+// EmailVerificationResultV2 structural conformance
+// ---------------------------------------------------------------------------
+
+describe('email conformance: mock verify response deserialization', () => {
+  const fixture = loadConformanceFixture();
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('deserializes mock response into EmailVerificationResultV2 via verifyEmail', async () => {
+    const mockJson = fixture.mock_verify_response.json;
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockJson),
+    }));
+
+    const client = await makeClient('https://mock.hai.ai');
+    const result: EmailVerificationResultV2 = await client.verifyEmail('raw email content');
+
+    expect(result.valid).toBe(true);
+    expect(result.jacsId).toBe('conformance-test-agent-001');
+    expect(result.algorithm).toBe('ed25519');
+    expect(result.reputationTier).toBe('established');
+    expect(result.dnsVerified).toBe(true);
+    expect(result.error).toBeNull();
+
+    // field_results
+    expect(result.fieldResults).toHaveLength(4);
+    expect(result.fieldResults[0].field).toBe('subject');
+    expect(result.fieldResults[0].status).toBe('pass');
+    expect(result.fieldResults[3].field).toBe('date');
+    expect(result.fieldResults[3].status).toBe('modified');
+
+    // chain
+    expect(result.chain).toHaveLength(1);
+    expect(result.chain[0].signer).toBe('agent@hai.ai');
+    expect(result.chain[0].jacsId).toBe('conformance-test-agent-001');
+    expect(result.chain[0].valid).toBe(true);
+    expect(result.chain[0].forwarded).toBe(false);
+
+    // agent_status and benchmarks_completed (TASK_012)
+    expect(result.agentStatus).toBe('active');
+    expect(result.benchmarksCompleted).toEqual(['free_chaotic']);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Content hash golden vector conformance (TASK_013)
+// ---------------------------------------------------------------------------
+
+describe('email conformance: content hash golden vectors', () => {
+  it('all golden vectors produce the expected content hash', async () => {
+    const { computeContentHash } = await import('../src/hash.js');
+    const fixture = loadConformanceFixture() as ConformanceFixture & {
+      content_hash_golden: {
+        vectors: Array<{
+          name: string;
+          subject: string;
+          body: string;
+          attachments: Array<{ filename: string; content_type: string; data_utf8: string }>;
+          expected_hash: string;
+        }>;
+      };
+    };
+
+    for (const vector of fixture.content_hash_golden.vectors) {
+      const result = computeContentHash(vector.subject, vector.body, vector.attachments);
+      expect(result).toBe(vector.expected_hash);
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// MIME round-trip conformance (TASK_014)
+// ---------------------------------------------------------------------------
+
+describe('email conformance: MIME round-trip content hash', () => {
+  it('produces expected content hash from round-trip input', async () => {
+    const { computeContentHash } = await import('../src/hash.js');
+    const fixture = loadConformanceFixture() as ConformanceFixture & {
+      mime_round_trip: {
+        input: {
+          subject: string;
+          body: string;
+          attachments: Array<{ filename: string; content_type: string; data_utf8: string }>;
+        };
+        expected_content_hash: string;
+      };
+    };
+
+    const { input, expected_content_hash: expectedHash } = fixture.mime_round_trip;
+    const result = computeContentHash(input.subject, input.body, input.attachments);
+    expect(result).toBe(expectedHash);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// FieldStatus enum conformance
+// ---------------------------------------------------------------------------
+
+describe('email conformance: FieldStatus values', () => {
+  const fixture = loadConformanceFixture();
+
+  it('all fixture field_status_values are valid FieldStatus literals', () => {
+    const validStatuses: FieldStatus[] = ['pass', 'modified', 'fail', 'unverifiable'];
+    for (const val of fixture.verification_result_v2_schema.field_status_values) {
+      expect(validStatuses).toContain(val);
+    }
+    expect(fixture.verification_result_v2_schema.field_status_values).toHaveLength(validStatuses.length);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// API contract conformance: SignEmail
+// ---------------------------------------------------------------------------
+
+describe('email conformance: signEmail API contract', () => {
+  const fixture = loadConformanceFixture();
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('sends POST to correct path with message/rfc822 content-type', async () => {
+    let gotMethod = '';
+    let gotPath = '';
+    let gotContentType = '';
+
+    vi.stubGlobal('fetch', vi.fn().mockImplementation((url: string, init?: RequestInit) => {
+      const u = new URL(url);
+      gotMethod = init?.method ?? 'GET';
+      gotPath = u.pathname;
+      gotContentType = (init?.headers as Record<string, string>)?.['Content-Type'] ?? '';
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
+      });
+    }));
+
+    const client = await makeClient('https://mock.hai.ai');
+    await client.signEmail('raw email');
+
+    expect(gotMethod).toBe(fixture.api_contracts.sign_email.method);
+    expect(gotPath).toBe(fixture.api_contracts.sign_email.path);
+    expect(gotContentType).toBe(fixture.api_contracts.sign_email.request_content_type);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// API contract conformance: VerifyEmail
+// ---------------------------------------------------------------------------
+
+describe('email conformance: verifyEmail API contract', () => {
+  const fixture = loadConformanceFixture();
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('sends POST to correct path with message/rfc822 content-type', async () => {
+    let gotMethod = '';
+    let gotPath = '';
+    let gotContentType = '';
+
+    vi.stubGlobal('fetch', vi.fn().mockImplementation((url: string, init?: RequestInit) => {
+      const u = new URL(url);
+      gotMethod = init?.method ?? 'GET';
+      gotPath = u.pathname;
+      gotContentType = (init?.headers as Record<string, string>)?.['Content-Type'] ?? '';
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve(fixture.mock_verify_response.json),
+      });
+    }));
+
+    const client = await makeClient('https://mock.hai.ai');
+    await client.verifyEmail('raw email');
+
+    expect(gotMethod).toBe(fixture.api_contracts.verify_email.method);
+    expect(gotPath).toBe(fixture.api_contracts.verify_email.path);
+    expect(gotContentType).toBe(fixture.api_contracts.verify_email.request_content_type);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// API contract conformance: SendEmail excluded fields
+// ---------------------------------------------------------------------------
+
+describe('email conformance: sendEmail excluded fields', () => {
+  const fixture = loadConformanceFixture();
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('does not send client-side signing fields', async () => {
+    let gotBody: Record<string, unknown> = {};
+
+    vi.stubGlobal('fetch', vi.fn().mockImplementation((_url: string, init?: RequestInit) => {
+      if (init?.body) {
+        gotBody = JSON.parse(init.body as string) as Record<string, unknown>;
+      }
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ message_id: 'msg-conf', status: 'sent' }),
+      });
+    }));
+
+    const client = await makeClient('https://mock.hai.ai');
+    await client.sendEmail({ to: 'bob@hai.ai', subject: 'Test', body: 'Body' });
+
+    for (const excluded of fixture.api_contracts.send_email.excluded_fields) {
+      expect(gotBody).not.toHaveProperty(excluded);
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Error type conformance
+// ---------------------------------------------------------------------------
+
+describe('email conformance: error types', () => {
+  it('all email error sentinel classes exist', () => {
+    expect(EmailNotActiveError).toBeDefined();
+    expect(RecipientNotFoundError).toBeDefined();
+    expect(RateLimitedError).toBeDefined();
+
+    // Verify they are constructable
+    const e1 = new EmailNotActiveError('test');
+    const e2 = new RecipientNotFoundError('test');
+    const e3 = new RateLimitedError('test');
+    expect(e1.message).toBe('test');
+    expect(e2.message).toBe('test');
+    expect(e3.message).toBe('test');
+  });
+});

package/tests/email-integration.test.ts

@@ -0,0 +1,217 @@
+/**
+ * Live integration tests for HAI email CRUD operations.
+ *
+ * Gated behind HAI_LIVE_TEST=1. Requires a running HAI API at
+ * HAI_URL (defaults to http://localhost:3000) backed by Stalwart.
+ *
+ * Run:
+ *   HAI_LIVE_TEST=1 HAI_URL=http://localhost:3000 npx vitest run tests/email-integration.test.ts
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { HaiClient } from '../src/index.js';
+import { generateTestKeypair as generateKeypair } from './setup.js';
+import type { SendEmailResult, EmailMessage, EmailStatus } from '../src/types.js';
+
+const LIVE = process.env.HAI_LIVE_TEST === '1';
+const API_URL = process.env.HAI_URL || 'http://localhost:3000';
+
+/** Small helper to wait for async email delivery to settle. */
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe.skipIf(!LIVE)('Email integration (live API)', () => {
+  let client: HaiClient;
+  const agentName = `node-integ-${Date.now()}`;
+  let sentMessageId: string;
+  let replyMessageId: string;
+  const subject = `node-integ-test-${Date.now()}`;
+  const body = 'Hello from Node integration test!';
+
+  // -------------------------------------------------------------------------
+  // Setup: register agent + claim username to provision @hai.ai email
+  // -------------------------------------------------------------------------
+
+  beforeAll(async () => {
+    // 1. Generate fresh Ed25519 keypair.
+    const keypair = generateKeypair();
+
+    // 2. Build client from credentials (no jacs.config.json needed).
+    client = await HaiClient.fromCredentials(agentName, keypair.privateKeyPem, {
+      url: API_URL,
+      privateKeyPassphrase: 'keygen-password',
+    });
+
+    // 3. Register the agent with the local API (bootstrap registration).
+    const ownerEmail = process.env.HAI_OWNER_EMAIL || 'jonathan@hai.io';
+    const result = await client.register({
+      description: 'Node SDK email integration test agent',
+      ownerEmail,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.jacsId).toBeTruthy();
+    expect(result.agentId).toBeTruthy();
+    console.log(`Registered agent: jacsId=${result.jacsId}, agentId=${result.agentId}`);
+
+    // 4. Claim a username to provision the @hai.ai email address.
+    const claim = await client.claimUsername(client.haiAgentId, agentName);
+    expect(claim.email).toContain('@hai.ai');
+    console.log(`Claimed username: ${claim.username}, email=${claim.email}`);
+  }, 30_000);
+
+  // -------------------------------------------------------------------------
+  // 1. Send email -> assert message_id
+  // -------------------------------------------------------------------------
+
+  it('should send an email and return a message_id', async () => {
+    const result: SendEmailResult = await client.sendEmail({
+      to: `${agentName}@hai.ai`,
+      subject,
+      body,
+    });
+
+    sentMessageId = result.messageId;
+    expect(sentMessageId).toBeTruthy();
+    expect(typeof sentMessageId).toBe('string');
+    expect(result.status).toBeTruthy();
+    console.log(`Sent email: messageId=${sentMessageId}, status=${result.status}`);
+
+    // Allow time for async delivery before subsequent tests.
+    await sleep(2000);
+  }, 15_000);
+
+  // -------------------------------------------------------------------------
+  // 2. List messages -> assert sent message appears
+  // -------------------------------------------------------------------------
+
+  it('should list messages including the sent message', async () => {
+    const messages: EmailMessage[] = await client.listMessages({ limit: 50 });
+    expect(messages.length).toBeGreaterThan(0);
+
+    // The sent message should appear in the list (either as outbound or
+    // delivered back to self as inbound).
+    const found = messages.some(
+      (m) => m.id === sentMessageId || m.subject === subject,
+    );
+    expect(found).toBe(true);
+    console.log(`Listed ${messages.length} messages; sent message found=${found}`);
+  });
+
+  // -------------------------------------------------------------------------
+  // 3. Get message -> assert subject/body match
+  // -------------------------------------------------------------------------
+
+  it('should get the message by id with matching subject and body', async () => {
+    const msg: EmailMessage = await client.getMessage(sentMessageId);
+    expect(msg.id).toBe(sentMessageId);
+    expect(msg.subject).toBe(subject);
+    expect(msg.bodyText).toContain(body);
+    expect(msg.direction).toBeTruthy();
+    expect(msg.createdAt).toBeTruthy();
+    console.log(`Got message: id=${msg.id}, subject=${msg.subject}`);
+  });
+
+  // -------------------------------------------------------------------------
+  // 4. Mark read / unread -> no error
+  // -------------------------------------------------------------------------
+
+  it('should mark a message as read without error', async () => {
+    await client.markRead(sentMessageId);
+
+    // Verify the read state persisted.
+    const msg = await client.getMessage(sentMessageId);
+    expect(msg.isRead).toBe(true);
+    console.log('Marked read; isRead=' + msg.isRead);
+  });
+
+  it('should mark a message as unread without error', async () => {
+    await client.markUnread(sentMessageId);
+
+    // Verify the unread state persisted.
+    const msg = await client.getMessage(sentMessageId);
+    expect(msg.isRead).toBe(false);
+    console.log('Marked unread; isRead=' + msg.isRead);
+  });
+
+  // -------------------------------------------------------------------------
+  // 5. Search -> assert message found
+  // -------------------------------------------------------------------------
+
+  it('should search messages and find the sent message', async () => {
+    const results: EmailMessage[] = await client.searchMessages({ query: subject });
+    expect(results.length).toBeGreaterThan(0);
+
+    const found = results.some(
+      (m) => m.id === sentMessageId || m.subject === subject,
+    );
+    expect(found).toBe(true);
+    console.log(`Search found ${results.length} results; target found=${found}`);
+  });
+
+  // -------------------------------------------------------------------------
+  // 6. Unread count -> assert returns number
+  // -------------------------------------------------------------------------
+
+  it('should return unread count as a number', async () => {
+    const count: number = await client.getUnreadCount();
+    expect(typeof count).toBe('number');
+    expect(count).toBeGreaterThanOrEqual(0);
+    console.log(`Unread count: ${count}`);
+  });
+
+  // -------------------------------------------------------------------------
+  // 7. Email status -> assert returns status
+  // -------------------------------------------------------------------------
+
+  it('should return email status with expected fields', async () => {
+    const status: EmailStatus = await client.getEmailStatus();
+    expect(status.email).toBeTruthy();
+    expect(status.email).toContain('@hai.ai');
+    expect(status.status).toBeTruthy();
+    expect(typeof status.dailyLimit).toBe('number');
+    expect(typeof status.dailyUsed).toBe('number');
+    expect(typeof status.messagesSentTotal).toBe('number');
+    console.log(
+      `Email status: email=${status.email}, status=${status.status}, tier=${status.tier}`,
+    );
+  });
+
+  // -------------------------------------------------------------------------
+  // 8. Reply -> assert reply message_id
+  // -------------------------------------------------------------------------
+
+  it('should reply to the sent message and return a reply message_id', async () => {
+    // reply() expects the internal message ID (used in URL path), not the
+    // RFC Message-ID. It fetches the original message, derives the sender
+    // and subject, then calls sendEmail with inReplyTo threading.
+    const result: SendEmailResult = await client.reply(
+      sentMessageId,
+      'Reply from Node integration test!',
+    );
+
+    replyMessageId = result.messageId;
+    expect(replyMessageId).toBeTruthy();
+    expect(typeof replyMessageId).toBe('string');
+    expect(result.status).toBeTruthy();
+    console.log(`Reply sent: messageId=${replyMessageId}, status=${result.status}`);
+  }, 15_000);
+
+  // -------------------------------------------------------------------------
+  // 9. Delete -> assert no error
+  // -------------------------------------------------------------------------
+
+  it('should delete the sent message without error', async () => {
+    // deleteMessage resolves void on success; any throw means failure.
+    await client.deleteMessage(sentMessageId);
+    console.log(`Deleted message: ${sentMessageId}`);
+  });
+
+  // -------------------------------------------------------------------------
+  // 10. Get deleted -> assert error/404
+  // -------------------------------------------------------------------------
+
+  it('should throw when getting a deleted message', async () => {
+    await expect(client.getMessage(sentMessageId)).rejects.toThrow();
+    console.log('Confirmed deleted message returns error');
+  });
+});