@hasna/connectors 1.3.22 → 1.3.23

package/connectors/connect-gmail/src/api/settings.ts

@@ -0,0 +1,280 @@
+import type { GmailClient } from './client';
+
+// ============================================
+// Settings API Types
+// ============================================
+
+export interface GetSettingsOptions {
+  format?: 'full' | 'minimal';
+}
+
+export interface GmailSettings {
+  autoForwardAddresses?: AutoForwardingAddress[];
+  displayName: string;
+  emailAddress: string;
+  hasAGoogleAppsDomain?: boolean;
+  language: string;
+  replyToAddresses?: string[];
+  signatures: Signature[];
+  vacationResponder: VacationResponder;
+  autoDeleteChats?: AutoDeleteChatsValue[];
+  keyboardShortcuts?: boolean;
+  locale: string;
+  markImportantEmailsAsRead?: boolean;
+  useExternalCalendarInvites?: boolean;
+  conversationView?: boolean;
+  defaultSnippets?: boolean;
+  externalBodyContent?: boolean;
+  imagesInEmails?: ImagesInEmailsValue;
+  unreadMessageIcon?: UnreadMessageIconValue;
+  indicators?: string[];
+  dateStampFormat?: number;
+  defaultInboxStyle?: string;
+  dotsInEmails?: string;
+  autoAdvance?: AutoAdvanceValue;
+  allowCustomFrom?: boolean;
+  fontSize?: string;
+  defaultCccPref?: boolean;
+  autoCreateContacts?: boolean;
+  allowMailToLinks?: boolean;
+  replyFromAddress: ReplyFromAddress;
+}
+
+export interface AutoForwardingAddress {
+  forwardingEmailAddress: string;
+  verificationStatus: string;
+  disposition: string;
+}
+
+export interface Signature {
+  sendAsEmail: string;
+  signature: string;
+  isDefault: boolean;
+}
+
+export interface VacationResponder {
+  enableAutoReply: boolean;
+  responseBodyHtml: string;
+  responseBodyPlainText: string;
+  subject: string;
+  startTime: string;
+  endTime: string;
+  restrictToContacts: boolean;
+  restrictToDomain: boolean;
+}
+
+export interface ReplyFromAddress {
+  treatAsAlias: boolean;
+  sendAsEmail: string;
+}
+
+export type AutoDeleteChatsValue = 'autoDeleteForever' | 'autoDeleteNever' | 'autoDeleteAfter30Days';
+export type ImagesInEmailsValue = 'displayExternal' | 'alwaysDisplay';
+export type UnreadMessageIconValue = 'number' | 'dot' | 'nothing';
+export type AutoAdvanceValue = 'goToNext' | 'goToPrev' | 'goToInbox';
+
+export interface AutoForwarding {
+  enabled: boolean;
+  emailAddress: string;
+  disposition: 'leaveInInbox' | 'archive' | 'trash' | 'markRead' | 'leaveInInboxAndMarkRead';
+}
+
+export interface PopSettings {
+  accessWindow: 'disabled' | 'fromNowOn' | 'allMail';
+  disposition: 'archive' | 'trash' | 'leaveInInbox';
+}
+
+export interface ImapSettings {
+  enabled: boolean;
+  autoExpunge: boolean;
+  expungeBehavior: 'archive' | 'trash' | 'markRead';
+  maxFolderSize: number;
+}
+
+export interface LanguageSettings {
+  displayLanguage: string;
+  writeLanguage: string;
+}
+
+export interface SendAsEmail {
+  sendAsEmail: string;
+  displayName: string;
+  replyToAddress: string;
+  signature: string;
+  isPrimary: boolean;
+  isDefault: boolean;
+  treatAsAlias: boolean;
+  smtpMsa?: {
+    host: string;
+    port: number;
+    username: string;
+    securityMode: 'none' | 'ssl' | 'starttls';
+  };
+  verificationStatus: 'accepted' | 'pending';
+}
+
+export interface CreateSendAsOptions {
+  sendAsEmail: string;
+  displayName?: string;
+  replyToAddress?: string;
+  signature?: string;
+  treatAsAlias?: boolean;
+  isDefault?: boolean;
+}
+
+export interface UpdateSendAsOptions {
+  displayName?: string;
+  replyToAddress?: string;
+  signature?: string;
+  treatAsAlias?: boolean;
+  isDefault?: boolean;
+}
+
+export interface CreateSmtpMsaOptions {
+  host: string;
+  port: number;
+  username: string;
+  password: string;
+  securityMode: 'none' | 'ssl' | 'starttls';
+}
+
+/**
+ * Settings API module - Gmail account settings, send-as, POP, IMAP, forwarding
+ */
+export class SettingsApi {
+  constructor(private readonly client: GmailClient) {}
+
+  /**
+   * Get user's Gmail settings
+   */
+  async get(options: GetSettingsOptions = {}): Promise<GmailSettings> {
+    const params: Record<string, string> = {};
+    if (options.format) params.format = options.format;
+    return this.client.get<GmailSettings>('/v1/users/me/settings', params);
+  }
+
+  /**
+   * Get auto-forwarding settings
+   */
+  async getAutoForwarding(): Promise<AutoForwarding> {
+    return this.client.get<AutoForwarding>('/v1/users/me/settings/autoForwarding');
+  }
+
+  /**
+   * Update auto-forwarding settings
+   */
+  async updateAutoForwarding(forwarding: Omit<AutoForwarding, 'emailAddress'> & { emailAddress: string }): Promise<AutoForwarding> {
+    return this.client.put<AutoForwarding>('/v1/users/me/settings/autoForwarding', forwarding as unknown as unknown as Record<string, unknown>);
+  }
+
+  /**
+   * Get POP settings
+   */
+  async getPop(): Promise<PopSettings> {
+    return this.client.get<PopSettings>('/v1/users/me/settings/pop');
+  }
+
+  /**
+   * Update POP settings
+   */
+  async updatePop(pop: PopSettings): Promise<PopSettings> {
+    return this.client.put<PopSettings>('/v1/users/me/settings/pop', pop as unknown as Record<string, unknown>);
+  }
+
+  /**
+   * Get IMAP settings
+   */
+  async getImap(): Promise<ImapSettings> {
+    return this.client.get<ImapSettings>('/v1/users/me/settings/imap');
+  }
+
+  /**
+   * Update IMAP settings
+   */
+  async updateImap(imap: ImapSettings): Promise<ImapSettings> {
+    return this.client.put<ImapSettings>('/v1/users/me/settings/imap', imap as unknown as Record<string, unknown>);
+  }
+
+  /**
+   * Get language settings
+   */
+  async getLanguage(): Promise<LanguageSettings> {
+    return this.client.get<LanguageSettings>('/v1/users/me/settings/language');
+  }
+
+  /**
+   * Update language settings
+   */
+  async updateLanguage(language: LanguageSettings): Promise<LanguageSettings> {
+    return this.client.put<LanguageSettings>('/v1/users/me/settings/language', language as unknown as Record<string, unknown>);
+  }
+
+  /**
+   * List all send-as addresses
+   */
+  async listSendAs(): Promise<{ sendAs: SendAsEmail[] }> {
+    return this.client.get('/v1/users/me/settings/sendAs');
+  }
+
+  /**
+   * Get a specific send-as address
+   */
+  async getSendAs(sendAsEmail: string): Promise<SendAsEmail> {
+    const encoded = encodeURIComponent(sendAsEmail);
+    return this.client.get<SendAsEmail>(`/v1/users/me/settings/sendAs/${encoded}`);
+  }
+
+  /**
+   * Create a new send-as alias
+   */
+  async createSendAs(options: CreateSendAsOptions): Promise<SendAsEmail> {
+    const body: Record<string, unknown> = { sendAsEmail: options.sendAsEmail };
+    if (options.displayName !== undefined) body.displayName = options.displayName;
+    if (options.replyToAddress !== undefined) body.replyToAddress = options.replyToAddress;
+    if (options.signature !== undefined) body.signature = options.signature;
+    if (options.treatAsAlias !== undefined) body.treatAsAlias = options.treatAsAlias;
+    if (options.isDefault !== undefined) body.isDefault = options.isDefault;
+
+    return this.client.post<SendAsEmail>('/v1/users/me/settings/sendAs', body);
+  }
+
+  /**
+   * Update a send-as alias
+   */
+  async updateSendAs(sendAsEmail: string, options: UpdateSendAsOptions): Promise<SendAsEmail> {
+    const encoded = encodeURIComponent(sendAsEmail);
+    return this.client.put<SendAsEmail>(`/v1/users/me/settings/sendAs/${encoded}`, options as unknown as Record<string, unknown>);
+  }
+
+  /**
+   * Delete a send-as alias
+   */
+  async deleteSendAs(sendAsEmail: string): Promise<void> {
+    const encoded = encodeURIComponent(sendAsEmail);
+    await this.client.delete(`/v1/users/me/settings/sendAs/${encoded}`);
+  }
+
+  /**
+   * Set SMTP MSA for a send-as alias (for third-party SMTP)
+   */
+  async setSendAsSmtpMsa(sendAsEmail: string, smtp: CreateSmtpMsaOptions): Promise<SendAsEmail> {
+    const encoded = encodeURIComponent(sendAsEmail);
+    return this.client.put<SendAsEmail>(`/v1/users/me/settings/sendAs/${encoded}/smtpMsa`, smtp as unknown as Record<string, unknown>);
+  }
+
+  /**
+   * Delete SMTP MSA for a send-as alias (revert to Gmail's servers)
+   */
+  async deleteSendAsSmtpMsa(sendAsEmail: string): Promise<SendAsEmail> {
+    const encoded = encodeURIComponent(sendAsEmail);
+    return this.client.delete<SendAsEmail>(`/v1/users/me/settings/sendAs/${encoded}/smtpMsa`);
+  }
+
+  /**
+   * Request verification for a send-as alias
+   */
+  async verifySendAs(sendAsEmail: string): Promise<void> {
+    const encoded = encodeURIComponent(sendAsEmail);
+    await this.client.post(`/v1/users/me/settings/sendAs/${encoded}/verify`);
+  }
+}

