@happyvertical/smrt-messages 0.30.0

package/dist/index.js

@@ -0,0 +1,3068 @@
+import { ObjectRegistry, field, smrt, SmrtObject, SmrtCollection, foreignKey } from "@happyvertical/smrt-core";
+import { tenantId, TenantScoped } from "@happyvertical/smrt-tenancy";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$b = Object.getOwnPropertyDescriptor;
+var __decorateClass$b = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$b(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$3(target, key, result);
+  return result;
+};
+let Account = class extends SmrtObject {
+  tenantId = null;
+  name = "";
+  providerType = "";
+  // credentialSecretId stores the Secret's NAME (keyed by name + tenant
+  // context in smrt-secrets), NOT its primary-key id — see setCredentials()/
+  // getCredentials() which call secretService.store/retrieve by name. So it is
+  // deliberately NOT a @crossPackageRef id FK.
+  credentialSecretId = null;
+  isActive = true;
+  lastSyncAt = null;
+  settings = "";
+  // JSON
+  // Timestamps
+  createdAt = /* @__PURE__ */ new Date();
+  updatedAt = /* @__PURE__ */ new Date();
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.name !== void 0) this.name = options.name;
+    if (options.providerType !== void 0)
+      this.providerType = options.providerType;
+    if (options.credentialSecretId !== void 0)
+      this.credentialSecretId = options.credentialSecretId || null;
+    if (options.isActive !== void 0) this.isActive = options.isActive;
+    if (options.lastSyncAt !== void 0)
+      this.lastSyncAt = options.lastSyncAt || null;
+    if (options.settings !== void 0) this.settings = options.settings;
+    if (options.createdAt) this.createdAt = options.createdAt;
+    if (options.updatedAt) this.updatedAt = options.updatedAt;
+  }
+  /**
+   * Get settings as parsed object
+   */
+  getSettings() {
+    if (!this.settings) return {};
+    try {
+      return JSON.parse(this.settings);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Set settings from object
+   */
+  setSettings(settings) {
+    this.settings = JSON.stringify(settings);
+  }
+  /**
+   * Activate account
+   */
+  async activate() {
+    this.isActive = true;
+    this.updatedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+  /**
+   * Deactivate account
+   */
+  async deactivate() {
+    this.isActive = false;
+    this.updatedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+  /**
+   * Store credentials securely using smrt-secrets
+   */
+  async setCredentials(credentials, options = {}) {
+    const { SecretService } = await import("@happyvertical/smrt-secrets");
+    const secretService = await SecretService.create({ db: this.db });
+    const secretName = `account-${this.id}`;
+    const secretValue = JSON.stringify(credentials);
+    if (this.credentialSecretId) {
+      await secretService.store(this.credentialSecretId, secretValue, {
+        description: options.description || `Credentials for ${this.name}`,
+        category: options.category || "messaging"
+      });
+    } else {
+      await secretService.store(secretName, secretValue, {
+        description: options.description || `Credentials for ${this.name}`,
+        category: options.category || "messaging"
+      });
+      this.credentialSecretId = secretName;
+      this.updatedAt = /* @__PURE__ */ new Date();
+      await this.save();
+    }
+  }
+  /**
+   * Create a sender for this account.
+   * Subclasses must override to return a concrete sender.
+   */
+  async createSender() {
+    throw new Error(
+      `createSender() not implemented for account type '${this.providerType}'`
+    );
+  }
+  /**
+   * Retrieve stored credentials
+   */
+  async getCredentials() {
+    if (!this.credentialSecretId) {
+      return this.getSettings();
+    }
+    const { SecretService } = await import("@happyvertical/smrt-secrets");
+    const secretService = await SecretService.create({ db: this.db });
+    try {
+      const secret = await secretService.retrieve(this.credentialSecretId);
+      return JSON.parse(secret.value);
+    } catch {
+      return null;
+    }
+  }
+};
+__decorateClass$b([
+  tenantId({ nullable: true })
+], Account.prototype, "tenantId", 2);
+__decorateClass$b([
+  field({ sensitive: true })
+], Account.prototype, "settings", 2);
+Account = __decorateClass$b([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], Account);
+class AccountCollection extends SmrtCollection {
+  static _itemClass = Account;
+  /**
+   * Get active accounts
+   */
+  async getActive() {
+    return await this.list({ where: { isActive: true } });
+  }
+  /**
+   * Get inactive accounts
+   */
+  async getInactive() {
+    return await this.list({ where: { isActive: false } });
+  }
+  /**
+   * Get accounts by provider type
+   */
+  async getByProviderType(providerType) {
+    return await this.list({ where: { providerType } });
+  }
+  /**
+   * Get accounts by STI type.
+   *
+   * Accepts either the full discriminator (e.g. "@happyvertical/smrt-messages:EmailAccount")
+   * or the short type name (e.g. "EmailAccount").
+   */
+  async getByType(accountType) {
+    if (accountType.includes(":") || accountType.startsWith("@")) {
+      return await this.list({ where: { _meta_type: accountType } });
+    }
+    const allAccounts = await this.list({});
+    return allAccounts.filter((a) => {
+      const metaType = a._meta_type || "";
+      return metaType.endsWith(`:${accountType}`);
+    });
+  }
+  /**
+   * Search accounts with filters
+   */
+  async search(query, filters) {
+    let accounts = await this.list({});
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      accounts = accounts.filter(
+        (a) => a.name?.toLowerCase().includes(lowerQuery)
+      );
+    }
+    if (filters) {
+      if (filters.providerType) {
+        accounts = accounts.filter(
+          (a) => a.providerType === filters.providerType
+        );
+      }
+      if (filters.isActive !== void 0) {
+        accounts = accounts.filter((a) => a.isActive === filters.isActive);
+      }
+      if (filters.accountType) {
+        accounts = accounts.filter((a) => {
+          const metaType = a._meta_type || "";
+          return metaType.includes(filters.accountType);
+        });
+      }
+    }
+    return accounts;
+  }
+  /**
+   * Get account statistics
+   */
+  async getStats() {
+    const accounts = await this.list({});
+    const byType = {};
+    for (const account of accounts) {
+      const metaType = account._meta_type || "Unknown";
+      const shortType = metaType.split(":").pop() || metaType;
+      byType[shortType] = (byType[shortType] || 0) + 1;
+    }
+    return {
+      total: accounts.length,
+      active: accounts.filter((a) => a.isActive).length,
+      inactive: accounts.filter((a) => !a.isActive).length,
+      byType
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Tenant Helper Methods
+  // ─────────────────────────────────────────────────────────────────────────
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const AccountCollection$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AccountCollection
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$a = Object.getOwnPropertyDescriptor;
+var __decorateClass$a = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$a(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$2(target, key, result);
+  return result;
+};
+let Attachment = class extends SmrtObject {
+  tenantId = null;
+  messageId = "";
+  filename = "";
+  contentType = "";
+  size = 0;
+  contentId = "";
+  // For inline images (<img src="cid:...">)
+  contentDisposition = "attachment";
+  filePath = "";
+  // External file storage path
+  sourceUrl = "";
+  // For non-email attachments (media URLs, etc.)
+  // Timestamps
+  createdAt = /* @__PURE__ */ new Date();
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.messageId !== void 0) this.messageId = options.messageId;
+    if (options.filename !== void 0) this.filename = options.filename;
+    if (options.contentType !== void 0)
+      this.contentType = options.contentType;
+    if (options.size !== void 0) this.size = options.size;
+    if (options.contentId !== void 0) this.contentId = options.contentId;
+    if (options.contentDisposition !== void 0)
+      this.contentDisposition = options.contentDisposition;
+    if (options.filePath !== void 0) this.filePath = options.filePath;
+    if (options.sourceUrl !== void 0) this.sourceUrl = options.sourceUrl;
+    if (options.createdAt) this.createdAt = options.createdAt;
+  }
+  /**
+   * Get the message this attachment belongs to
+   */
+  async getMessage() {
+    if (!this.messageId) return null;
+    const { MessageCollection: MessageCollection2 } = await Promise.resolve().then(() => MessageCollection$1);
+    const collection = await MessageCollection2.create(this.options);
+    return await collection.get({ id: this.messageId });
+  }
+  /**
+   * Check if attachment is an image
+   */
+  isImage() {
+    return this.contentType.startsWith("image/");
+  }
+  /**
+   * Check if attachment is a PDF
+   */
+  isPdf() {
+    return this.contentType === "application/pdf";
+  }
+  /**
+   * Check if attachment is inline (embedded in message body)
+   */
+  isInline() {
+    return this.contentDisposition === "inline";
+  }
+  /**
+   * Get file extension from filename
+   */
+  getExtension() {
+    if (!this.filename) return "";
+    const parts = this.filename.split(".");
+    return parts.length > 1 ? parts[parts.length - 1].toLowerCase() : "";
+  }
+  /**
+   * Get human-readable file size
+   */
+  getFormattedSize() {
+    const units = ["B", "KB", "MB", "GB"];
+    let size = this.size;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024;
+      unitIndex++;
+    }
+    return `${size.toFixed(1)} ${units[unitIndex]}`;
+  }
+  /**
+   * Check if file is stored externally
+   */
+  hasExternalFile() {
+    return !!this.filePath;
+  }
+  /**
+   * Read file content (if stored externally)
+   */
+  async readContent() {
+    if (!this.filePath) return null;
+    try {
+      const { getFilesystem } = await import("@happyvertical/files");
+      const files = await getFilesystem({ type: "local" });
+      const data = await files.read(this.filePath);
+      return data instanceof Buffer ? data : Buffer.from(data);
+    } catch {
+      return null;
+    }
+  }
+};
+__decorateClass$a([
+  tenantId({ nullable: true })
+], Attachment.prototype, "tenantId", 2);
+__decorateClass$a([
+  foreignKey("Message")
+], Attachment.prototype, "messageId", 2);
+Attachment = __decorateClass$a([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    api: { include: ["list", "get", "create", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], Attachment);
+class AttachmentCollection extends SmrtCollection {
+  static _itemClass = Attachment;
+  /**
+   * Get attachments for a message
+   */
+  async getByMessage(messageId) {
+    return await this.list({ where: { messageId } });
+  }
+  /**
+   * Get attachments by content type
+   */
+  async getByContentType(contentType) {
+    return await this.list({ where: { contentType } });
+  }
+  /**
+   * Get image attachments
+   */
+  async getImages(messageId) {
+    const attachments = messageId ? await this.getByMessage(messageId) : await this.list({});
+    return attachments.filter((a) => a.isImage());
+  }
+  /**
+   * Get PDF attachments
+   */
+  async getPdfs(messageId) {
+    const attachments = messageId ? await this.getByMessage(messageId) : await this.list({});
+    return attachments.filter((a) => a.isPdf());
+  }
+  /**
+   * Get inline attachments (embedded in message body)
+   */
+  async getInline(messageId) {
+    const attachments = await this.getByMessage(messageId);
+    return attachments.filter((a) => a.isInline());
+  }
+  /**
+   * Get regular attachments (not inline)
+   */
+  async getRegular(messageId) {
+    const attachments = await this.getByMessage(messageId);
+    return attachments.filter((a) => !a.isInline());
+  }
+  /**
+   * Get attachments with external files
+   */
+  async getWithExternalFiles() {
+    const attachments = await this.list({});
+    return attachments.filter((a) => a.hasExternalFile());
+  }
+  /**
+   * Get total size of attachments for a message
+   */
+  async getTotalSize(messageId) {
+    const attachments = await this.getByMessage(messageId);
+    return attachments.reduce((sum, a) => sum + a.size, 0);
+  }
+  /**
+   * Get largest attachments
+   */
+  async getLargest(limit = 10) {
+    const attachments = await this.list({});
+    return attachments.sort((a, b) => b.size - a.size).slice(0, limit);
+  }
+  /**
+   * Search attachments by filename
+   */
+  async searchByFilename(query) {
+    const attachments = await this.list({});
+    const lowerQuery = query.toLowerCase();
+    return attachments.filter(
+      (a) => a.filename?.toLowerCase().includes(lowerQuery)
+    );
+  }
+  /**
+   * Get attachments by extension
+   */
+  async getByExtension(extension) {
+    const attachments = await this.list({});
+    const lowerExt = extension.toLowerCase().replace(/^\./, "");
+    return attachments.filter((a) => a.getExtension() === lowerExt);
+  }
+  /**
+   * Get attachment statistics
+   */
+  async getStats() {
+    const attachments = await this.list({});
+    const byType = {};
+    for (const attachment of attachments) {
+      const type = attachment.contentType.split("/")[0] || "other";
+      byType[type] = (byType[type] || 0) + 1;
+    }
+    return {
+      total: attachments.length,
+      totalSize: attachments.reduce((sum, a) => sum + a.size, 0),
+      byType,
+      inline: attachments.filter((a) => a.isInline()).length,
+      regular: attachments.filter((a) => !a.isInline()).length
+    };
+  }
+  /**
+   * Delete all attachments for a message
+   */
+  async deleteByMessage(messageId) {
+    const attachments = await this.getByMessage(messageId);
+    let count = 0;
+    for (const attachment of attachments) {
+      await attachment.delete();
+      count++;
+    }
+    return count;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Tenant Helper Methods
+  // ─────────────────────────────────────────────────────────────────────────
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const AttachmentCollection$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AttachmentCollection
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$9 = Object.getOwnPropertyDescriptor;
+var __decorateClass$9 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$9(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$1(target, key, result);
+  return result;
+};
+let Message = class extends SmrtObject {
+  tenantId = null;
+  accountId = "";
+  threadId = "";
+  subject = "";
+  body = "";
+  // Normalized plain text
+  fromAddress = "";
+  fromName = "";
+  toAddresses = "";
+  // JSON array of {address, name}
+  date = null;
+  isRead = false;
+  isFlagged = false;
+  hasAttachments = false;
+  size = 0;
+  metadata = "";
+  // JSON extension bag
+  // Send lifecycle fields
+  sendStatus = "draft";
+  sentAt = null;
+  sendError = "";
+  retryCount = 0;
+  maxRetries = 3;
+  scheduledSendAt = null;
+  inReplyToMessageId = "";
+  // Timestamps
+  createdAt = /* @__PURE__ */ new Date();
+  updatedAt = /* @__PURE__ */ new Date();
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.accountId !== void 0) this.accountId = options.accountId;
+    if (options.threadId !== void 0) this.threadId = options.threadId;
+    if (options.subject !== void 0) this.subject = options.subject;
+    if (options.body !== void 0) this.body = options.body;
+    if (options.fromAddress !== void 0)
+      this.fromAddress = options.fromAddress;
+    if (options.fromName !== void 0) this.fromName = options.fromName;
+    if (options.toAddresses !== void 0)
+      this.toAddresses = options.toAddresses;
+    if (options.date !== void 0) this.date = options.date || null;
+    if (options.isRead !== void 0) this.isRead = options.isRead;
+    if (options.isFlagged !== void 0) this.isFlagged = options.isFlagged;
+    if (options.hasAttachments !== void 0)
+      this.hasAttachments = options.hasAttachments;
+    if (options.size !== void 0) this.size = options.size;
+    if (options.metadata !== void 0) this.metadata = options.metadata;
+    if (options.sendStatus !== void 0) this.sendStatus = options.sendStatus;
+    if (options.sentAt !== void 0) this.sentAt = options.sentAt || null;
+    if (options.sendError !== void 0) this.sendError = options.sendError;
+    if (options.retryCount !== void 0) this.retryCount = options.retryCount;
+    if (options.maxRetries !== void 0) this.maxRetries = options.maxRetries;
+    if (options.scheduledSendAt !== void 0)
+      this.scheduledSendAt = options.scheduledSendAt || null;
+    if (options.inReplyToMessageId !== void 0)
+      this.inReplyToMessageId = options.inReplyToMessageId;
+    if (options.createdAt) this.createdAt = options.createdAt;
+    if (options.updatedAt) this.updatedAt = options.updatedAt;
+  }
+  /**
+   * Get to addresses as parsed array
+   */
+  getToAddresses() {
+    if (!this.toAddresses) return [];
+    try {
+      return JSON.parse(this.toAddresses);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Set to addresses from array
+   */
+  setToAddresses(addresses) {
+    this.toAddresses = JSON.stringify(addresses);
+  }
+  /**
+   * Get metadata as parsed object
+   */
+  getMetadata() {
+    if (!this.metadata) return {};
+    try {
+      return JSON.parse(this.metadata);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Set metadata from object
+   */
+  setMetadata(data) {
+    this.metadata = JSON.stringify(data);
+  }
+  /**
+   * Mark message as read
+   */
+  async markRead() {
+    this.isRead = true;
+    this.updatedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+  /**
+   * Mark message as unread
+   */
+  async markUnread() {
+    this.isRead = false;
+    this.updatedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+  /**
+   * Toggle flagged status
+   */
+  async toggleFlagged() {
+    this.isFlagged = !this.isFlagged;
+    this.updatedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+  /**
+   * Check if message is unread
+   */
+  isUnread() {
+    return !this.isRead;
+  }
+  /**
+   * Get a short preview of the message body
+   */
+  getPreview(maxLength = 200) {
+    const text = this.body || "";
+    if (text.length <= maxLength) return text;
+    return `${text.slice(0, maxLength)}...`;
+  }
+  /**
+   * Get the account for this message
+   */
+  async getAccount() {
+    if (!this.accountId) return null;
+    const { AccountCollection: AccountCollection2 } = await Promise.resolve().then(() => AccountCollection$1);
+    const collection = await AccountCollection2.create(this.options);
+    return await collection.get({ id: this.accountId });
+  }
+  /**
+   * Get messages in the same thread
+   */
+  async getThreadMessages() {
+    if (!this.threadId) return [this];
+    const { MessageCollection: MessageCollection2 } = await Promise.resolve().then(() => MessageCollection$1);
+    const collection = await MessageCollection2.create(this.options);
+    return await collection.list({ where: { threadId: this.threadId } });
+  }
+  /**
+   * Get attachments for this message
+   */
+  async getAttachments() {
+    const { AttachmentCollection: AttachmentCollection2 } = await Promise.resolve().then(() => AttachmentCollection$1);
+    const collection = await AttachmentCollection2.create(this.options);
+    return await collection.list({ where: { messageId: this.id } });
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Send Lifecycle
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Send this message via its account's sender
+   */
+  async send(options) {
+    const account = await this.getAccount();
+    if (!account) {
+      const result = {
+        success: false,
+        error: "No account associated with this message",
+        sentAt: /* @__PURE__ */ new Date()
+      };
+      this.sendStatus = "failed";
+      this.sendError = result.error ?? "";
+      this.updatedAt = /* @__PURE__ */ new Date();
+      await this.save();
+      return result;
+    }
+    const sender = await account.createSender();
+    this.sendStatus = "sending";
+    this.updatedAt = /* @__PURE__ */ new Date();
+    await this.save();
+    try {
+      const result = await sender.send(this, options);
+      if (result.success) {
+        this.sendStatus = "sent";
+        this.sentAt = result.sentAt;
+        this.sendError = "";
+      } else {
+        this.sendStatus = "failed";
+        this.sendError = result.error ?? "Send failed";
+      }
+      this.updatedAt = /* @__PURE__ */ new Date();
+      await this.save();
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.sendStatus = "failed";
+      this.sendError = errorMessage;
+      this.updatedAt = /* @__PURE__ */ new Date();
+      await this.save();
+      return {
+        success: false,
+        error: errorMessage,
+        sentAt: /* @__PURE__ */ new Date()
+      };
+    }
+  }
+  /**
+   * Retry sending a failed message
+   */
+  async retrySend(options) {
+    if (this.sendStatus !== "failed") {
+      return {
+        success: false,
+        error: `Cannot retry: message status is '${this.sendStatus}', expected 'failed'`,
+        sentAt: /* @__PURE__ */ new Date()
+      };
+    }
+    if (this.retryCount >= this.maxRetries) {
+      return {
+        success: false,
+        error: `Retry budget exhausted (${this.retryCount}/${this.maxRetries})`,
+        sentAt: /* @__PURE__ */ new Date()
+      };
+    }
+    this.retryCount++;
+    this.updatedAt = /* @__PURE__ */ new Date();
+    await this.save();
+    return this.send(options);
+  }
+  /**
+   * Create a reply to this message (returns unsaved draft)
+   */
+  createReply(_options) {
+    const reply = new this.constructor({
+      ...this.options,
+      id: void 0,
+      accountId: this.accountId,
+      threadId: this.threadId || this.id || "",
+      subject: this.subject.startsWith("Re:") ? this.subject : `Re: ${this.subject}`,
+      toAddresses: JSON.stringify([
+        { address: this.fromAddress, name: this.fromName }
+      ]),
+      fromAddress: "",
+      fromName: "",
+      body: this.buildQuotedBody(),
+      inReplyToMessageId: this.id || "",
+      sendStatus: "draft",
+      isRead: true,
+      date: null,
+      createdAt: void 0,
+      updatedAt: void 0
+    });
+    return reply;
+  }
+  /**
+   * Create a forward of this message (returns unsaved draft)
+   */
+  createForward() {
+    const forward = new this.constructor({
+      ...this.options,
+      id: void 0,
+      accountId: this.accountId,
+      threadId: "",
+      subject: this.subject.startsWith("Fwd:") ? this.subject : `Fwd: ${this.subject}`,
+      toAddresses: "[]",
+      fromAddress: "",
+      fromName: "",
+      body: this.buildQuotedBody(),
+      hasAttachments: this.hasAttachments,
+      inReplyToMessageId: "",
+      sendStatus: "draft",
+      isRead: true,
+      date: null,
+      createdAt: void 0,
+      updatedAt: void 0
+    });
+    return forward;
+  }
+  /**
+   * Build quoted body for reply/forward
+   */
+  buildQuotedBody() {
+    const dateStr = this.date ? this.date.toLocaleString() : "unknown date";
+    const from = this.fromName ? `${this.fromName} <${this.fromAddress}>` : this.fromAddress;
+    const quotedLines = (this.body || "").split("\n").map((line) => `> ${line}`).join("\n");
+    return `
+
+On ${dateStr}, ${from} wrote:
+${quotedLines}`;
+  }
+};
+__decorateClass$9([
+  tenantId({ nullable: true })
+], Message.prototype, "tenantId", 2);
+__decorateClass$9([
+  foreignKey("Account")
+], Message.prototype, "accountId", 2);
+__decorateClass$9([
+  foreignKey("Message")
+], Message.prototype, "inReplyToMessageId", 2);
+Message = __decorateClass$9([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], Message);
+class MessageCollection extends SmrtCollection {
+  static _itemClass = Message;
+  /**
+   * Search messages with filters
+   */
+  async search(query, filters) {
+    let messages = await this.list({});
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      messages = messages.filter(
+        (m) => m.subject?.toLowerCase().includes(lowerQuery) || m.body?.toLowerCase().includes(lowerQuery) || m.fromAddress?.toLowerCase().includes(lowerQuery) || m.fromName?.toLowerCase().includes(lowerQuery)
+      );
+    }
+    if (filters) {
+      if (filters.accountIds && filters.accountIds.length > 0) {
+        messages = messages.filter(
+          (m) => filters.accountIds?.includes(m.accountId)
+        );
+      }
+      if (filters.messageType) {
+        messages = messages.filter((m) => {
+          const metaType = m._meta_type || "";
+          return metaType.includes(filters.messageType);
+        });
+      }
+      if (filters.from) {
+        const fromLower = filters.from.toLowerCase();
+        messages = messages.filter(
+          (m) => m.fromAddress?.toLowerCase().includes(fromLower) || m.fromName?.toLowerCase().includes(fromLower)
+        );
+      }
+      if (filters.to) {
+        const toLower = filters.to.toLowerCase();
+        messages = messages.filter(
+          (m) => m.toAddresses?.toLowerCase().includes(toLower)
+        );
+      }
+      if (filters.isRead !== void 0) {
+        messages = messages.filter((m) => m.isRead === filters.isRead);
+      }
+      if (filters.isFlagged !== void 0) {
+        messages = messages.filter((m) => m.isFlagged === filters.isFlagged);
+      }
+      if (filters.sinceDate) {
+        messages = messages.filter(
+          (m) => m.date && m.date >= filters.sinceDate
+        );
+      }
+      if (filters.beforeDate) {
+        messages = messages.filter(
+          (m) => m.date && m.date < filters.beforeDate
+        );
+      }
+      if (filters.query) {
+        const q = filters.query.toLowerCase();
+        messages = messages.filter(
+          (m) => m.subject?.toLowerCase().includes(q) || m.body?.toLowerCase().includes(q)
+        );
+      }
+    }
+    return messages;
+  }
+  /**
+   * Get messages by multiple accounts
+   */
+  async getByAccounts(accountIds) {
+    const allMessages = await this.list({});
+    return allMessages.filter((m) => accountIds.includes(m.accountId));
+  }
+  /**
+   * Get messages by STI type.
+   *
+   * Accepts either the full discriminator (e.g. "@happyvertical/smrt-messages:Email")
+   * or the short type name (e.g. "Email").
+   */
+  async getByType(messageType) {
+    if (messageType.includes(":") || messageType.startsWith("@")) {
+      return await this.list({ where: { _meta_type: messageType } });
+    }
+    const allMessages = await this.list({});
+    return allMessages.filter((m) => {
+      const metaType = m._meta_type || "";
+      return metaType.endsWith(`:${messageType}`);
+    });
+  }
+  /**
+   * Get unread messages
+   */
+  async getUnread(accountId) {
+    const where = { isRead: false };
+    if (accountId) {
+      where.accountId = accountId;
+    }
+    return await this.list({ where });
+  }
+  /**
+   * Get flagged messages
+   */
+  async getFlagged(accountId) {
+    const where = { isFlagged: true };
+    if (accountId) {
+      where.accountId = accountId;
+    }
+    return await this.list({ where });
+  }
+  /**
+   * Get recent messages
+   */
+  async getRecent(limit = 20, accountId) {
+    const allMessages = await this.list({
+      where: accountId ? { accountId } : void 0
+    });
+    return allMessages.sort((a, b) => {
+      const dateA = a.date?.getTime() || 0;
+      const dateB = b.date?.getTime() || 0;
+      return dateB - dateA;
+    }).slice(0, limit);
+  }
+  /**
+   * Get messages by thread
+   */
+  async getByThread(threadId) {
+    return await this.list({ where: { threadId } });
+  }
+  /**
+   * Mark multiple messages as read
+   */
+  async markAllRead(messageIds) {
+    for (const id of messageIds) {
+      const message = await this.get({ id });
+      if (message) {
+        await message.markRead();
+      }
+    }
+  }
+  /**
+   * Get message statistics for an account
+   */
+  async getAccountStats(accountId) {
+    const messages = await this.list({ where: { accountId } });
+    const byType = {};
+    for (const msg of messages) {
+      const metaType = msg._meta_type || "Unknown";
+      const shortType = metaType.split(":").pop() || metaType;
+      byType[shortType] = (byType[shortType] || 0) + 1;
+    }
+    return {
+      total: messages.length,
+      unread: messages.filter((m) => !m.isRead).length,
+      flagged: messages.filter((m) => m.isFlagged).length,
+      byType
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Send / Draft Queries
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Get draft messages
+   */
+  async getDrafts(accountId) {
+    const where = { sendStatus: "draft" };
+    if (accountId) where.accountId = accountId;
+    return await this.list({ where });
+  }
+  /**
+   * Get sent messages
+   */
+  async getSent(accountId) {
+    const where = { sendStatus: "sent" };
+    if (accountId) where.accountId = accountId;
+    return await this.list({ where });
+  }
+  /**
+   * Get scheduled messages
+   */
+  async getScheduled(accountId) {
+    const where = { sendStatus: "scheduled" };
+    if (accountId) where.accountId = accountId;
+    return await this.list({ where });
+  }
+  /**
+   * Get messages that failed to send
+   */
+  async getFailedSends(accountId) {
+    const where = { sendStatus: "failed" };
+    if (accountId) where.accountId = accountId;
+    return await this.list({ where });
+  }
+  /**
+   * Get outbox (pending + sending + scheduled)
+   */
+  async getOutbox(accountId) {
+    const allMessages = await this.list({
+      where: accountId ? { accountId } : void 0
+    });
+    return allMessages.filter(
+      (m) => m.sendStatus === "pending" || m.sendStatus === "sending" || m.sendStatus === "scheduled"
+    );
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Tenant Helper Methods
+  // ─────────────────────────────────────────────────────────────────────────
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const MessageCollection$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  MessageCollection
+}, Symbol.toStringTag, { value: "Module" }));
+var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
+var __decorateClass$8 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let EmailAccount = class extends Account {
+  email = "";
+  syncIntervalMinutes = 60;
+  constructor(options = {}) {
+    super(options);
+    if (options.email !== void 0) this.email = options.email;
+    if (options.providerType !== void 0)
+      this.providerType = options.providerType;
+    if (options.syncIntervalMinutes !== void 0)
+      this.syncIntervalMinutes = options.syncIntervalMinutes;
+  }
+  /**
+   * Options for child rows (folders/emails) created during sync: carries the DB
+   * connection + tenant context from this account, but strips this account's own
+   * identity fields. When this account was hydrated from the DB, `this.options`
+   * holds the account row's `id`/`slug`/`_skipLoad`; spreading those into a new
+   * child would make every synced row inherit the account's primary key and
+   * upsert over each other.
+   */
+  childOptions() {
+    const rest = { ...this.options };
+    delete rest.id;
+    delete rest.slug;
+    delete rest._skipLoad;
+    return rest;
+  }
+  /**
+   * Create a sender for this email account
+   */
+  async createSender() {
+    const client = await this.createClient();
+    await client.connect();
+    const { EmailSender: EmailSender2 } = await Promise.resolve().then(() => EmailSender$1);
+    return new EmailSender2(client, this);
+  }
+  /**
+   * Create an EmailClient from stored settings
+   * Retrieves credentials from smrt-secrets if credentialSecretId is set
+   */
+  async createClient() {
+    const { getEmailClient } = await import("@happyvertical/email");
+    let settings;
+    if (this.credentialSecretId) {
+      const { SecretService } = await import("@happyvertical/smrt-secrets");
+      const secretService = await SecretService.create({ db: this.db });
+      const secret = await secretService.retrieve(this.credentialSecretId);
+      settings = JSON.parse(secret.value);
+    } else {
+      settings = this.getSettings();
+    }
+    return await getEmailClient({
+      type: this.providerType,
+      ...settings
+    });
+  }
+  /**
+   * Sync emails from the email server to the database
+   */
+  async syncFrom(options = {}) {
+    const startTime = Date.now();
+    const result = {
+      folders: [],
+      messagesProcessed: 0,
+      messagesDownloaded: 0,
+      messagesSkipped: 0,
+      errors: [],
+      duration: 0
+    };
+    try {
+      const client = await this.createClient();
+      await client.connect();
+      const foldersToSync = options.folders || ["INBOX"];
+      result.folders = foldersToSync;
+      const { EmailCollection: EmailCollection2 } = await Promise.resolve().then(() => EmailCollection$1);
+      const { EmailFolderCollection: EmailFolderCollection2 } = await Promise.resolve().then(() => EmailFolderCollection$1);
+      const emailCollection = await EmailCollection2.create(
+        this.options
+      );
+      const folderCollection = await EmailFolderCollection2.create(
+        this.options
+      );
+      for (const folderName of foldersToSync) {
+        try {
+          const accountId = this.id ?? "";
+          let folder = await folderCollection.getByPath(accountId, folderName);
+          if (!folder) {
+            const { EmailFolder: EmailFolder2 } = await Promise.resolve().then(() => EmailFolder$1);
+            folder = new EmailFolder2({
+              ...this.childOptions(),
+              accountId,
+              name: folderName,
+              path: folderName
+            });
+            await folder.initialize();
+            await folder.save();
+          }
+          const fetchOptions = {
+            folder: folderName,
+            limit: options.batchSize || 100
+          };
+          if (options.since) {
+            fetchOptions.since = options.since;
+          }
+          if (options.before) {
+            fetchOptions.before = options.before;
+          }
+          const messages = await client.fetch(fetchOptions);
+          for (const msg of messages) {
+            result.messagesProcessed++;
+            try {
+              const existingEmail = await emailCollection.getByMessageId(
+                this.id,
+                msg.messageId || ""
+              );
+              if (existingEmail && !options.fullSync) {
+                result.messagesSkipped++;
+                continue;
+              }
+              const { Email: Email2 } = await Promise.resolve().then(() => Email$1);
+              let email = existingEmail;
+              if (!email) {
+                email = new Email2({
+                  ...this.childOptions(),
+                  accountId
+                });
+                await email.initialize();
+              }
+              email.messageId = msg.messageId || "";
+              email.threadId = msg.threadId || "";
+              email.inReplyTo = msg.inReplyTo || "";
+              email.fromAddress = msg.from?.address || "";
+              email.fromName = msg.from?.name || "";
+              email.toAddresses = JSON.stringify(msg.to || []);
+              email.ccAddresses = JSON.stringify(msg.cc || []);
+              email.bccAddresses = JSON.stringify(msg.bcc || []);
+              email.replyToAddress = msg.replyTo?.address || "";
+              email.replyToName = msg.replyTo?.name || "";
+              email.subject = msg.subject || "";
+              email.date = msg.date || null;
+              email.textBody = msg.text || "";
+              email.htmlBody = msg.html || "";
+              email.body = msg.text || "";
+              email.folderId = folder.id;
+              email.folderPath = folderName;
+              email.labels = JSON.stringify(msg.labels || []);
+              email.flags = JSON.stringify(msg.flags || []);
+              email.hasAttachments = msg.attachments && msg.attachments.length > 0 || false;
+              email.size = msg.size || 0;
+              email.headers = JSON.stringify(msg.headers || {});
+              email.updatedAt = /* @__PURE__ */ new Date();
+              await email.save();
+              result.messagesDownloaded++;
+              if (options.onProgress) {
+                options.onProgress({
+                  folder: folderName,
+                  processed: result.messagesProcessed,
+                  total: messages.length,
+                  downloaded: result.messagesDownloaded,
+                  skipped: result.messagesSkipped,
+                  errors: result.errors.length
+                });
+              }
+            } catch (error) {
+              const err = error instanceof Error ? error : new Error(String(error));
+              result.errors.push(err);
+              if (options.onError) {
+                options.onError(err, msg);
+              }
+            }
+          }
+          folder.messageCount = await emailCollection.countByFolder(folder.id);
+          folder.unreadCount = await emailCollection.countUnreadByFolder(
+            folder.id
+          );
+          await folder.save();
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          result.errors.push(err);
+          if (options.onError) {
+            options.onError(err);
+          }
+        }
+      }
+      this.lastSyncAt = /* @__PURE__ */ new Date();
+      this.updatedAt = /* @__PURE__ */ new Date();
+      await this.save();
+      await client.disconnect();
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      result.errors.push(err);
+      if (options.onError) {
+        options.onError(err);
+      }
+    }
+    result.duration = Date.now() - startTime;
+    return result;
+  }
+  /**
+   * Get all folders for this account
+   */
+  async getFolders() {
+    const { EmailFolderCollection: EmailFolderCollection2 } = await Promise.resolve().then(() => EmailFolderCollection$1);
+    const collection = await EmailFolderCollection2.create(
+      this.options
+    );
+    return await collection.list({ where: { accountId: this.id } });
+  }
+  /**
+   * Get all emails for this account
+   */
+  async getEmails(limit) {
+    const { EmailCollection: EmailCollection2 } = await Promise.resolve().then(() => EmailCollection$1);
+    const collection = await EmailCollection2.create(this.options);
+    const options = { where: { accountId: this.id } };
+    if (limit) {
+      options.limit = limit;
+    }
+    return await collection.list(options);
+  }
+  /**
+   * Get unread email count
+   */
+  async getUnreadCount() {
+    const { EmailCollection: EmailCollection2 } = await Promise.resolve().then(() => EmailCollection$1);
+    const collection = await EmailCollection2.create(this.options);
+    return await collection.countUnreadByAccount(this.id);
+  }
+  /**
+   * Store credentials securely using smrt-secrets (email-specific)
+   */
+  async setCredentials(credentials, options = {}) {
+    const { SecretService } = await import("@happyvertical/smrt-secrets");
+    const secretService = await SecretService.create({ db: this.db });
+    const secretName = `email-account-${this.id}`;
+    const secretValue = JSON.stringify(credentials);
+    if (this.credentialSecretId) {
+      await secretService.store(this.credentialSecretId, secretValue, {
+        description: options.description || `IMAP credentials for ${this.name}`,
+        category: options.category || "email"
+      });
+    } else {
+      await secretService.store(secretName, secretValue, {
+        description: options.description || `IMAP credentials for ${this.name}`,
+        category: options.category || "email"
+      });
+      this.credentialSecretId = secretName;
+      this.updatedAt = /* @__PURE__ */ new Date();
+      await this.save();
+    }
+  }
+  /**
+   * Sync all active email accounts (for job runner)
+   *
+   * NOTE: This is a class-wide operation, not per-instance. It syncs ALL active
+   * accounts, ignoring `this` instance. It exists as an instance method because
+   * the TaskRunner dispatches via `objectType: 'EmailAccount', method: 'syncAll'`
+   * which requires an instance method signature.
+   */
+  async syncAll(args) {
+    const { EmailAccountCollection: EmailAccountCollection2 } = await Promise.resolve().then(() => EmailAccountCollection$1);
+    const collection = await EmailAccountCollection2.create({
+      db: this.db
+    });
+    return collection.syncAll(args);
+  }
+  /**
+   * Migrate from plain-text settings to secrets
+   */
+  async migrateToSecrets() {
+    if (this.credentialSecretId) {
+      return;
+    }
+    const settings = this.getSettings();
+    if (Object.keys(settings).length === 0) {
+      return;
+    }
+    await this.setCredentials(settings, {
+      description: `Migrated IMAP credentials for ${this.name}`
+    });
+  }
+};
+EmailAccount = __decorateClass$8([
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], EmailAccount);
+class EmailAccountCollection extends AccountCollection {
+  static _itemClass = EmailAccount;
+  /**
+   * Get account by email address
+   */
+  async getByEmail(email) {
+    const accounts = await this.list({ where: { email } });
+    return accounts[0] || null;
+  }
+  /**
+   * Get accounts by email provider type
+   */
+  async getByEmailProviderType(providerType) {
+    return await this.list({ where: { providerType } });
+  }
+  /**
+   * Get active email accounts
+   */
+  async getActive() {
+    return await this.list({ where: { isActive: true } });
+  }
+  /**
+   * Get inactive email accounts
+   */
+  async getInactive() {
+    return await this.list({ where: { isActive: false } });
+  }
+  /**
+   * Get accounts that need syncing
+   */
+  async getNeedingSync(maxAgeMinutes = 60) {
+    const allAccounts = await this.getActive();
+    const cutoffTime = new Date(Date.now() - maxAgeMinutes * 60 * 1e3);
+    return allAccounts.filter(
+      (account) => !account.lastSyncAt || account.lastSyncAt < cutoffTime
+    );
+  }
+  /**
+   * Search email accounts with filters.
+   * Alias: `search()` for backward compatibility.
+   */
+  async search(query, filters) {
+    return this.searchEmailAccounts(query, filters);
+  }
+  /**
+   * Get accounts by email provider type.
+   * Alias: `getByProviderType()` for backward compatibility.
+   */
+  async getByProviderType(providerType) {
+    return this.getByEmailProviderType(providerType);
+  }
+  /**
+   * Get email account statistics.
+   * Alias: `getStats()` for backward compatibility.
+   */
+  async getStats() {
+    const stats = await this.getEmailStats();
+    return {
+      total: stats.total,
+      active: stats.active,
+      inactive: stats.inactive,
+      byType: stats.byProvider
+    };
+  }
+  /**
+   * Search email accounts with filters
+   */
+  async searchEmailAccounts(query, filters) {
+    let accounts = await this.list({});
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      accounts = accounts.filter(
+        (a) => a.name?.toLowerCase().includes(lowerQuery) || a.email?.toLowerCase().includes(lowerQuery)
+      );
+    }
+    if (filters) {
+      if (filters.providerType) {
+        accounts = accounts.filter(
+          (a) => a.providerType === filters.providerType
+        );
+      }
+      if (filters.email) {
+        const emailLower = filters.email.toLowerCase();
+        accounts = accounts.filter(
+          (a) => a.email?.toLowerCase().includes(emailLower)
+        );
+      }
+      if (filters.isActive !== void 0) {
+        accounts = accounts.filter((a) => a.isActive === filters.isActive);
+      }
+    }
+    return accounts;
+  }
+  /**
+   * Sync all active email accounts
+   */
+  async syncAll(options) {
+    const results = /* @__PURE__ */ new Map();
+    const accounts = await this.getActive();
+    for (const account of accounts) {
+      const ea = account;
+      const accountId = ea.id ?? ea.email ?? "unknown";
+      try {
+        await ea.syncFrom(options);
+        results.set(accountId, { success: true });
+      } catch (error) {
+        results.set(accountId, {
+          success: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Get total unread count across all email accounts
+   */
+  async getTotalUnreadCount() {
+    const accounts = await this.getActive();
+    let total = 0;
+    for (const account of accounts) {
+      total += await account.getUnreadCount();
+    }
+    return total;
+  }
+  /**
+   * Get email account statistics
+   */
+  async getEmailStats() {
+    const accounts = await this.list({});
+    const byProvider = {
+      smtp: 0,
+      imap: 0,
+      pop3: 0,
+      gmail: 0
+    };
+    for (const account of accounts) {
+      const pt = account.providerType;
+      if (pt in byProvider) {
+        byProvider[pt]++;
+      }
+    }
+    return {
+      total: accounts.length,
+      active: accounts.filter((a) => a.isActive).length,
+      inactive: accounts.filter((a) => !a.isActive).length,
+      byProvider
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Tenant Helper Methods
+  // ─────────────────────────────────────────────────────────────────────────
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const EmailAccountCollection$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  EmailAccountCollection
+}, Symbol.toStringTag, { value: "Module" }));
+class EmailAttachment extends Attachment {
+  /**
+   * Legacy emailId field — maps to messageId
+   */
+  get emailId() {
+    return this.messageId;
+  }
+  set emailId(value) {
+    this.messageId = value;
+  }
+  constructor(options = {}) {
+    const mappedOptions = {
+      ...options,
+      messageId: options.emailId || options.messageId || ""
+    };
+    super(mappedOptions);
+  }
+  /**
+   * Get the email this attachment belongs to
+   * @deprecated Use getMessage() instead
+   */
+  async getEmail() {
+    if (!this.messageId) return null;
+    const { EmailCollection: EmailCollection2 } = await Promise.resolve().then(() => EmailCollection$1);
+    const collection = await EmailCollection2.create(this.options);
+    return await collection.get({ id: this.messageId });
+  }
+}
+class EmailAttachmentCollection extends AttachmentCollection {
+  static _itemClass = EmailAttachment;
+  /**
+   * Get attachments for an email
+   * @deprecated Use getByMessage() instead
+   */
+  async getByEmail(emailId) {
+    return await this.getByMessage(emailId);
+  }
+  /**
+   * Get image attachments
+   */
+  async getImages(emailId) {
+    return await super.getImages(emailId);
+  }
+  /**
+   * Get PDF attachments
+   */
+  async getPdfs(emailId) {
+    return await super.getPdfs(emailId);
+  }
+  /**
+   * Get inline attachments
+   */
+  async getInline(emailId) {
+    return await super.getInline(emailId);
+  }
+  /**
+   * Get regular attachments
+   */
+  async getRegular(emailId) {
+    return await super.getRegular(emailId);
+  }
+  /**
+   * Delete all attachments for an email
+   * @deprecated Use deleteByMessage() instead
+   */
+  async deleteByEmail(emailId) {
+    return await this.deleteByMessage(emailId);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Tenant Helper Methods
+  // ─────────────────────────────────────────────────────────────────────────
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
+var __decorateClass$7 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let Email = class extends Message {
+  // RFC 822 fields
+  messageId = "";
+  // RFC 822 Message-ID header
+  inReplyTo = "";
+  // Additional recipients
+  ccAddresses = "";
+  bccAddresses = "";
+  replyToAddress = "";
+  replyToName = "";
+  // Email-specific content
+  textBody = "";
+  htmlBody = "";
+  // Location
+  folderId = "";
+  folderPath = "";
+  labels = "";
+  // JSON array (Gmail)
+  flags = "";
+  // JSON array (IMAP)
+  // Email-specific status flags
+  isAnswered = false;
+  isDraft = false;
+  // Raw data
+  rawMessage = "";
+  headers = "";
+  // JSON object
+  constructor(options = {}) {
+    super(options);
+    if (options.messageId !== void 0) this.messageId = options.messageId;
+    if (options.inReplyTo !== void 0) this.inReplyTo = options.inReplyTo;
+    if (options.ccAddresses !== void 0)
+      this.ccAddresses = options.ccAddresses;
+    if (options.bccAddresses !== void 0)
+      this.bccAddresses = options.bccAddresses;
+    if (options.replyToAddress !== void 0)
+      this.replyToAddress = options.replyToAddress;
+    if (options.replyToName !== void 0)
+      this.replyToName = options.replyToName;
+    if (options.textBody !== void 0) this.textBody = options.textBody;
+    if (options.htmlBody !== void 0) this.htmlBody = options.htmlBody;
+    if (options.folderId !== void 0) this.folderId = options.folderId;
+    if (options.folderPath !== void 0) this.folderPath = options.folderPath;
+    if (options.labels !== void 0) this.labels = options.labels;
+    if (options.flags !== void 0) this.flags = options.flags;
+    if (options.isAnswered !== void 0) this.isAnswered = options.isAnswered;
+    if (options.isDraft !== void 0) this.isDraft = options.isDraft;
+    if (options.rawMessage !== void 0) this.rawMessage = options.rawMessage;
+    if (options.headers !== void 0) this.headers = options.headers;
+    if (options.textBody && !options.body) {
+      this.body = options.textBody;
+    }
+  }
+  /**
+   * Get CC addresses as parsed array
+   */
+  getCcAddresses() {
+    if (!this.ccAddresses) return [];
+    try {
+      return JSON.parse(this.ccAddresses);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get BCC addresses as parsed array
+   */
+  getBccAddresses() {
+    if (!this.bccAddresses) return [];
+    try {
+      return JSON.parse(this.bccAddresses);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get labels as parsed array
+   */
+  getLabels() {
+    if (!this.labels) return [];
+    try {
+      return JSON.parse(this.labels);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Set labels from array
+   */
+  setLabels(labels) {
+    this.labels = JSON.stringify(labels);
+  }
+  /**
+   * Get flags as parsed array
+   */
+  getFlags() {
+    if (!this.flags) return [];
+    try {
+      return JSON.parse(this.flags);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Set flags from array
+   */
+  setFlags(flags) {
+    this.flags = JSON.stringify(flags);
+  }
+  /**
+   * Get headers as parsed object
+   */
+  getHeaders() {
+    if (!this.headers) return {};
+    try {
+      return JSON.parse(this.headers);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Set headers from object
+   */
+  setHeaders(headers) {
+    this.headers = JSON.stringify(headers);
+  }
+  /**
+   * Get the email account (typed as EmailAccount)
+   */
+  async getAccount() {
+    if (!this.accountId) return null;
+    const { EmailAccountCollection: EmailAccountCollection2 } = await Promise.resolve().then(() => EmailAccountCollection$1);
+    const collection = await EmailAccountCollection2.create(
+      this.options
+    );
+    return await collection.get({ id: this.accountId });
+  }
+  /**
+   * Get the folder
+   */
+  async getFolder() {
+    if (!this.folderId) return null;
+    const { EmailFolderCollection: EmailFolderCollection2 } = await Promise.resolve().then(() => EmailFolderCollection$1);
+    const collection = await EmailFolderCollection2.create(
+      this.options
+    );
+    return await collection.get({ id: this.folderId });
+  }
+  /**
+   * Get emails in the same thread
+   */
+  async getThreadEmails() {
+    if (!this.threadId) return [this];
+    const { EmailCollection: EmailCollection2 } = await Promise.resolve().then(() => EmailCollection$1);
+    const collection = await EmailCollection2.create(this.options);
+    return await collection.list({ where: { threadId: this.threadId } });
+  }
+  /**
+   * Get a short preview of the email body
+   */
+  getPreview(maxLength = 200) {
+    const body = this.textBody || this.htmlBody?.replace(/<[^>]*>/g, "") || "";
+    if (body.length <= maxLength) return body;
+    return `${body.slice(0, maxLength)}...`;
+  }
+  /**
+   * Get References header values as array
+   */
+  getReferences() {
+    const headers = this.getHeaders();
+    const refs = headers.references;
+    if (!refs) return [];
+    if (Array.isArray(refs)) return refs;
+    return refs.split(/\s+/).filter(Boolean);
+  }
+  /**
+   * Create a reply to this email with RFC 822 threading
+   */
+  createReply(options) {
+    const reply = new Email({
+      ...this.options,
+      id: void 0,
+      accountId: this.accountId,
+      threadId: this.threadId || this.id || void 0,
+      subject: this.subject.startsWith("Re:") ? this.subject : `Re: ${this.subject}`,
+      fromAddress: "",
+      fromName: "",
+      inReplyToMessageId: this.id || void 0,
+      sendStatus: "draft",
+      isRead: true,
+      isDraft: true,
+      date: null,
+      createdAt: void 0,
+      updatedAt: void 0,
+      // RFC 822 threading
+      inReplyTo: this.messageId,
+      // To: original sender
+      toAddresses: JSON.stringify([
+        { address: this.fromAddress, name: this.fromName }
+      ])
+    });
+    const refs = [...this.getReferences()];
+    if (this.messageId && !refs.includes(this.messageId)) {
+      refs.push(this.messageId);
+    }
+    reply.setHeaders({ references: refs.join(" ") });
+    if (options?.replyAll) {
+      const allRecipients = [
+        ...this.getToAddresses(),
+        ...this.getCcAddresses()
+      ];
+      const seen = /* @__PURE__ */ new Set([this.fromAddress.toLowerCase()]);
+      const ccAddresses = allRecipients.filter((r) => {
+        const addr = r.address.toLowerCase();
+        if (seen.has(addr)) return false;
+        seen.add(addr);
+        return true;
+      });
+      reply.ccAddresses = JSON.stringify(ccAddresses);
+    }
+    reply.body = this.buildQuotedBody();
+    reply.textBody = reply.body;
+    return reply;
+  }
+  /**
+   * Create a forward of this email
+   */
+  createForward() {
+    const forwardBody = this.buildForwardBody();
+    const forward = new Email({
+      ...this.options,
+      id: void 0,
+      accountId: this.accountId,
+      threadId: "",
+      subject: this.subject.startsWith("Fwd:") ? this.subject : `Fwd: ${this.subject}`,
+      toAddresses: "[]",
+      ccAddresses: "[]",
+      bccAddresses: "[]",
+      fromAddress: "",
+      fromName: "",
+      body: forwardBody,
+      textBody: forwardBody,
+      hasAttachments: this.hasAttachments,
+      inReplyToMessageId: "",
+      inReplyTo: "",
+      sendStatus: "draft",
+      isDraft: true,
+      isRead: true,
+      date: null,
+      createdAt: void 0,
+      updatedAt: void 0
+    });
+    return forward;
+  }
+  /**
+   * Build email-specific quoted body for replies
+   */
+  buildQuotedBody() {
+    const dateStr = this.date ? this.date.toLocaleString() : "unknown date";
+    const from = this.fromName ? `${this.fromName} <${this.fromAddress}>` : this.fromAddress;
+    const bodyText = this.textBody || this.body || "";
+    const quotedLines = bodyText.split("\n").map((line) => `> ${line}`).join("\n");
+    return `
+
+On ${dateStr}, ${from} wrote:
+${quotedLines}`;
+  }
+  /**
+   * Build forwarded message body
+   */
+  buildForwardBody() {
+    const dateStr = this.date ? this.date.toLocaleString() : "unknown date";
+    const from = this.fromName ? `${this.fromName} <${this.fromAddress}>` : this.fromAddress;
+    const toStr = this.getToAddresses().map((r) => r.name ? `${r.name} <${r.address}>` : r.address).join(", ");
+    const bodyText = this.textBody || this.body || "";
+    return [
+      "",
+      "",
+      "---------- Forwarded message ----------",
+      `From: ${from}`,
+      `Date: ${dateStr}`,
+      `Subject: ${this.subject}`,
+      `To: ${toStr}`,
+      "",
+      bodyText
+    ].join("\n");
+  }
+};
+Email = __decorateClass$7([
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], Email);
+const Email$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  get Email() {
+    return Email;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+class EmailCollection extends MessageCollection {
+  static _itemClass = Email;
+  /**
+   * Get email by RFC 822 Message-ID
+   */
+  async getByMessageId(accountId, messageId) {
+    const emails = await this.list({
+      where: { accountId, messageId },
+      limit: 1
+    });
+    return emails[0] || null;
+  }
+  /**
+   * Get emails by account
+   */
+  async getByAccount(accountId) {
+    return await this.list({ where: { accountId } });
+  }
+  /**
+   * Get emails by folder
+   */
+  async getByFolder(folderId) {
+    return await this.list({ where: { folderId } });
+  }
+  /**
+   * Get emails by thread
+   */
+  async getByThread(threadId) {
+    return await this.list({ where: { threadId } });
+  }
+  /**
+   * Get unread emails
+   */
+  async getUnread(accountId) {
+    const where = { isRead: false };
+    if (accountId) {
+      where.accountId = accountId;
+    }
+    return await this.list({ where });
+  }
+  /**
+   * Get flagged emails
+   */
+  async getFlagged(accountId) {
+    const where = { isFlagged: true };
+    if (accountId) {
+      where.accountId = accountId;
+    }
+    return await this.list({ where });
+  }
+  /**
+   * Get emails with attachments
+   */
+  async getWithAttachments(accountId) {
+    const where = { hasAttachments: true };
+    if (accountId) {
+      where.accountId = accountId;
+    }
+    return await this.list({ where });
+  }
+  /**
+   * Get recent emails
+   */
+  async getRecent(limit = 20, accountId) {
+    const allEmails = await this.list({
+      where: accountId ? { accountId } : void 0
+    });
+    return allEmails.sort((a, b) => {
+      const dateA = a.date?.getTime() || 0;
+      const dateB = b.date?.getTime() || 0;
+      return dateB - dateA;
+    }).slice(0, limit);
+  }
+  /**
+   * Count emails in a folder
+   */
+  async countByFolder(folderId) {
+    const emails = await this.list({ where: { folderId } });
+    return emails.length;
+  }
+  /**
+   * Count unread emails in a folder
+   */
+  async countUnreadByFolder(folderId) {
+    const emails = await this.list({ where: { folderId, isRead: false } });
+    return emails.length;
+  }
+  /**
+   * Count unread emails for an account
+   */
+  async countUnreadByAccount(accountId) {
+    const emails = await this.list({ where: { accountId, isRead: false } });
+    return emails.length;
+  }
+  /**
+   * Search emails with email-specific filters.
+   * Alias: `search()` for backward compatibility.
+   */
+  async search(query, filters) {
+    return this.searchEmails(query, filters);
+  }
+  /**
+   * Search emails with email-specific filters
+   */
+  async searchEmails(query, filters) {
+    let emails = await this.list({});
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      emails = emails.filter(
+        (e) => e.subject?.toLowerCase().includes(lowerQuery) || e.textBody?.toLowerCase().includes(lowerQuery) || e.fromAddress?.toLowerCase().includes(lowerQuery) || e.fromName?.toLowerCase().includes(lowerQuery)
+      );
+    }
+    if (filters) {
+      if (filters.accountId) {
+        emails = emails.filter((e) => e.accountId === filters.accountId);
+      }
+      if (filters.folderId) {
+        emails = emails.filter((e) => e.folderId === filters.folderId);
+      }
+      if (filters.threadId) {
+        emails = emails.filter((e) => e.threadId === filters.threadId);
+      }
+      if (filters.from) {
+        const fromLower = filters.from.toLowerCase();
+        emails = emails.filter(
+          (e) => e.fromAddress?.toLowerCase().includes(fromLower) || e.fromName?.toLowerCase().includes(fromLower)
+        );
+      }
+      if (filters.to) {
+        const toLower = filters.to.toLowerCase();
+        emails = emails.filter(
+          (e) => e.toAddresses?.toLowerCase().includes(toLower)
+        );
+      }
+      if (filters.subject) {
+        const subjectLower = filters.subject.toLowerCase();
+        emails = emails.filter(
+          (e) => e.subject?.toLowerCase().includes(subjectLower)
+        );
+      }
+      if (filters.isRead !== void 0) {
+        emails = emails.filter((e) => e.isRead === filters.isRead);
+      }
+      if (filters.isFlagged !== void 0) {
+        emails = emails.filter((e) => e.isFlagged === filters.isFlagged);
+      }
+      if (filters.hasAttachments !== void 0) {
+        emails = emails.filter(
+          (e) => e.hasAttachments === filters.hasAttachments
+        );
+      }
+      if (filters.sincDate) {
+        emails = emails.filter(
+          (e) => e.date && e.date >= filters.sincDate
+        );
+      }
+      if (filters.beforeDate) {
+        emails = emails.filter(
+          (e) => e.date && e.date < filters.beforeDate
+        );
+      }
+    }
+    return emails;
+  }
+  /**
+   * Mark all emails in a folder as read
+   */
+  async markFolderRead(folderId) {
+    const emails = await this.getUnread();
+    const folderEmails = emails.filter((e) => e.folderId === folderId);
+    for (const email of folderEmails) {
+      await email.markRead();
+    }
+  }
+  /**
+   * Delete emails by folder
+   */
+  async deleteByFolder(folderId) {
+    const emails = await this.getByFolder(folderId);
+    let count = 0;
+    for (const email of emails) {
+      await email.delete();
+      count++;
+    }
+    return count;
+  }
+  /**
+   * Get email statistics for an account
+   */
+  async getAccountStats(accountId) {
+    const emails = await this.getByAccount(accountId);
+    return {
+      total: emails.length,
+      unread: emails.filter((e) => !e.isRead).length,
+      flagged: emails.filter((e) => e.isFlagged).length,
+      withAttachments: emails.filter((e) => e.hasAttachments).length,
+      byType: { Email: emails.length }
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Tenant Helper Methods
+  // ─────────────────────────────────────────────────────────────────────────
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const EmailCollection$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  EmailCollection
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
+var __decorateClass$6 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+let EmailFolder = class extends SmrtObject {
+  tenantId = null;
+  accountId = "";
+  name = "";
+  path = "";
+  delimiter = "/";
+  specialUse = "";
+  // '\\Inbox', '\\Sent', '\\Drafts', etc.
+  messageCount = 0;
+  unreadCount = 0;
+  subscribed = true;
+  // Timestamps
+  createdAt = /* @__PURE__ */ new Date();
+  updatedAt = /* @__PURE__ */ new Date();
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.accountId !== void 0) this.accountId = options.accountId;
+    if (options.name !== void 0) this.name = options.name;
+    if (options.path !== void 0) this.path = options.path;
+    if (options.delimiter !== void 0) this.delimiter = options.delimiter;
+    if (options.specialUse !== void 0) this.specialUse = options.specialUse;
+    if (options.messageCount !== void 0)
+      this.messageCount = options.messageCount;
+    if (options.unreadCount !== void 0)
+      this.unreadCount = options.unreadCount;
+    if (options.subscribed !== void 0) this.subscribed = options.subscribed;
+    if (options.createdAt) this.createdAt = options.createdAt;
+    if (options.updatedAt) this.updatedAt = options.updatedAt;
+  }
+  /**
+   * Get the email account
+   */
+  async getAccount() {
+    if (!this.accountId) return null;
+    const { EmailAccountCollection: EmailAccountCollection2 } = await Promise.resolve().then(() => EmailAccountCollection$1);
+    const collection = await EmailAccountCollection2.create(
+      this.options
+    );
+    return await collection.get({ id: this.accountId });
+  }
+  /**
+   * Get all emails in this folder
+   */
+  async getEmails(limit) {
+    const { EmailCollection: EmailCollection2 } = await Promise.resolve().then(() => EmailCollection$1);
+    const collection = await EmailCollection2.create(this.options);
+    const options = { where: { folderId: this.id } };
+    if (limit) {
+      options.limit = limit;
+    }
+    return await collection.list(options);
+  }
+  /**
+   * Get unread emails in this folder
+   */
+  async getUnreadEmails(limit) {
+    const { EmailCollection: EmailCollection2 } = await Promise.resolve().then(() => EmailCollection$1);
+    const collection = await EmailCollection2.create(this.options);
+    const options = {
+      where: { folderId: this.id, isRead: false }
+    };
+    if (limit) {
+      options.limit = limit;
+    }
+    return await collection.list(options);
+  }
+  /**
+   * Update message counts from database
+   */
+  async refreshCounts() {
+    const { EmailCollection: EmailCollection2 } = await Promise.resolve().then(() => EmailCollection$1);
+    const collection = await EmailCollection2.create(this.options);
+    this.messageCount = await collection.countByFolder(this.id);
+    this.unreadCount = await collection.countUnreadByFolder(this.id);
+    this.updatedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+  /**
+   * Check if this is the inbox folder
+   */
+  isInbox() {
+    return this.specialUse === "\\Inbox" || this.path.toLowerCase() === "inbox";
+  }
+  /**
+   * Check if this is the sent folder
+   */
+  isSent() {
+    return this.specialUse === "\\Sent" || this.path.toLowerCase() === "sent";
+  }
+  /**
+   * Check if this is the drafts folder
+   */
+  isDrafts() {
+    return this.specialUse === "\\Drafts" || this.path.toLowerCase() === "drafts";
+  }
+  /**
+   * Check if this is the trash folder
+   */
+  isTrash() {
+    return this.specialUse === "\\Trash" || this.path.toLowerCase() === "trash";
+  }
+  /**
+   * Check if this is the spam/junk folder
+   */
+  isSpam() {
+    return this.specialUse === "\\Junk" || this.path.toLowerCase() === "spam" || this.path.toLowerCase() === "junk";
+  }
+  /**
+   * Check if this is a system folder
+   */
+  isSystemFolder() {
+    return !!this.specialUse;
+  }
+  /**
+   * Subscribe to folder
+   */
+  async subscribe() {
+    this.subscribed = true;
+    this.updatedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+  /**
+   * Unsubscribe from folder
+   */
+  async unsubscribe() {
+    this.subscribed = false;
+    this.updatedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+};
+__decorateClass$6([
+  tenantId({ nullable: true })
+], EmailFolder.prototype, "tenantId", 2);
+__decorateClass$6([
+  foreignKey("Account")
+], EmailFolder.prototype, "accountId", 2);
+EmailFolder = __decorateClass$6([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], EmailFolder);
+const EmailFolder$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  get EmailFolder() {
+    return EmailFolder;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+class EmailFolderCollection extends SmrtCollection {
+  static _itemClass = EmailFolder;
+  /**
+   * Get folder by path for an account
+   */
+  async getByPath(accountId, path) {
+    const folders = await this.list({ where: { accountId, path } });
+    return folders[0] || null;
+  }
+  /**
+   * Get folders by account
+   */
+  async getByAccount(accountId) {
+    return await this.list({ where: { accountId } });
+  }
+  /**
+   * Get inbox folder for an account
+   */
+  async getInbox(accountId) {
+    const folders = await this.getByAccount(accountId);
+    return folders.find((f) => f.isInbox()) || null;
+  }
+  /**
+   * Get sent folder for an account
+   */
+  async getSent(accountId) {
+    const folders = await this.getByAccount(accountId);
+    return folders.find((f) => f.isSent()) || null;
+  }
+  /**
+   * Get drafts folder for an account
+   */
+  async getDrafts(accountId) {
+    const folders = await this.getByAccount(accountId);
+    return folders.find((f) => f.isDrafts()) || null;
+  }
+  /**
+   * Get trash folder for an account
+   */
+  async getTrash(accountId) {
+    const folders = await this.getByAccount(accountId);
+    return folders.find((f) => f.isTrash()) || null;
+  }
+  /**
+   * Get spam folder for an account
+   */
+  async getSpam(accountId) {
+    const folders = await this.getByAccount(accountId);
+    return folders.find((f) => f.isSpam()) || null;
+  }
+  /**
+   * Get system folders for an account
+   */
+  async getSystemFolders(accountId) {
+    const folders = await this.getByAccount(accountId);
+    return folders.filter((f) => f.isSystemFolder());
+  }
+  /**
+   * Get user-created folders for an account
+   */
+  async getUserFolders(accountId) {
+    const folders = await this.getByAccount(accountId);
+    return folders.filter((f) => !f.isSystemFolder());
+  }
+  /**
+   * Get subscribed folders
+   */
+  async getSubscribed(accountId) {
+    const where = { subscribed: true };
+    if (accountId) {
+      where.accountId = accountId;
+    }
+    return await this.list({ where });
+  }
+  /**
+   * Get folders with unread messages
+   */
+  async getWithUnread(accountId) {
+    const folders = accountId ? await this.getByAccount(accountId) : await this.list({});
+    return folders.filter((f) => f.unreadCount > 0);
+  }
+  /**
+   * Search folders with filters
+   */
+  async search(query, filters) {
+    let folders = await this.list({});
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      folders = folders.filter(
+        (f) => f.name?.toLowerCase().includes(lowerQuery) || f.path?.toLowerCase().includes(lowerQuery)
+      );
+    }
+    if (filters) {
+      if (filters.accountId) {
+        folders = folders.filter((f) => f.accountId === filters.accountId);
+      }
+      if (filters.specialUse) {
+        folders = folders.filter((f) => f.specialUse === filters.specialUse);
+      }
+      if (filters.subscribed !== void 0) {
+        folders = folders.filter((f) => f.subscribed === filters.subscribed);
+      }
+    }
+    return folders;
+  }
+  /**
+   * Refresh counts for all folders in an account
+   */
+  async refreshAllCounts(accountId) {
+    const folders = await this.getByAccount(accountId);
+    for (const folder of folders) {
+      await folder.refreshCounts();
+    }
+  }
+  /**
+   * Get folder statistics for an account
+   */
+  async getAccountStats(accountId) {
+    const folders = await this.getByAccount(accountId);
+    return {
+      totalFolders: folders.length,
+      totalMessages: folders.reduce((sum, f) => sum + f.messageCount, 0),
+      totalUnread: folders.reduce((sum, f) => sum + f.unreadCount, 0),
+      systemFolders: folders.filter((f) => f.isSystemFolder()).length,
+      userFolders: folders.filter((f) => !f.isSystemFolder()).length
+    };
+  }
+  /**
+   * Create standard system folders for an account
+   */
+  async createSystemFolders(accountId) {
+    const standardFolders = [
+      { name: "INBOX", path: "INBOX", specialUse: "\\Inbox" },
+      { name: "Sent", path: "Sent", specialUse: "\\Sent" },
+      { name: "Drafts", path: "Drafts", specialUse: "\\Drafts" },
+      { name: "Trash", path: "Trash", specialUse: "\\Trash" },
+      { name: "Spam", path: "Spam", specialUse: "\\Junk" }
+    ];
+    for (const folderData of standardFolders) {
+      const existing = await this.getByPath(accountId, folderData.path);
+      if (!existing) {
+        const folder = await this.create({
+          accountId,
+          ...folderData
+        });
+        await folder.save();
+      }
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Tenant Helper Methods
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Find all email folders belonging to a specific tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find all global email folders (no tenant)
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find email folders for a tenant including global folders
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const EmailFolderCollection$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  EmailFolderCollection
+}, Symbol.toStringTag, { value: "Module" }));
+var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+var __decorateClass$5 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let Blacklist = class extends SmrtObject {
+  pattern = "";
+  type = "email";
+  reason = "";
+  autoArchive = true;
+  constructor(options = {}) {
+    super(options);
+    if (options.pattern !== void 0) {
+      this.pattern = options.pattern;
+    }
+    if (options.type !== void 0) {
+      this.type = options.type;
+    }
+  }
+  /**
+   * Check if an email address matches this blacklist entry
+   */
+  matches(email) {
+    const normalizedEmail = email.toLowerCase().trim();
+    switch (this.type) {
+      case "email":
+        return normalizedEmail === this.pattern.toLowerCase().trim();
+      case "domain": {
+        const domain = normalizedEmail.split("@")[1];
+        return domain === this.pattern.toLowerCase().trim();
+      }
+      case "regex": {
+        const pattern = this.pattern.trim();
+        if (!pattern) {
+          return false;
+        }
+        try {
+          const regex = new RegExp(pattern, "i");
+          return regex.test(normalizedEmail);
+        } catch {
+          return false;
+        }
+      }
+      default:
+        return false;
+    }
+  }
+};
+Blacklist = __decorateClass$5([
+  smrt({
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    cli: true,
+    tenantScoped: true
+  })
+], Blacklist);
+class BlacklistCollection extends SmrtCollection {
+  static _itemClass = Blacklist;
+  /**
+   * Check if an email is blacklisted
+   */
+  async isBlacklisted(email) {
+    const entries = await this.list({});
+    for (const entry of entries) {
+      if (entry.matches(email)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get the matching blacklist entry for an email
+   */
+  async getMatchingEntry(email) {
+    const entries = await this.list({});
+    for (const entry of entries) {
+      if (entry.matches(email)) {
+        return entry;
+      }
+    }
+    return null;
+  }
+}
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let Whitelist = class extends SmrtObject {
+  pattern = "";
+  type = "email";
+  category = null;
+  description = "";
+  constructor(options = {}) {
+    super(options);
+    if (options.pattern !== void 0) {
+      this.pattern = options.pattern;
+    }
+    if (options.type !== void 0) {
+      this.type = options.type;
+    }
+  }
+  /**
+   * Check if an email address matches this whitelist entry
+   */
+  matches(email) {
+    const normalizedEmail = email.toLowerCase().trim();
+    switch (this.type) {
+      case "email":
+        return normalizedEmail === this.pattern.toLowerCase().trim();
+      case "domain": {
+        const domain = normalizedEmail.split("@")[1];
+        return domain === this.pattern.toLowerCase().trim();
+      }
+      case "regex": {
+        const pattern = this.pattern.trim();
+        if (!pattern) {
+          return false;
+        }
+        try {
+          const regex = new RegExp(pattern, "i");
+          return regex.test(normalizedEmail);
+        } catch {
+          return false;
+        }
+      }
+      default:
+        return false;
+    }
+  }
+};
+Whitelist = __decorateClass$4([
+  smrt({
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    cli: true,
+    tenantScoped: true
+  })
+], Whitelist);
+class WhitelistCollection extends SmrtCollection {
+  static _itemClass = Whitelist;
+  /**
+   * Check if an email is whitelisted for a specific category
+   */
+  async isWhitelisted(email, category) {
+    const entries = await this.list({});
+    for (const entry of entries) {
+      if (!entry.matches(email)) {
+        continue;
+      }
+      if (!category) {
+        return true;
+      }
+      if (entry.category === category || entry.category === null) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get the matching whitelist entry for an email
+   */
+  async getMatchingEntry(email) {
+    const entries = await this.list({});
+    for (const entry of entries) {
+      if (entry.matches(email)) {
+        return entry;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get whitelist entries by category
+   */
+  async getByCategory(category) {
+    return await this.list({
+      where: { category }
+    });
+  }
+}
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let SlackAccount = class extends Account {
+  workspaceId = "";
+  workspaceName = "";
+  botUserId = "";
+  constructor(options = {}) {
+    super(options);
+    if (options.workspaceId !== void 0)
+      this.workspaceId = options.workspaceId;
+    if (options.workspaceName !== void 0)
+      this.workspaceName = options.workspaceName;
+    if (options.botUserId !== void 0) this.botUserId = options.botUserId;
+    if (!this.providerType) this.providerType = "slack";
+  }
+  /**
+   * Create a sender for this Slack account
+   */
+  async createSender() {
+    const { SlackSender: SlackSender2 } = await Promise.resolve().then(() => SlackSender$1);
+    return new SlackSender2(this);
+  }
+};
+SlackAccount = __decorateClass$3([
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], SlackAccount);
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let SlackMessage = class extends Message {
+  channelId = "";
+  channelName = "";
+  slackTs = "";
+  // Slack message timestamp (unique ID)
+  slackThreadTs = "";
+  // Thread parent timestamp
+  reactions = "";
+  // JSON array of {name, count, users[]}
+  isEdited = false;
+  messageType = "";
+  // 'message', 'bot_message', etc.
+  blocks = "";
+  // JSON - Slack Block Kit blocks
+  constructor(options = {}) {
+    super(options);
+    if (options.channelId !== void 0) this.channelId = options.channelId;
+    if (options.channelName !== void 0)
+      this.channelName = options.channelName;
+    if (options.slackTs !== void 0) this.slackTs = options.slackTs;
+    if (options.slackThreadTs !== void 0)
+      this.slackThreadTs = options.slackThreadTs;
+    if (options.reactions !== void 0) this.reactions = options.reactions;
+    if (options.isEdited !== void 0) this.isEdited = options.isEdited;
+    if (options.messageType !== void 0)
+      this.messageType = options.messageType;
+    if (options.blocks !== void 0) this.blocks = options.blocks;
+  }
+  /**
+   * Get reactions as parsed array
+   */
+  getReactions() {
+    if (!this.reactions) return [];
+    try {
+      return JSON.parse(this.reactions);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get blocks as parsed array
+   */
+  getBlocks() {
+    if (!this.blocks) return [];
+    try {
+      return JSON.parse(this.blocks);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Check if message is in a thread
+   */
+  isInThread() {
+    return !!this.slackThreadTs && this.slackThreadTs !== this.slackTs;
+  }
+  /**
+   * Get total reaction count
+   */
+  getTotalReactions() {
+    return this.getReactions().reduce((sum, r) => sum + r.count, 0);
+  }
+};
+SlackMessage = __decorateClass$2([
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], SlackMessage);
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let Tweet = class extends Message {
+  tweetId = "";
+  retweetCount = 0;
+  likeCount = 0;
+  replyCount = 0;
+  isRetweet = false;
+  isReply = false;
+  mediaUrls = "";
+  // JSON array
+  hashtags = "";
+  // JSON array
+  mentions = "";
+  // JSON array
+  constructor(options = {}) {
+    super(options);
+    if (options.tweetId !== void 0) this.tweetId = options.tweetId;
+    if (options.retweetCount !== void 0)
+      this.retweetCount = options.retweetCount;
+    if (options.likeCount !== void 0) this.likeCount = options.likeCount;
+    if (options.replyCount !== void 0) this.replyCount = options.replyCount;
+    if (options.isRetweet !== void 0) this.isRetweet = options.isRetweet;
+    if (options.isReply !== void 0) this.isReply = options.isReply;
+    if (options.mediaUrls !== void 0) this.mediaUrls = options.mediaUrls;
+    if (options.hashtags !== void 0) this.hashtags = options.hashtags;
+    if (options.mentions !== void 0) this.mentions = options.mentions;
+  }
+  /**
+   * Get media URLs as parsed array
+   */
+  getMediaUrls() {
+    if (!this.mediaUrls) return [];
+    try {
+      return JSON.parse(this.mediaUrls);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get hashtags as parsed array
+   */
+  getHashtags() {
+    if (!this.hashtags) return [];
+    try {
+      return JSON.parse(this.hashtags);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get mentions as parsed array
+   */
+  getMentions() {
+    if (!this.mentions) return [];
+    try {
+      return JSON.parse(this.mentions);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get total engagement count
+   */
+  getEngagement() {
+    return this.retweetCount + this.likeCount + this.replyCount;
+  }
+};
+Tweet = __decorateClass$1([
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], Tweet);
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let TwitterAccount = class extends Account {
+  handle = "";
+  twitterUserId = "";
+  constructor(options = {}) {
+    super(options);
+    if (options.handle !== void 0) this.handle = options.handle;
+    if (options.twitterUserId !== void 0)
+      this.twitterUserId = options.twitterUserId;
+    if (!this.providerType) this.providerType = "twitter";
+  }
+  /**
+   * Create a sender for this Twitter account
+   */
+  async createSender() {
+    const { TweetSender: TweetSender2 } = await Promise.resolve().then(() => TweetSender$1);
+    return new TweetSender2(this);
+  }
+};
+TwitterAccount = __decorateClass([
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], TwitterAccount);
+class EmailSender {
+  providerType = "email";
+  client;
+  account;
+  constructor(client, account) {
+    this.client = client;
+    this.account = account;
+  }
+  isReady() {
+    return this.client.isConnected();
+  }
+  async send(message, _options) {
+    const toAddresses = message.getToAddresses();
+    const ccAddresses = message.getCcAddresses();
+    const bccAddresses = message.getBccAddresses();
+    const emailMessage = {
+      from: {
+        name: message.fromName || this.account.name,
+        address: message.fromAddress || this.account.email
+      },
+      to: toAddresses.map((r) => ({
+        name: r.name,
+        address: r.address
+      })),
+      cc: ccAddresses.length > 0 ? ccAddresses.map((r) => ({ name: r.name, address: r.address })) : void 0,
+      bcc: bccAddresses.length > 0 ? bccAddresses.map((r) => ({ name: r.name, address: r.address })) : void 0,
+      subject: message.subject,
+      text: message.textBody || message.body,
+      html: message.htmlBody || void 0,
+      inReplyTo: message.inReplyTo || void 0
+    };
+    try {
+      const result = await this.client.send(emailMessage);
+      return {
+        success: true,
+        providerMessageId: result.messageId,
+        accepted: result.accepted,
+        rejected: result.rejected,
+        providerResponse: { response: result.response },
+        sentAt: /* @__PURE__ */ new Date()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        sentAt: /* @__PURE__ */ new Date()
+      };
+    }
+  }
+}
+const EmailSender$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  EmailSender
+}, Symbol.toStringTag, { value: "Module" }));
+class SlackSender {
+  providerType = "slack";
+  account;
+  constructor(account) {
+    this.account = account;
+  }
+  isReady() {
+    return this.account.isActive;
+  }
+  async send(message, _options) {
+    const { getMessageClient } = await import("@happyvertical/messages");
+    const credentials = await this.account.getCredentials();
+    if (!credentials?.botToken) {
+      return {
+        success: false,
+        error: "No botToken found in account credentials",
+        sentAt: /* @__PURE__ */ new Date()
+      };
+    }
+    const client = await getMessageClient({
+      type: "slack",
+      botToken: credentials.botToken
+    });
+    try {
+      await client.connect();
+      const result = await client.send(
+        {
+          from: { id: this.account.botUserId, name: this.account.name },
+          channelId: message.channelId,
+          content: message.body
+        },
+        {
+          replyTo: message.slackThreadTs || void 0
+        }
+      );
+      await client.disconnect();
+      return {
+        success: result.success,
+        providerMessageId: result.messageId,
+        providerResponse: result.providerResponse,
+        sentAt: result.timestamp
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        sentAt: /* @__PURE__ */ new Date()
+      };
+    }
+  }
+}
+const SlackSender$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  SlackSender
+}, Symbol.toStringTag, { value: "Module" }));
+class TweetSender {
+  providerType = "twitter";
+  account;
+  constructor(account) {
+    this.account = account;
+  }
+  isReady() {
+    return this.account.isActive;
+  }
+  async send(message, _options) {
+    const { getMessageClient } = await import("@happyvertical/messages");
+    const credentials = await this.account.getCredentials();
+    if (!credentials?.apiKey || !credentials?.apiSecret || !credentials?.accessToken || !credentials?.accessSecret) {
+      return {
+        success: false,
+        error: "Missing Twitter API credentials in account",
+        sentAt: /* @__PURE__ */ new Date()
+      };
+    }
+    const client = await getMessageClient({
+      type: "twitter",
+      apiKey: credentials.apiKey,
+      apiSecret: credentials.apiSecret,
+      accessToken: credentials.accessToken,
+      accessSecret: credentials.accessSecret
+    });
+    try {
+      const sendOptions = {};
+      if (message.isReply && message.inReplyToMessageId) {
+        sendOptions.replyTo = message.inReplyToMessageId;
+      }
+      const result = await client.send(
+        {
+          from: { id: this.account.twitterUserId, name: this.account.handle },
+          content: message.body
+        },
+        sendOptions.replyTo ? { replyTo: sendOptions.replyTo } : void 0
+      );
+      return {
+        success: result.success,
+        providerMessageId: result.messageId,
+        providerResponse: result.providerResponse,
+        sentAt: result.timestamp
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        sentAt: /* @__PURE__ */ new Date()
+      };
+    }
+  }
+}
+const TweetSender$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  TweetSender
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Account,
+  AccountCollection,
+  Attachment,
+  AttachmentCollection,
+  Blacklist,
+  BlacklistCollection,
+  Email,
+  EmailAccount,
+  EmailAccountCollection,
+  EmailAttachment,
+  EmailAttachmentCollection,
+  EmailCollection,
+  EmailFolder,
+  EmailFolderCollection,
+  EmailSender,
+  Message,
+  MessageCollection,
+  SlackAccount,
+  SlackMessage,
+  SlackSender,
+  Tweet,
+  TweetSender,
+  TwitterAccount,
+  Whitelist,
+  WhitelistCollection
+};
+//# sourceMappingURL=index.js.map