Scheduld Send

lib/__tests__/jmap-send-threading.test.ts

@@ -11,6 +11,26 @@ function createClient(): JMAPClient {
   return client;
 }
 
+function enableDelayedSend(client: JMAPClient) {
+  Object.assign(client, {
+    capabilities: {
+      'urn:ietf:params:jmap:core': {},
+      'urn:ietf:params:jmap:mail': {},
+      'urn:ietf:params:jmap:submission': {},
+    },
+    session: {
+      accounts: {
+        'account-1': {
+          accountCapabilities: {
+            'urn:ietf:params:jmap:mail': {},
+            'urn:ietf:params:jmap:submission': { maxDelayedSend: 3600 },
+          },
+        },
+      },
+    },
+  });
+}
+
 interface JMAPMethodCall {
   0: string;
   1: Record<string, unknown>;
@@ -148,4 +168,55 @@ describe('JMAPClient.sendEmail threading headers', () => {
     expect(draft.inReplyTo).toEqual(['real@example.com']);
     expect(draft.references).toBeUndefined();
   });
+
+  it('includes sendAt and submission capability for scheduled sends', async () => {
+    const client = createClient();
+    enableDelayedSend(client);
+    const captured = mockSendEmailFlow();
+    const sendAt = new Date(Date.now() + 60_000).toISOString();
+
+    const result = await client.sendEmail(
+      ['recipient@example.com'],
+      'Scheduled test',
+      'body',
+      undefined, undefined, 'identity-1', 'user@example.com',
+      undefined, undefined, undefined, undefined,
+      undefined,
+      undefined,
+      sendAt,
+    );
+
+    const identityRequest = captured[1];
+    expect(identityRequest.using).toContain('urn:ietf:params:jmap:submission');
+    const submissionCall = captured[2].methodCalls.find(call => call[0] === 'EmailSubmission/set');
+    expect(submissionCall?.[1].create).toEqual({ '1': { emailId: expect.stringMatching(/^#send-/), identityId: 'identity-1', sendAt } });
+    expect(result).toMatchObject({ scheduled: true, emailSubmissionId: 'sub-1', sendAt });
+  });
+
+  it('cleans up replacement submission if canceling the original fails during reschedule', async () => {
+    const client = createClient();
+    enableDelayedSend(client);
+    vi.spyOn(client, 'getMailboxes').mockResolvedValue([
+      { id: 'mb-drafts', name: 'Drafts', role: 'drafts' },
+      { id: 'mb-sent', name: 'Sent', role: 'sent' },
+    ] as never);
+    const requestSpy = vi.spyOn(client as unknown as { request: JMAPClient['request'] }, 'request')
+      .mockImplementation(async (methodCalls) => {
+        const args = methodCalls[0][1] as { create?: unknown; update?: Record<string, unknown> };
+        if (args.create) {
+          return { methodResponses: [['EmailSubmission/set', { created: { replacement: { id: 'sub-new' } } }, '0']] };
+        }
+        if (args.update?.['sub-old']) {
+          return { methodResponses: [['EmailSubmission/set', { notUpdated: { 'sub-old': { type: 'cannotUnsend' } } }, '0']] };
+        }
+        return { methodResponses: [['EmailSubmission/set', { updated: { 'sub-new': null } }, '0']] };
+      });
+
+    await expect(client.rescheduleEmailSubmission('sub-old', 'email-1', 'identity-1', new Date(Date.now() + 60_000).toISOString()))
+      .rejects.toThrow('could not cancel the original');
+
+    expect(requestSpy).toHaveBeenCalledWith(expect.arrayContaining([
+      expect.arrayContaining(['EmailSubmission/set', expect.objectContaining({ update: { 'sub-new': { undoStatus: 'canceled' } } })]),
+    ]));
+  });
 });

lib/demo/demo-client.ts

@@ -1,5 +1,5 @@
 import type { IJMAPClient } from '@/lib/jmap/client-interface';
-import type { Email, Mailbox, StateChange, AccountStates, Thread, Identity, EmailAddress, ContactCard, AddressBook, VacationResponse, Calendar, CalendarEvent, CalendarEventFilter, CalendarTask, FileNode } from '@/lib/jmap/types';
+import type { Email, Mailbox, StateChange, AccountStates, Thread, Identity, EmailAddress, ContactCard, AddressBook, VacationResponse, Calendar, CalendarEvent, CalendarEventFilter, CalendarTask, FileNode, ScheduledEmail, SendEmailResult } from '@/lib/jmap/types';
 import type { SieveScript, SieveCapabilities } from '@/lib/jmap/sieve-types';
 import { getDemoData, type DemoData } from './demo-data';
 import { generateDemoId } from './demo-utils';
@@ -11,6 +11,7 @@ import { generateDemoId } from './demo-utils';
 export class DemoJMAPClient implements IJMAPClient {
   private data: DemoData;
   private blobStore = new Map<string, Blob>();
+  private scheduledSubmissions = new Map<string, { id: string; emailId: string; identityId: string; sendAt: string; undoStatus: 'pending' | 'final' | 'canceled'; isSmime: boolean }>();
   private connectionCallback: ((connected: boolean) => void) | null = null;
   private stateChangeCallback: ((change: StateChange) => void) | null = null;
   private lastStates: AccountStates = {};
@@ -49,8 +50,8 @@ export class DemoJMAPClient implements IJMAPClient {
 
   // ── Capabilities ──────────────────────────────────────────────
 
-  hasAccountCapability(_capability: string, _accountId?: string): boolean {
-    return false;
+  hasAccountCapability(capability: string, _accountId?: string): boolean {
+    return capability === 'urn:ietf:params:jmap:submission';
   }
 
   getCapabilities(): Record<string, unknown> {
@@ -70,6 +71,8 @@ export class DemoJMAPClient implements IJMAPClient {
   getMaxSizeUpload(): number { return 50_000_000; }
   getMaxCallsInRequest(): number { return 16; }
   getMaxObjectsInGet(): number { return 500; }
+  getMaxDelayedSend(): number { return 30 * 24 * 60 * 60; }
+  hasDelayedSend(): boolean { return true; }
   getEventSourceUrl(): string | null { return null; }
   supportsEmailSubmission(): boolean { return true; }
   supportsQuota(): boolean { return true; }
@@ -289,6 +292,8 @@ export class DemoJMAPClient implements IJMAPClient {
     emails: Array<{ id: string; receivedAt: string }>,
     archiveMailboxId: string,
     mode: 'single' | 'year' | 'month',
+    _existingMailboxes: Mailbox[],
+    _accountId?: string,
   ): Promise<void> {
     if (emails.length === 0) return;
     if (mode === 'single') {
@@ -449,7 +454,8 @@ export class DemoJMAPClient implements IJMAPClient {
     attachments?: Array<{ blobId: string; name: string; type: string; size: number; disposition?: 'attachment' | 'inline'; cid?: string }>,
     inReplyTo?: string[],
     references?: string[],
-  ): Promise<void> {
+    sendAt?: string,
+  ): Promise<SendEmailResult> {
     // Remove draft if updating
     if (draftId) {
       this.data.emails = this.data.emails.filter(e => e.id !== draftId);
@@ -457,8 +463,8 @@ export class DemoJMAPClient implements IJMAPClient {
     const sentMb = this.data.mailboxes.find(m => m.role === 'sent');
     const email: Email = {
       id: generateDemoId('email'), threadId: generateDemoId('thread'),
-      mailboxIds: { [sentMb?.id || 'demo-mailbox-sent']: true },
-      keywords: { $seen: true },
+      mailboxIds: { [sendAt ? (this.data.mailboxes.find(m => m.role === 'drafts')?.id || 'demo-mailbox-drafts') : (sentMb?.id || 'demo-mailbox-sent')]: true },
+      keywords: sendAt ? { $seen: true, $draft: true } : { $seen: true },
       size: body.length + (htmlBody?.length || 0),
       receivedAt: new Date().toISOString(),
       from: [{ name: 'Demo User', email: 'demo@example.com' }],
@@ -478,7 +484,22 @@ export class DemoJMAPClient implements IJMAPClient {
       references: references?.length ? references : undefined,
     };
     this.data.emails.push(email);
+    let emailSubmissionId: string | undefined;
+    if (sendAt) {
+      emailSubmissionId = generateDemoId('submission');
+      this.scheduledSubmissions.set(emailSubmissionId, {
+        id: emailSubmissionId,
+        emailId: email.id,
+        identityId: _identityId || 'demo-identity',
+        sendAt,
+        undoStatus: 'pending',
+        isSmime: false,
+      });
+    }
     this.recalcMailboxCounts();
+    return sendAt
+      ? { scheduled: true, emailId: email.id, emailSubmissionId, sendAt }
+      : { scheduled: false, emailId: email.id };
   }
 
   async sendImipReply(): Promise<void> { /* no-op in demo */ }
@@ -898,7 +919,74 @@ export class DemoJMAPClient implements IJMAPClient {
 
   async importRawEmail(): Promise<string> { return generateDemoId('email'); }
   async submitEmail(): Promise<void> { /* no-op */ }
-  async sendRawEmail(): Promise<void> { /* no-op */ }
+  async sendRawEmail(_blob?: Blob, identityId = 'demo-identity', _sentMailboxId?: string, _draftMailboxId?: string, sendAt?: string): Promise<SendEmailResult> {
+    const emailId = generateDemoId('email');
+    const draftsMailbox = this.data.mailboxes.find(m => m.role === 'drafts');
+    const sentMailbox = this.data.mailboxes.find(m => m.role === 'sent');
+    const email: Email = {
+      id: emailId,
+      threadId: generateDemoId('thread'),
+      mailboxIds: { [(sendAt ? draftsMailbox?.id : sentMailbox?.id) || 'demo-mailbox-sent']: true },
+      keywords: sendAt ? { $seen: true, $draft: true } : { $seen: true },
+      size: 1024,
+      receivedAt: new Date().toISOString(),
+      from: [{ name: 'Demo User', email: 'demo@example.com' }],
+      to: [],
+      subject: 'S/MIME message',
+      preview: 'Signed/encrypted demo message',
+      hasAttachment: false,
+    };
+    this.data.emails.push(email);
+    let emailSubmissionId: string | undefined;
+    if (sendAt) {
+      emailSubmissionId = generateDemoId('submission');
+      this.scheduledSubmissions.set(emailSubmissionId, { id: emailSubmissionId, emailId, identityId, sendAt, undoStatus: 'pending', isSmime: true });
+    }
+    this.recalcMailboxCounts();
+    return sendAt ? { scheduled: true, emailId, emailSubmissionId, sendAt, isSmime: true } : { scheduled: false, emailId, isSmime: true };
+  }
+
+  async getScheduledEmails(limit = 50, position = 0): Promise<{ emails: ScheduledEmail[]; hasMore: boolean; total: number }> {
+    const pending = Array.from(this.scheduledSubmissions.values())
+      .filter(s => s.undoStatus === 'pending')
+      .sort((a, b) => new Date(a.sendAt).getTime() - new Date(b.sendAt).getTime());
+    const page = pending.slice(position, position + limit);
+    const emails = page.map((submission) => {
+      const email = this.data.emails.find(e => e.id === submission.emailId);
+      if (!email) return null;
+      return {
+        ...email,
+        scheduledSendAt: submission.sendAt,
+        emailSubmissionId: submission.id,
+        scheduledIdentityId: submission.identityId,
+        scheduledUndoStatus: submission.undoStatus,
+        isScheduled: true,
+        isSmimeScheduled: submission.isSmime,
+      } satisfies ScheduledEmail;
+    }).filter((email): email is ScheduledEmail => email !== null);
+    return { emails, hasMore: position + emails.length < pending.length, total: pending.length };
+  }
+
+  async cancelEmailSubmission(submissionId: string): Promise<void> {
+    const submission = this.scheduledSubmissions.get(submissionId);
+    if (submission) submission.undoStatus = 'canceled';
+  }
+
+  async rescheduleEmailSubmission(submissionId: string, emailId: string, identityId: string, sendAt: string): Promise<SendEmailResult> {
+    await this.cancelEmailSubmission(submissionId);
+    const replacement = generateDemoId('submission');
+    this.scheduledSubmissions.set(replacement, { id: replacement, emailId, identityId, sendAt, undoStatus: 'pending', isSmime: false });
+    return { scheduled: true, emailId, emailSubmissionId: replacement, sendAt };
+  }
+
+  async restoreEmailToDraft(emailId: string, draftMailboxId: string, sentMailboxId?: string): Promise<void> {
+    const email = this.data.emails.find(e => e.id === emailId);
+    if (!email) return;
+    email.mailboxIds[draftMailboxId] = true;
+    if (sentMailboxId) delete email.mailboxIds[sentMailboxId];
+    email.keywords.$draft = true;
+    this.recalcMailboxCounts();
+  }
 
   // ── Internal helpers ──────────────────────────────────────────
 

lib/jmap/client-interface.ts

@@ -1,4 +1,4 @@
-import type { Email, Mailbox, StateChange, AccountStates, Thread, Identity, EmailAddress, ContactCard, AddressBook, AddressBookRights, VacationResponse, Calendar, CalendarRights, CalendarEvent, CalendarEventFilter, CalendarTask, FileNode, Principal, PushSubscription } from "./types";
+import type { Email, Mailbox, StateChange, AccountStates, Thread, Identity, EmailAddress, ContactCard, AddressBook, AddressBookRights, VacationResponse, Calendar, CalendarRights, CalendarEvent, CalendarEventFilter, CalendarTask, FileNode, Principal, PushSubscription, ScheduledEmail, SendEmailResult } from "./types";
 import type { SieveScript, SieveCapabilities } from "./sieve-types";
 
 /**
@@ -31,6 +31,8 @@ export interface IJMAPClient {
   getMaxSizeUpload(): number;
   getMaxCallsInRequest(): number;
   getMaxObjectsInGet(): number;
+  getMaxDelayedSend(accountId?: string): number;
+  hasDelayedSend(accountId?: string): boolean;
   getEventSourceUrl(): string | null;
   supportsEmailSubmission(): boolean;
   supportsQuota(): boolean;
@@ -146,7 +148,14 @@ export interface IJMAPClient {
     attachments?: Array<{ blobId: string; name: string; type: string; size: number; disposition?: 'attachment' | 'inline'; cid?: string }>,
     inReplyTo?: string[],
     references?: string[],
-  ): Promise<void>;
+    sendAt?: string,
+  ): Promise<SendEmailResult>;
+
+  sendRawEmail(blob: Blob, identityId: string, sentMailboxId: string, draftMailboxId?: string, sendAt?: string): Promise<SendEmailResult>;
+  getScheduledEmails(limit?: number, position?: number): Promise<{ emails: ScheduledEmail[]; hasMore: boolean; total: number }>;
+  cancelEmailSubmission(submissionId: string): Promise<void>;
+  rescheduleEmailSubmission(submissionId: string, emailId: string, identityId: string, sendAt: string): Promise<SendEmailResult>;
+  restoreEmailToDraft(emailId: string, draftMailboxId: string, sentMailboxId?: string): Promise<void>;
 
   sendImipReply(opts: {
     organizerEmail: string;
@@ -275,5 +284,4 @@ export interface IJMAPClient {
   // ── S/MIME raw-email helpers ──────────────────────────────────
   importRawEmail(blob: Blob, mailboxIds: Record<string, boolean>, keywords?: Record<string, boolean>): Promise<string>;
   submitEmail(emailId: string, identityId: string): Promise<void>;
-  sendRawEmail(blob: Blob, identityId: string, sentMailboxId: string, draftMailboxId?: string): Promise<void>;
 }

lib/jmap/client.ts

@@ -1,4 +1,4 @@
-import type { Email, Mailbox, StateChange, AccountStates, Thread, Identity, EmailAddress, ContactCard, AddressBook, AddressBookRights, VacationResponse, Calendar, CalendarRights, CalendarEvent, CalendarEventFilter, CalendarTask, FileNode, FileNodeFilter, Principal, PushSubscription } from "./types";
+import type { Email, Mailbox, StateChange, AccountStates, Thread, Identity, EmailAddress, ContactCard, AddressBook, AddressBookRights, VacationResponse, Calendar, CalendarRights, CalendarEvent, CalendarEventFilter, CalendarTask, FileNode, FileNodeFilter, Principal, PushSubscription, EmailSubmission, ScheduledEmail, SendEmailResult } from "./types";
 import type { SieveScript, SieveCapabilities } from "./sieve-types";
 import type { IJMAPClient } from "./client-interface";
 import { toWildcardQuery } from "./search-utils";
@@ -61,6 +61,12 @@ interface JMAPEmailHeader {
 
 type JMAPMethodCall = [string, Record<string, unknown>, string];
 
+const SUBMISSION_USING = [
+  'urn:ietf:params:jmap:core',
+  'urn:ietf:params:jmap:mail',
+  'urn:ietf:params:jmap:submission',
+] as const;
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type JMAPResponseResult = Record<string, any>;
 
@@ -275,6 +281,27 @@ function computeHasMore(position: number, emailCount: number, total: number, lim
   return emailCount === limit;
 }
 
+function hasSubmissionMethod(methodCalls: JMAPMethodCall[]): boolean {
+  return methodCalls.some(([method]) => method.startsWith('Identity/') || method.startsWith('EmailSubmission/'));
+}
+
+function isSmimeEmail(email: Email): boolean {
+  const types: string[] = [];
+  const collect = (part: Email['bodyStructure']): void => {
+    if (!part) return;
+    if (part.type) types.push(part.type.toLowerCase());
+    part.subParts?.forEach(collect);
+  };
+  collect(email.bodyStructure);
+  email.attachments?.forEach(att => types.push((att.type || '').toLowerCase()));
+  return types.some(type =>
+    type.includes('pkcs7') ||
+    type.includes('x-pkcs7') ||
+    type === 'application/pkcs7-mime' ||
+    type === 'application/pkcs7-signature'
+  );
+}
+
 /**
  * Fold a single iCalendar content line per RFC 5545 §3.1.
  * Lines longer than 75 octets MUST be split with CRLF + a single linear white space character.
@@ -666,7 +693,7 @@ export class JMAPClient implements IJMAPClient {
     }
 
     const requestBody = {
-      using: using || ["urn:ietf:params:jmap:core", "urn:ietf:params:jmap:mail"],
+      using: using || (hasSubmissionMethod(methodCalls) ? [...SUBMISSION_USING] : ["urn:ietf:params:jmap:core", "urn:ietf:params:jmap:mail"]),
       methodCalls,
     };
 
@@ -2054,8 +2081,10 @@ export class JMAPClient implements IJMAPClient {
     htmlBody?: string,
     attachments?: Array<{ blobId: string; name: string; type: string; size: number; disposition?: 'attachment' | 'inline'; cid?: string }>,
     inReplyTo?: string[],
-    references?: string[]
-  ): Promise<void> {
+    references?: string[],
+    sendAt?: string
+  ): Promise<SendEmailResult> {
+    if (sendAt) this.validateSendAt(sendAt);
     const emailId = `send-${Date.now()}`;
     const mailboxes = await this.getMailboxes();
     const sentMailbox = mailboxes.find(mb => mb.role === 'sent');
@@ -2162,7 +2191,7 @@ export class JMAPClient implements IJMAPClient {
       }, "1"]);
       methodCalls.push(["EmailSubmission/set", {
         accountId: this.accountId,
-        create: { "1": { emailId: `#${emailId}`, identityId: finalIdentityId } },
+        create: { "1": { emailId: `#${emailId}`, identityId: finalIdentityId, ...(sendAt ? { sendAt } : {}) } },
         onSuccessUpdateEmail,
       }, "2"]);
     } else {
@@ -2172,13 +2201,16 @@ export class JMAPClient implements IJMAPClient {
       }, "0"]);
       methodCalls.push(["EmailSubmission/set", {
         accountId: this.accountId,
-        create: { "1": { emailId: `#${emailId}`, identityId: finalIdentityId } },
+        create: { "1": { emailId: `#${emailId}`, identityId: finalIdentityId, ...(sendAt ? { sendAt } : {}) } },
         onSuccessUpdateEmail,
       }, "1"]);
     }
 
     const response = await this.request(methodCalls);
 
+    let createdEmailId: string | undefined;
+    let emailSubmissionId: string | undefined;
+
     if (response.methodResponses) {
       for (const [methodName, result] of response.methodResponses) {
         if (methodName.endsWith('/error')) {
@@ -2192,8 +2224,19 @@ export class JMAPClient implements IJMAPClient {
           console.error('Email send error:', firstError);
           throw new Error(firstError?.description || firstError?.type || 'Failed to send email');
         }
+
+        if (methodName === 'Email/set' && result.created?.[emailId]?.id) {
+          createdEmailId = result.created[emailId].id;
+        }
+        if (methodName === 'EmailSubmission/set' && result.created?.['1']?.id) {
+          emailSubmissionId = result.created['1'].id;
+        }
       }
     }
+
+    return sendAt
+      ? { scheduled: true, emailId: createdEmailId, emailSubmissionId, sendAt }
+      : { scheduled: false, emailId: createdEmailId, emailSubmissionId };
   }
 
   /**
@@ -2821,6 +2864,37 @@ export class JMAPClient implements IJMAPClient {
     return coreCapability?.maxObjectsInGet || 500;
   }
 
+  getMaxDelayedSend(accountId?: string): number {
+    const id = accountId || this.accountId;
+    const submissionCapability = this.session?.accounts?.[id]?.accountCapabilities?.["urn:ietf:params:jmap:submission"] as { maxDelayedSend?: number } | undefined;
+    return typeof submissionCapability?.maxDelayedSend === 'number' ? submissionCapability.maxDelayedSend : 0;
+  }
+
+  hasDelayedSend(accountId?: string): boolean {
+    const id = accountId || this.accountId;
+    return this.supportsEmailSubmission()
+      && this.hasAccountCapability('urn:ietf:params:jmap:submission', id)
+      && this.getMaxDelayedSend(id) > 0;
+  }
+
+  private validateSendAt(sendAt: string, accountId?: string): void {
+    const time = new Date(sendAt).getTime();
+    if (!Number.isFinite(time)) {
+      throw new Error('Scheduled send time is invalid');
+    }
+    const now = Date.now();
+    if (time <= now) {
+      throw new Error('Scheduled send time must be in the future');
+    }
+    const maxDelayedSend = this.getMaxDelayedSend(accountId);
+    if (!this.hasDelayedSend(accountId) || maxDelayedSend <= 0) {
+      throw new Error('Scheduled send is not supported for this account');
+    }
+    if (time > now + maxDelayedSend * 1000) {
+      throw new Error('Scheduled send time is later than the server allows');
+    }
+  }
+
   getEventSourceUrl(): string | null {
     if (!this.session) return null;
 
@@ -5287,7 +5361,9 @@ export class JMAPClient implements IJMAPClient {
     identityId: string,
     sentMailboxId: string,
     draftMailboxId?: string,
-  ): Promise<void> {
+    sendAt?: string,
+  ): Promise<SendEmailResult> {
+    if (sendAt) this.validateSendAt(sendAt);
     // Upload the raw message
     const file = new File([blob], 'message.eml', { type: 'message/rfc822' });
     const { blobId } = await this.uploadBlob(file);
@@ -5312,6 +5388,7 @@ export class JMAPClient implements IJMAPClient {
           'raw-submit': {
             emailId: '#raw-import',
             identityId,
+            ...(sendAt ? { sendAt } : {}),
           },
         },
         ...(draftMailboxId ? {
@@ -5327,6 +5404,8 @@ export class JMAPClient implements IJMAPClient {
     ];
 
     const response = await this.request(methodCalls);
+    let emailId: string | undefined;
+    let emailSubmissionId: string | undefined;
 
     // Check for errors
     for (const [methodName, result] of response.methodResponses ?? []) {
@@ -5338,6 +5417,167 @@ export class JMAPClient implements IJMAPClient {
         const firstErr = Object.values(r.notCreated)[0];
         throw new Error(firstErr?.description || firstErr?.type || 'Failed to send raw email');
       }
+      if (methodName === 'Email/import') {
+        emailId = (result as { created?: Record<string, { id?: string }> }).created?.['raw-import']?.id;
+      }
+      if (methodName === 'EmailSubmission/set') {
+        emailSubmissionId = (result as { created?: Record<string, { id?: string }> }).created?.['raw-submit']?.id;
+      }
+    }
+
+    return sendAt
+      ? { scheduled: true, emailId, emailSubmissionId, sendAt, isSmime: true }
+      : { scheduled: false, emailId, emailSubmissionId, isSmime: true };
+  }
+
+  async getScheduledEmails(limit = 50, position = 0): Promise<{ emails: ScheduledEmail[]; hasMore: boolean; total: number }> {
+    if (!this.hasDelayedSend()) {
+      return { emails: [], hasMore: false, total: 0 };
+    }
+
+    const queryResponse = await this.request([
+      ['EmailSubmission/query', {
+        accountId: this.accountId,
+        filter: { undoStatus: 'pending' },
+        sort: [{ property: 'sendAt', isAscending: true }],
+        limit,
+        position,
+      }, '0'],
+    ]);
+
+    const query = queryResponse.methodResponses?.[0]?.[1] as { ids?: string[]; total?: number; position?: number } | undefined;
+    const ids = query?.ids ?? [];
+    if (ids.length === 0) {
+      return { emails: [], hasMore: false, total: query?.total ?? 0 };
+    }
+
+    const submissionResponse = await this.request([
+      ['EmailSubmission/get', {
+        accountId: this.accountId,
+        ids,
+        properties: ['id', 'emailId', 'identityId', 'sendAt', 'undoStatus'],
+      }, '0'],
+    ]);
+    const submissions = ((submissionResponse.methodResponses?.[0]?.[1]?.list ?? []) as EmailSubmission[])
+      .filter(submission => submission.sendAt && Number.isFinite(new Date(submission.sendAt).getTime()));
+
+    if (submissions.length === 0) {
+      return { emails: [], hasMore: false, total: query?.total ?? 0 };
+    }
+
+    const emailResponse = await this.request([
+      ['Email/get', {
+        accountId: this.accountId,
+        ids: submissions.map(submission => submission.emailId),
+        properties: [
+          'id', 'threadId', 'mailboxIds', 'keywords', 'size', 'receivedAt', 'from', 'to', 'cc', 'bcc', 'replyTo',
+          'subject', 'preview', 'textBody', 'htmlBody', 'bodyValues', 'attachments', 'hasAttachment', 'sentAt',
+          'messageId', 'inReplyTo', 'references', 'headers', 'blobId', 'bodyStructure',
+        ],
+        fetchTextBodyValues: true,
+        fetchHTMLBodyValues: true,
+        fetchAllBodyValues: true,
+        maxBodyValueBytes: 256000,
+      }, '0'],
+    ]);
+
+    const emailById = new Map(((emailResponse.methodResponses?.[0]?.[1]?.list ?? []) as Email[]).map(email => [email.id, email]));
+    const emails = submissions
+      .map((submission): ScheduledEmail | null => {
+        const email = emailById.get(submission.emailId);
+        if (!email || !submission.sendAt) return null;
+        return {
+          ...email,
+          scheduledSendAt: submission.sendAt,
+          emailSubmissionId: submission.id,
+          scheduledIdentityId: submission.identityId,
+          scheduledUndoStatus: submission.undoStatus,
+          isScheduled: true,
+          isSmimeScheduled: isSmimeEmail(email),
+        };
+      })
+      .filter((email): email is ScheduledEmail => email !== null)
+      .sort((a, b) => new Date(a.scheduledSendAt).getTime() - new Date(b.scheduledSendAt).getTime());
+
+    const total = query?.total ?? emails.length;
+    return { emails, hasMore: computeHasMore(position, ids.length, total, limit), total };
+  }
+
+  async cancelEmailSubmission(submissionId: string): Promise<void> {
+    const response = await this.request([
+      ['EmailSubmission/set', {
+        accountId: this.accountId,
+        update: { [submissionId]: { undoStatus: 'canceled' } },
+      }, '0'],
+    ]);
+    const result = response.methodResponses?.[0]?.[1];
+    const error = result?.notUpdated?.[submissionId];
+    if (error) {
+      throw new Error(error.description || error.type || 'Failed to cancel scheduled send');
+    }
+  }
+
+  async rescheduleEmailSubmission(submissionId: string, emailId: string, identityId: string, sendAt: string): Promise<SendEmailResult> {
+    this.validateSendAt(sendAt);
+    const mailboxes = await this.getMailboxes();
+    const draftsMailbox = mailboxes.find(mb => mb.role === 'drafts');
+    const sentMailbox = mailboxes.find(mb => mb.role === 'sent');
+    const response = await this.request([
+      ['EmailSubmission/set', {
+        accountId: this.accountId,
+        create: { replacement: { emailId, identityId, sendAt } },
+        ...(draftsMailbox && sentMailbox ? {
+          onSuccessUpdateEmail: {
+            '#replacement': {
+              [`mailboxIds/${draftsMailbox.id}`]: null,
+              [`mailboxIds/${sentMailbox.id}`]: true,
+              'keywords/$draft': null,
+            },
+          },
+        } : {}),
+      }, '0'],
+    ]);
+    const result = response.methodResponses?.[0]?.[1];
+    const createError = result?.notCreated?.replacement;
+    if (createError) {
+      throw new Error(createError.description || createError.type || 'Failed to reschedule email');
+    }
+    const replacementId = result?.created?.replacement?.id;
+    if (!replacementId) {
+      throw new Error('Server did not return a replacement scheduled send ID');
+    }
+    try {
+      await this.cancelEmailSubmission(submissionId);
+    } catch (error) {
+      try {
+        await this.cancelEmailSubmission(replacementId);
+      } catch (cleanupError) {
+        console.error('Failed to clean up replacement scheduled send after reschedule failure:', cleanupError);
+      }
+      const message = error instanceof Error ? error.message : 'Failed to cancel original scheduled send';
+      throw new Error(`Reschedule created a replacement but could not cancel the original: ${message}`);
+    }
+    return { scheduled: true, emailId, emailSubmissionId: replacementId, sendAt };
+  }
+
+  async restoreEmailToDraft(emailId: string, draftMailboxId: string, sentMailboxId?: string): Promise<void> {
+    const update: Record<string, unknown> = {
+      [`mailboxIds/${draftMailboxId}`]: true,
+      'keywords/$draft': true,
+    };
+    if (sentMailboxId) {
+      update[`mailboxIds/${sentMailboxId}`] = null;
+    }
+    const response = await this.request([
+      ['Email/set', {
+        accountId: this.accountId,
+        update: { [emailId]: update },
+      }, '0'],
+    ]);
+    const result = response.methodResponses?.[0]?.[1];
+    const error = result?.notUpdated?.[emailId];
+    if (error) {
+      throw new Error(error.description || error.type || 'Failed to restore email to drafts');
     }
   }
 
@@ -5416,4 +5656,4 @@ export class JMAPClient implements IJMAPClient {
       ['urn:ietf:params:jmap:core'],
     );
   }
-}
+}

lib/jmap/types.ts

@@ -42,6 +42,30 @@ export interface Email {
   // Unified mailbox support - set when displaying emails from multiple accounts
   accountId?: string;
   accountLabel?: string;
+  // Client-only scheduled-send metadata, populated from EmailSubmission/query.
+  scheduledSendAt?: string;
+  emailSubmissionId?: string;
+  scheduledIdentityId?: string;
+  scheduledUndoStatus?: 'pending' | 'final' | 'canceled';
+  isScheduled?: boolean;
+  isSmimeScheduled?: boolean;
+}
+
+export interface SendEmailResult {
+  scheduled: boolean;
+  emailId?: string;
+  emailSubmissionId?: string;
+  sendAt?: string;
+  isSmime?: boolean;
+}
+
+export interface ScheduledEmail extends Email {
+  scheduledSendAt: string;
+  emailSubmissionId: string;
+  scheduledIdentityId: string;
+  scheduledUndoStatus: 'pending' | 'final' | 'canceled';
+  isScheduled: true;
+  isSmimeScheduled: boolean;
 }
 
 export interface AuthenticationResults {
@@ -767,4 +791,4 @@ export const UNIFIED_ROLE_BY_ID: Record<string, UnifiedMailboxRole> = Object.fro
 
 export function isUnifiedMailboxId(id: string): boolean {
   return id in UNIFIED_ROLE_BY_ID;
-}
+}