package/connectors/connect-gmail/src/api/watch.ts

@@ -0,0 +1,40 @@
+import type { GmailClient } from './client';
+
+// ============================================
+// Watch API Types
+// ============================================
+
+export interface WatchRequest {
+  labelIds?: string[];
+  labelFilterAction?: 'include' | 'exclude';
+  topicName: string;
+}
+
+export interface WatchResponse {
+  historyId: string;
+  expiration: string;
+}
+
+/**
+ * Watch API module - Set up push notifications for mailbox changes
+ */
+export class WatchApi {
+  constructor(private readonly client: GmailClient) {}
+
+  /**
+   * Set up or update a push notifications watch
+   *
+   * @param request - Watch configuration including Pub/Sub topic and optional label filters
+   * @returns Watch response with historyId and expiration timestamp
+   */
+  async start(request: WatchRequest): Promise<WatchResponse> {
+    return this.client.post<WatchResponse>('/v1/users/me/watch', request as unknown as Record<string, unknown>);
+  }
+
+  /**
+   * Stop receiving push notifications on the current watch
+   */
+  async stop(): Promise<void> {
+    await this.client.post('/v1/users/me/stop');
+  }
+}

package/connectors/connect-gmail/src/cli/index.ts

@@ -2419,5 +2419,242 @@ bulkCmd
     info('  bulk mark-read "is:unread older_than:7d" --batch');
   });
 
