@vellumai/assistant 0.6.2 → 0.6.4

package/src/email/guardrails.ts

@@ -1,221 +0,0 @@
-/**
- * Local guardrails state for email operations.
- * Stores state in ~/.vellum/email-guardrails.json.
- */
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { minimatch } from "minimatch";
-
-import { getWorkspaceDir } from "../util/platform.js";
-
-export interface AddressRule {
-  id: string;
-  type: "block" | "allow";
-  pattern: string;
-  createdAt: string;
-}
-
-interface DailyCount {
-  [date: string]: number;
-}
-
-interface GuardrailsState {
-  paused: boolean;
-  dailyCap: number;
-  dailyCounts: DailyCount;
-  addressRules: AddressRule[];
-}
-
-const DEFAULT_STATE: GuardrailsState = {
-  paused: false,
-  dailyCap: 25,
-  dailyCounts: {},
-  addressRules: [],
-};
-
-function getGuardrailsPath(): string {
-  return join(getWorkspaceDir(), "email-guardrails.json");
-}
-
-function loadState(): GuardrailsState {
-  const path = getGuardrailsPath();
-  if (!existsSync(path))
-    return { ...DEFAULT_STATE, dailyCounts: {}, addressRules: [] };
-  try {
-    const raw = readFileSync(path, "utf-8");
-    const parsed = JSON.parse(raw) as Partial<GuardrailsState>;
-    return {
-      paused: parsed.paused ?? DEFAULT_STATE.paused,
-      dailyCap: parsed.dailyCap ?? DEFAULT_STATE.dailyCap,
-      dailyCounts: parsed.dailyCounts ?? {},
-      addressRules: parsed.addressRules ?? [],
-    };
-  } catch {
-    return { ...DEFAULT_STATE, dailyCounts: {}, addressRules: [] };
-  }
-}
-
-function saveState(state: GuardrailsState): void {
-  const path = getGuardrailsPath();
-  const dir = getWorkspaceDir();
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(path, JSON.stringify(state, null, 2));
-}
-
-function todayKey(): string {
-  return new Date().toISOString().slice(0, 10);
-}
-
-export function getDailySendCount(): number {
-  const state = loadState();
-  return state.dailyCounts[todayKey()] ?? 0;
-}
-
-export function incrementDailySendCount(): number {
-  const state = loadState();
-  const key = todayKey();
-  const newCount = (state.dailyCounts[key] ?? 0) + 1;
-  state.dailyCounts[key] = newCount;
-  saveState(state);
-  return newCount;
-}
-
-export function isOutboundPaused(): boolean {
-  return loadState().paused;
-}
-
-export function setOutboundPaused(paused: boolean): void {
-  const state = loadState();
-  state.paused = paused;
-  saveState(state);
-}
-
-export function getDailySendCap(): number {
-  return loadState().dailyCap;
-}
-
-export function setDailySendCap(cap: number): void {
-  const state = loadState();
-  state.dailyCap = cap;
-  saveState(state);
-}
-
-function isAddressAllowed(email: string): {
-  allowed: boolean;
-  reason?: string;
-  rule?: AddressRule;
-} {
-  const state = loadState();
-  const normalized = email.toLowerCase().trim();
-
-  // Check block rules first
-  for (const rule of state.addressRules) {
-    if (
-      rule.type === "block" &&
-      minimatch(normalized, rule.pattern, { nocase: true })
-    ) {
-      return {
-        allowed: false,
-        reason: `blocked by rule: ${rule.pattern}`,
-        rule,
-      };
-    }
-  }
-
-  // If there are allow rules, address must match at least one
-  const allowRules = state.addressRules.filter((r) => r.type === "allow");
-  if (allowRules.length > 0) {
-    const matched = allowRules.some((r) =>
-      minimatch(normalized, r.pattern, { nocase: true }),
-    );
-    if (!matched) {
-      return { allowed: false, reason: "not in allowlist" };
-    }
-  }
-
-  return { allowed: true };
-}
-
-export function addAddressRule(
-  type: "block" | "allow",
-  pattern: string,
-): AddressRule {
-  const state = loadState();
-  const rule: AddressRule = {
-    id: crypto.randomUUID(),
-    type,
-    pattern: pattern.toLowerCase(),
-    createdAt: new Date().toISOString(),
-  };
-  state.addressRules.push(rule);
-  saveState(state);
-  return rule;
-}
-
-export function removeAddressRule(ruleId: string): boolean {
-  const state = loadState();
-  const idx = state.addressRules.findIndex(
-    (r) => r.id === ruleId || r.id.startsWith(ruleId),
-  );
-  if (idx === -1) return false;
-  state.addressRules.splice(idx, 1);
-  saveState(state);
-  return true;
-}
-
-export function listRules(): AddressRule[] {
-  return loadState().addressRules;
-}
-
-export function getGuardrailsStatus(): {
-  paused: boolean;
-  dailyCap: number;
-  dailyCount: number;
-  rules: AddressRule[];
-} {
-  const state = loadState();
-  return {
-    paused: state.paused,
-    dailyCap: state.dailyCap,
-    dailyCount: state.dailyCounts[todayKey()] ?? 0,
-    rules: state.addressRules,
-  };
-}
-
-/**
- * Check all guardrails before sending. Returns null if all clear,
- * or an error object describing what blocked the send.
- */
-export function checkSendGuardrails(recipients: string[]): {
-  error: string;
-  address?: string;
-  reason?: string;
-  count?: number;
-  cap?: number;
-} | null {
-  if (isOutboundPaused()) {
-    return { error: "outbound_paused" };
-  }
-
-  const count = getDailySendCount();
-  const cap = getDailySendCap();
-  if (count >= cap) {
-    return { error: "daily_cap_reached", count, cap };
-  }
-
-  for (const addr of recipients) {
-    const check = isAddressAllowed(addr);
-    if (!check.allowed) {
-      return { error: "address_blocked", address: addr, reason: check.reason };
-    }
-  }
-
-  return null;
-}
-
-/** @internal Test-only: reset state file path override. */
-export { getGuardrailsPath as _getGuardrailsPath };