+// ============================================
+// History Commands
+// ============================================
+const historyCmd = program
+  .command('history')
+  .description('Mailbox history commands');
+
+historyCmd
+  .command('list')
+  .description('List mailbox change history')
+  .requiredOption('--start-history-id <id>', 'History ID to start from')
+  .option('--types <types>', 'History types: messageAdded,messageChanged,messageDeleted,labelAdded,labelRemoved')
+  .option('--label-id <id>', 'Filter by label ID')
+  .option('-n, --max <number>', 'Maximum history records to return', '50')
+  .action(async (opts) => {
+    try {
+      const gmail = requireAuth();
+      const historyTypes = opts.types ? opts.types.split(',').map((t: string) => t.trim()) : undefined;
+      const result = await gmail.history.list({
+        startHistoryId: opts.startHistoryId,
+        historyTypes,
+        labelId: opts.labelId,
+        maxResults: parseInt(opts.max),
+      });
+
+      if (!result.history || result.history.length === 0) {
+        info('No history records found');
+        return;
+      }
+
+      success(`Found ${result.history.length} history record(s):`);
+      const output = result.history.map(h => ({
+        id: h.id,
+        messagesAdded: h.messagesAdded?.length || 0,
+        messagesDeleted: h.messagesDeleted?.length || 0,
+        labelsAdded: h.labelsAdded?.length || 0,
+        labelsRemoved: h.labelsRemoved?.length || 0,
+        messagesChanged: h.messageChanged?.length || 0,
+      }));
+      print(output, getFormat(historyCmd));
+      info(`Current historyId: ${result.historyId}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// Gmail Settings Commands (API settings, not CLI config)
+// ============================================
+const gmailSettingsCmd = program
+  .command('gmail-settings')
+  .description('Gmail account settings commands');
+
+gmailSettingsCmd
+  .command('get')
+  .description('Get Gmail account settings')
+  .action(async () => {
+    try {
+      const gmail = requireAuth();
+      const settings = await gmail.settings.get();
+      print({
+        displayName: settings.displayName,
+        emailAddress: settings.emailAddress,
+        language: settings.language,
+        locale: settings.locale,
+        autoDeleteChats: settings.autoDeleteChats,
+        vacationResponder: {
+          enabled: settings.vacationResponder.enableAutoReply,
+          subject: settings.vacationResponder.subject,
+          restrictToContacts: settings.vacationResponder.restrictToContacts,
+          restrictToDomain: settings.vacationResponder.restrictToDomain,
+        },
+        signature: settings.signatures?.find(s => s.isDefault)?.signature || 'None',
+      }, getFormat(gmailSettingsCmd));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+gmailSettingsCmd
+  .command('forwarding')
+  .description('Get auto-forwarding settings')
+  .action(async () => {
+    try {
+      const gmail = requireAuth();
+      const forwarding = await gmail.settings.getAutoForwarding();
+      print(forwarding, getFormat(gmailSettingsCmd));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+gmailSettingsCmd
+  .command('imap')
+  .description('Get IMAP settings')
+  .action(async () => {
+    try {
+      const gmail = requireAuth();
+      const imap = await gmail.settings.getImap();
+      print(imap, getFormat(gmailSettingsCmd));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+gmailSettingsCmd
+  .command('pop')
+  .description('Get POP settings')
+  .action(async () => {
+    try {
+      const gmail = requireAuth();
+      const pop = await gmail.settings.getPop();
+      print(pop, getFormat(gmailSettingsCmd));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+gmailSettingsCmd
+  .command('send-as')
+  .description('List send-as aliases')
+  .action(async () => {
+    try {
+      const gmail = requireAuth();
+      const result = await gmail.settings.listSendAs();
+
+      if (!result.sendAs || result.sendAs.length === 0) {
+        info('No send-as aliases found');
+        return;
+      }
+
+      success(`Found ${result.sendAs.length} send-as address(es):`);
+      const output = result.sendAs.map(s => ({
+        email: s.sendAsEmail,
+        displayName: s.displayName,
+        isDefault: s.isDefault,
+        isPrimary: s.isPrimary,
+        verified: s.verificationStatus,
+      }));
+      print(output, getFormat(gmailSettingsCmd));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+gmailSettingsCmd
+  .command('add-send-as')
+  .description('Add a send-as alias')
+  .requiredOption('--email <email>', 'Send-as email address')
+  .option('--display-name <name>', 'Display name')
+  .option('--reply-to <email>', 'Reply-to address')
+  .option('--signature <text>', 'Email signature')
+  .option('--set-default', 'Make this the default send-as')
+  .action(async (opts) => {
+    try {
+      const gmail = requireAuth();
+      const sendAs = await gmail.settings.createSendAs({
+        sendAsEmail: opts.email,
+        displayName: opts.displayName,
+        replyToAddress: opts.replyTo,
+        signature: opts.signature,
+        isDefault: opts.setDefault,
+      });
+      success(`Send-as alias created: ${sendAs.sendAsEmail}`);
+      info(`Verification status: ${sendAs.verificationStatus}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+gmailSettingsCmd
+  .command('delete-send-as <email>')
+  .description('Delete a send-as alias')
+  .action(async (email: string) => {
+    try {
+      const gmail = requireAuth();
+      await gmail.settings.deleteSendAs(email);
+      success(`Send-as alias deleted: ${email}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// Watch Commands
+// ============================================
+const watchCmd = program
+  .command('watch')
+  .description('Push notification watch commands');
+
+watchCmd
+  .command('start')
+  .description('Start a push notification watch')
+  .requiredOption('--topic <topic>', 'Pub/Sub topic name (e.g., projects/my-project/topics/my-topic)')
+  .option('--label-ids <ids>', 'Comma-separated label IDs to watch')
+  .option('--label-filter <action>', 'Label filter: include or exclude', 'include')
+  .action(async (opts) => {
+    try {
+      const gmail = requireAuth();
+      const labelIds = opts.labelIds ? opts.labelIds.split(',').map((l: string) => l.trim()) : undefined;
+      const result = await gmail.watch.start({
+        topicName: opts.topic,
+        labelIds,
+        labelFilterAction: opts.labelFilter,
+      });
+
+      success('Watch started!');
+      info(`History ID: ${result.historyId}`);
+      info(`Expires: ${new Date(parseInt(result.historyId) > 1e12 ? parseInt(result.historyId) : Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString()}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+watchCmd
+  .command('stop')
+  .description('Stop push notification watch')
+  .action(async () => {
+    try {
+      const gmail = requireAuth();
+      await gmail.watch.stop();
+      success('Watch stopped');
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
 // Parse and execute
 program.parse();