package/src/email/provider.ts

@@ -1,117 +0,0 @@
-/**
- * Email provider interface — the contract every adapter must implement.
- *
- * Providers are pure transport/integration logic.
- * Guardrails and business rules live in the service layer.
- */
-
-import type {
-  DnsRecord,
-  EmailDomain,
-  EmailDraft,
-  EmailInbox,
-  EmailMessage,
-  EmailThread,
-  EmailWebhook,
-  ProviderHealth,
-  SendResult,
-} from "./types.js";
-
-// ---------------------------------------------------------------------------
-// Setup operations
-// ---------------------------------------------------------------------------
-
-export interface SetupDomainOpts {
-  domain: string;
-  dryRun?: boolean;
-}
-
-export interface EnsureInboxesOpts {
-  domain: string;
-  prefixes?: string[];
-}
-
-export interface CreateInboxOpts {
-  /** Username/local part (e.g. "sam"). */
-  username: string;
-  /** Domain (e.g. "agentmail.to"). If omitted, provider uses its default. */
-  domain?: string;
-  /** Display name (e.g. "Samwise"). */
-  displayName?: string;
-}
-
-export interface SetupWebhookOpts {
-  url: string;
-  secret?: string;
-  events?: string[];
-}
-
-// ---------------------------------------------------------------------------
-// Draft operations
-// ---------------------------------------------------------------------------
-
-export interface CreateDraftOpts {
-  inboxId: string;
-  to: string[];
-  subject: string;
-  body: string;
-  cc?: string[];
-  inReplyTo?: string;
-}
-
-export interface ListDraftsOpts {
-  inboxId?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Message / thread operations
-// ---------------------------------------------------------------------------
-
-export interface ListMessagesOpts {
-  inboxId?: string;
-  threadId?: string;
-}
-
-export interface ListThreadsOpts {
-  inboxId?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Provider interface
-// ---------------------------------------------------------------------------
-
-export interface EmailProvider {
-  /** Unique provider identifier (e.g. 'agentmail'). */
-  readonly name: string;
-
-  // --- Health ---
-  health(): Promise<ProviderHealth>;
-
-  // --- Domain setup ---
-  setupDomain(opts: SetupDomainOpts): Promise<EmailDomain>;
-  getDomainDnsRecords(domain: string): Promise<DnsRecord[]>;
-  verifyDomain(domain: string): Promise<EmailDomain>;
-
-  // --- Inbox setup ---
-  createInbox(opts: CreateInboxOpts): Promise<EmailInbox>;
-  listInboxes(): Promise<EmailInbox[]>;
-  ensureInboxes(opts: EnsureInboxesOpts): Promise<EmailInbox[]>;
-
-  // --- Webhook setup ---
-  setupWebhook(opts: SetupWebhookOpts): Promise<EmailWebhook>;
-
-  // --- Draft lifecycle ---
-  createDraft(opts: CreateDraftOpts): Promise<EmailDraft>;
-  listDrafts(opts?: ListDraftsOpts): Promise<EmailDraft[]>;
-  getDraft(draftId: string, inboxId?: string): Promise<EmailDraft>;
-  deleteDraft(draftId: string, inboxId?: string): Promise<void>;
-  sendDraft(draftId: string, inboxId?: string): Promise<SendResult>;
-
-  // --- Messages ---
-  listMessages(opts?: ListMessagesOpts): Promise<EmailMessage[]>;
-  getMessage(messageId: string, inboxId?: string): Promise<EmailMessage>;
-
-  // --- Threads ---
-  listThreads(opts?: ListThreadsOpts): Promise<EmailThread[]>;
-  getThread(threadId: string): Promise<EmailThread>;
-}

package/src/email/providers/agentmail.ts

@@ -1,361 +0,0 @@
-/**
- * AgentMail adapter — implements EmailProvider using the agentmail SDK.
- *
- * This is pure transport/integration logic. No guardrails here.
- */
-
-import type { AgentMailClient } from "agentmail";
-
-import { ConfigError } from "../../util/errors.js";
-import type {
-  CreateDraftOpts,
-  CreateInboxOpts,
-  EmailProvider,
-  EnsureInboxesOpts,
-  ListDraftsOpts,
-  ListMessagesOpts,
-  ListThreadsOpts,
-  SetupDomainOpts,
-  SetupWebhookOpts,
-} from "../provider.js";
-import type {
-  DnsRecord,
-  EmailDomain,
-  EmailDraft,
-  EmailInbox,
-  EmailMessage,
-  EmailThread,
-  EmailWebhook,
-  ProviderHealth,
-  SendResult,
-} from "../types.js";
-
-const DEFAULT_INBOX_PREFIXES = ["hello", "support", "ops"];
-
-export class AgentMailProvider implements EmailProvider {
-  readonly name = "agentmail";
-  private client: AgentMailClient;
-
-  constructor(client: AgentMailClient) {
-    this.client = client;
-  }
-
-  // -------------------------------------------------------------------------
-  // Health
-  // -------------------------------------------------------------------------
-
-  async health(): Promise<ProviderHealth> {
-    const response = await this.client.inboxes.list();
-    const inboxes = response.inboxes.map(mapInbox);
-    return { provider: this.name, ok: true, inboxes };
-  }
-
-  // -------------------------------------------------------------------------
-  // Domain setup
-  // -------------------------------------------------------------------------
-
-  async setupDomain(opts: SetupDomainOpts): Promise<EmailDomain> {
-    if (opts.dryRun) {
-      return {
-        id: `dry-run:${opts.domain}`,
-        domain: opts.domain,
-        verified: false,
-        createdAt: new Date().toISOString(),
-      };
-    }
-    const result = await this.client.domains.create({
-      domain: opts.domain,
-      feedbackEnabled: false,
-    });
-    return mapDomain(result);
-  }
-
-  async getDomainDnsRecords(domain: string): Promise<DnsRecord[]> {
-    const domainObj = await this.client.domains.get(domain);
-    return (domainObj.records ?? []).map(
-      (r): DnsRecord => ({
-        type: r.type,
-        name: r.name,
-        value: r.value,
-        priority: r.priority,
-      }),
-    );
-  }
-
-  async verifyDomain(domain: string): Promise<EmailDomain> {
-    await this.client.domains.verify(domain);
-    const result = await this.client.domains.get(domain);
-    return mapDomain(result);
-  }
-
-  // -------------------------------------------------------------------------
-  // Inbox management
-  // -------------------------------------------------------------------------
-
-  async createInbox(opts: CreateInboxOpts): Promise<EmailInbox> {
-    const params: Record<string, unknown> = { username: opts.username };
-    if (opts.domain) params.domain = opts.domain;
-    if (opts.displayName) params.displayName = opts.displayName;
-    const inbox = await this.client.inboxes.create(
-      params as Parameters<typeof this.client.inboxes.create>[0],
-    );
-    return mapInbox(inbox);
-  }
-
-  async listInboxes(): Promise<EmailInbox[]> {
-    const response = await this.client.inboxes.list();
-    return response.inboxes.map(mapInbox);
-  }
-
-  async ensureInboxes(opts: EnsureInboxesOpts): Promise<EmailInbox[]> {
-    const prefixes = opts.prefixes ?? DEFAULT_INBOX_PREFIXES;
-    const results: EmailInbox[] = [];
-    for (const prefix of prefixes) {
-      const inbox = await this.client.inboxes.create({
-        username: prefix,
-        domain: opts.domain,
-        displayName: `${prefix.charAt(0).toUpperCase() + prefix.slice(1)} (${
-          opts.domain
-        })`,
-      });
-      results.push(mapInbox(inbox));
-    }
-    return results;
-  }
-
-  // -------------------------------------------------------------------------
-  // Webhook setup
-  // -------------------------------------------------------------------------
-
-  async setupWebhook(opts: SetupWebhookOpts): Promise<EmailWebhook> {
-    const result = await this.client.webhooks.create({
-      url: opts.url,
-      eventTypes:
-        (opts.events as import("agentmail").AgentMail.EventType[]) ?? [
-          "message.received",
-        ],
-    });
-    return {
-      id: result.webhookId,
-      url: result.url,
-      secret: result.secret,
-      events: result.eventTypes ?? [],
-      createdAt: result.createdAt.toISOString(),
-    };
-  }
-
-  // -------------------------------------------------------------------------
-  // Draft lifecycle
-  // -------------------------------------------------------------------------
-
-  async createDraft(opts: CreateDraftOpts): Promise<EmailDraft> {
-    const params: Record<string, unknown> = {
-      to: opts.to,
-      subject: opts.subject,
-      text: opts.body,
-    };
-    if (opts.cc) params.cc = opts.cc;
-    if (opts.inReplyTo) params.inReplyTo = opts.inReplyTo;
-
-    const result = await this.client.inboxes.drafts.create(
-      opts.inboxId,
-      params,
-    );
-    return mapDraft(result);
-  }
-
-  async listDrafts(opts?: ListDraftsOpts): Promise<EmailDraft[]> {
-    const inboxId = opts?.inboxId ?? (await this.resolveDefaultInbox());
-    const result = await this.client.inboxes.drafts.list(inboxId);
-    return result.drafts.map(mapDraftItem);
-  }
-
-  async getDraft(draftId: string, inboxId?: string): Promise<EmailDraft> {
-    const inbox = inboxId ?? (await this.resolveDefaultInbox());
-    const result = await this.client.inboxes.drafts.get(inbox, draftId);
-    return mapDraft(result);
-  }
-
-  async deleteDraft(draftId: string, inboxId?: string): Promise<void> {
-    const inbox = inboxId ?? (await this.resolveDefaultInbox());
-    await this.client.inboxes.drafts.delete(inbox, draftId);
-  }
-
-  async sendDraft(draftId: string, inboxId?: string): Promise<SendResult> {
-    const inbox = inboxId ?? (await this.resolveDefaultInbox());
-    const result = await this.client.inboxes.drafts.send(inbox, draftId, {});
-    return {
-      messageId: result.messageId,
-      threadId: result.threadId,
-    };
-  }
-
-  // -------------------------------------------------------------------------
-  // Messages
-  // -------------------------------------------------------------------------
-
-  async listMessages(opts?: ListMessagesOpts): Promise<EmailMessage[]> {
-    const inboxId = opts?.inboxId ?? (await this.resolveDefaultInbox());
-    const result = await this.client.inboxes.messages.list(inboxId);
-    let messages = result.messages.map(mapMessageItem);
-    // The SDK doesn't support thread filtering natively — filter client-side
-    if (opts?.threadId) {
-      messages = messages.filter((m) => m.threadId === opts.threadId);
-    }
-    return messages;
-  }
-
-  async getMessage(messageId: string, inboxId?: string): Promise<EmailMessage> {
-    const inbox = inboxId ?? (await this.resolveDefaultInbox());
-    const result = await this.client.inboxes.messages.get(inbox, messageId);
-    return mapMessage(result);
-  }
-
-  // -------------------------------------------------------------------------
-  // Threads
-  // -------------------------------------------------------------------------
-
-  async listThreads(opts?: ListThreadsOpts): Promise<EmailThread[]> {
-    const inboxId = opts?.inboxId ?? (await this.resolveDefaultInbox());
-    const result = await this.client.inboxes.threads.list(inboxId);
-    return result.threads.map(mapThreadItem);
-  }
-
-  async getThread(threadId: string): Promise<EmailThread> {
-    const result = await this.client.threads.get(threadId);
-    return mapThreadFull(result);
-  }
-
-  // -------------------------------------------------------------------------
-  // Internal
-  // -------------------------------------------------------------------------
-
-  private async resolveDefaultInbox(): Promise<string> {
-    const inboxes = await this.client.inboxes.list();
-    if (inboxes.inboxes.length > 0) {
-      return inboxes.inboxes[0].inboxId;
-    }
-    throw new ConfigError(
-      "No inboxes found. Run: assistant email setup inboxes --domain <domain>",
-    );
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Mappers: AgentMail SDK types → canonical types
-// ---------------------------------------------------------------------------
-
-function mapDomain(d: import("agentmail").AgentMail.Domain): EmailDomain {
-  return {
-    id: d.domainId,
-    domain: d.domainId,
-    verified: d.status === "VERIFIED",
-    createdAt: d.createdAt.toISOString(),
-  };
-}
-
-function mapInbox(i: import("agentmail").AgentMail.inboxes.Inbox): EmailInbox {
-  return {
-    id: i.inboxId,
-    address: i.inboxId,
-    displayName: i.displayName,
-    createdAt: i.createdAt.toISOString(),
-  };
-}
-
-function mapDraft(d: import("agentmail").AgentMail.Draft): EmailDraft {
-  return {
-    id: d.draftId,
-    inboxId: d.inboxId,
-    to: d.to ?? [],
-    cc: d.cc,
-    bcc: d.bcc,
-    subject: d.subject ?? "",
-    body: d.text ?? "",
-    html: d.html,
-    inReplyTo: d.inReplyTo,
-    threadId: d.threadId,
-    status: mapSendStatus(d.sendStatus),
-    createdAt: d.createdAt.toISOString(),
-  };
-}
-
-function mapDraftItem(d: import("agentmail").AgentMail.DraftItem): EmailDraft {
-  return {
-    id: d.draftId,
-    inboxId: d.inboxId,
-    to: d.to ?? [],
-    cc: d.cc,
-    bcc: d.bcc,
-    subject: d.subject ?? "",
-    body: "",
-    threadId: d.threadId,
-    status: mapSendStatus(d.sendStatus),
-    createdAt: d.updatedAt.toISOString(),
-  };
-}
-
-function mapSendStatus(status?: string): EmailDraft["status"] {
-  switch (status) {
-    case "sent":
-      return "sent";
-    case "sending":
-      return "approved";
-    case "failed":
-      return "rejected";
-    default:
-      return "pending";
-  }
-}
-
-function mapMessageItem(
-  m: import("agentmail").AgentMail.MessageItem,
-): EmailMessage {
-  return {
-    id: m.messageId,
-    threadId: m.threadId,
-    inboxId: m.inboxId,
-    from: m.from,
-    to: m.to,
-    cc: m.cc,
-    subject: m.subject,
-    receivedAt: m.createdAt.toISOString(),
-  };
-}
-
-function mapMessage(m: import("agentmail").AgentMail.Message): EmailMessage {
-  return {
-    id: m.messageId,
-    threadId: m.threadId,
-    inboxId: m.inboxId,
-    from: m.from,
-    to: m.to,
-    cc: m.cc,
-    subject: m.subject,
-    body: m.text,
-    html: m.html,
-    receivedAt: m.createdAt.toISOString(),
-  };
-}
-
-function mapThreadItem(
-  t: import("agentmail").AgentMail.ThreadItem,
-): EmailThread {
-  return {
-    id: t.threadId,
-    subject: t.subject,
-    participants: [...(t.senders ?? []), ...(t.recipients ?? [])],
-    messageCount: t.messageCount,
-    lastMessageAt: t.timestamp.toISOString(),
-  };
-}
-
-function mapThreadFull(t: import("agentmail").AgentMail.Thread): EmailThread {
-  return {
-    id: t.threadId,
-    subject: t.subject,
-    participants: [...(t.senders ?? []), ...(t.recipients ?? [])],
-    messageCount: t.messageCount,
-    lastMessageAt: t.timestamp.toISOString(),
-  };
-}