@hasna/connectors 1.3.22 → 1.3.23

package/connectors/connect-github/src/api/bulk.ts

@@ -0,0 +1,328 @@
+import type { GitHubClient } from './client';
+
+// ============================================
+// Bulk Operation Types
+// ============================================
+
+export interface BulkOperationOptions {
+  /** Owner of the repository */
+  owner: string;
+  /** Repository name */
+  repo: string;
+  /** Maximum concurrent API calls (default: 10) */
+  concurrency?: number;
+  /** Dry run - don't actually modify */
+  dryRun?: boolean;
+  /** Progress callback */
+  onProgress?: (current: number, total: number, item: unknown) => void;
+  /** Error callback */
+  onError?: (error: Error, item: unknown) => void;
+}
+
+// --- Issue Bulk Operations ---
+
+export interface BulkIssueOptions extends BulkOperationOptions {
+  issueNumbers: number[];
+  /** Action to perform */
+  action: 'close' | 'reopen' | 'lock' | 'unlock';
+  /** Lock reason (for lock action only) */
+  lockReason?: 'off-topic' | 'too_heated' | 'resolved' | 'spam';
+}
+
+export interface BulkIssueResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ issueNumber: number; error: string }>;
+  results: Array<{ issueNumber: number; response: unknown }>;
+}
+
+// --- Label Bulk Operations ---
+
+export interface BulkLabelOptions extends BulkOperationOptions {
+  issueNumber: number;
+  /** Labels to add or remove */
+  labels: string[];
+  /** Action to perform */
+  action: 'add' | 'remove';
+}
+
+export interface BulkLabelResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ label: string; error: string }>;
+  results: Array<{ label: string; response: unknown }>;
+}
+
+// --- Pull Request Bulk Operations ---
+
+export interface BulkPullRequestOptions extends BulkOperationOptions {
+  pullNumbers: number[];
+  /** Action to perform */
+  action: 'merge' | 'close' | 'update_branch';
+  /** Merge method (for merge action) */
+  mergeMethod?: 'merge' | 'squash' | 'rebase';
+}
+
+export interface BulkPullRequestResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ pullNumber: number; error: string }>;
+  results: Array<{ pullNumber: number; response: unknown }>;
+}
+
+// --- Comment Bulk Operations ---
+
+export interface BulkCommentOptions extends BulkOperationOptions {
+  /** Comment IDs to operate on */
+  commentIds: number[];
+  /** Action to perform */
+  action: 'delete';
+}
+
+export interface BulkCommentResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ commentId: number; error: string }>;
+  results: Array<{ commentId: number; response: unknown }>;
+}
+
+// ============================================
+// Bulk Operations API
+// ============================================
+
+export class BulkApi {
+  private readonly client: GitHubClient;
+
+  constructor(client: GitHubClient) {
+    this.client = client;
+  }
+
+  // ============================================
+  // Bulk Issue Operations
+  // ============================================
+
+  async issues(options: BulkIssueOptions): Promise<BulkIssueResult> {
+    const { owner, repo, issueNumbers, action, lockReason, concurrency = 10, dryRun = false, onProgress, onError } = options;
+
+    const result: BulkIssueResult = {
+      total: issueNumbers.length,
+      success: 0,
+      failed: 0,
+      errors: [],
+      results: [],
+    };
+
+    if (issueNumbers.length === 0) return result;
+
+    const chunks = this.chunkArray(issueNumbers, concurrency);
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (issueNumber) => {
+          try {
+            if (dryRun) {
+              result.success++;
+            } else {
+              let response: unknown;
+              if (action === 'close') {
+                response = await this.client.patch(`/repos/${owner}/${repo}/issues/${issueNumber}`, { state: 'closed' });
+              } else if (action === 'reopen') {
+                response = await this.client.patch(`/repos/${owner}/${repo}/issues/${issueNumber}`, { state: 'open' });
+              } else if (action === 'lock') {
+                await this.client.put(`/repos/${owner}/${repo}/issues/${issueNumber}/lock`, {
+                  lock_reason: lockReason,
+                });
+                response = { locked: true };
+              } else {
+                await this.client.delete(`/repos/${owner}/${repo}/issues/${issueNumber}/lock`);
+                response = { locked: false };
+              }
+              result.success++;
+              result.results.push({ issueNumber, response });
+            }
+
+            if (onProgress) onProgress(result.success + result.failed, result.total, issueNumber);
+          } catch (err) {
+            result.failed++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            result.errors.push({ issueNumber, error: errorMessage });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), issueNumber);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Bulk Label Operations
+  // ============================================
+
+  async labels(options: BulkLabelOptions): Promise<BulkLabelResult> {
+    const { owner, repo, issueNumber, labels, action, concurrency = 10, dryRun = false, onProgress, onError } = options;
+
+    const result: BulkLabelResult = {
+      total: labels.length,
+      success: 0,
+      failed: 0,
+      errors: [],
+      results: [],
+    };
+
+    if (labels.length === 0) return result;
+
+    const chunks = this.chunkArray(labels, concurrency);
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (label) => {
+          try {
+            if (dryRun) {
+              result.success++;
+            } else {
+              let response: unknown;
+              if (action === 'add') {
+                await this.client.post(`/repos/${owner}/${repo}/issues/${issueNumber}/labels`, {
+                  labels: [label],
+                });
+                response = { added: label };
+              } else {
+                await this.client.delete(`/repos/${owner}/${repo}/issues/${issueNumber}/labels/${encodeURIComponent(label)}`);
+                response = { removed: label };
+              }
+              result.success++;
+              result.results.push({ label, response });
+            }
+
+            if (onProgress) onProgress(result.success + result.failed, result.total, label);
+          } catch (err) {
+            result.failed++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            result.errors.push({ label, error: errorMessage });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), label);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Bulk Pull Request Operations
+  // ============================================
+
+  async pullRequests(options: BulkPullRequestOptions): Promise<BulkPullRequestResult> {
+    const { owner, repo, pullNumbers, action, mergeMethod = 'merge', concurrency = 10, dryRun = false, onProgress, onError } = options;
+
+    const result: BulkPullRequestResult = {
+      total: pullNumbers.length,
+      success: 0,
+      failed: 0,
+      errors: [],
+      results: [],
+    };
+
+    if (pullNumbers.length === 0) return result;
+
+    const chunks = this.chunkArray(pullNumbers, concurrency);
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (pullNumber) => {
+          try {
+            if (dryRun) {
+              result.success++;
+            } else {
+              let response: unknown;
+              if (action === 'merge') {
+                response = await this.client.put(`/repos/${owner}/${repo}/pulls/${pullNumber}/merge`, {
+                  merge_method: mergeMethod,
+                });
+              } else if (action === 'close') {
+                response = await this.client.patch(`/repos/${owner}/${repo}/pulls/${pullNumber}`, { state: 'closed' });
+              } else {
+                response = await this.client.put(`/repos/${owner}/${repo}/pulls/${pullNumber}/update-branch`);
+              }
+              result.success++;
+              result.results.push({ pullNumber, response });
+            }
+
+            if (onProgress) onProgress(result.success + result.failed, result.total, pullNumber);
+          } catch (err) {
+            result.failed++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            result.errors.push({ pullNumber, error: errorMessage });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), pullNumber);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Bulk Comment Operations
+  // ============================================
+
+  async comments(options: BulkCommentOptions): Promise<BulkCommentResult> {
+    const { owner, repo, commentIds, action, concurrency = 10, dryRun = false, onProgress, onError } = options;
+
+    const result: BulkCommentResult = {
+      total: commentIds.length,
+      success: 0,
+      failed: 0,
+      errors: [],
+      results: [],
+    };
+
+    if (commentIds.length === 0) return result;
+
+    const chunks = this.chunkArray(commentIds, concurrency);
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (commentId) => {
+          try {
+            if (dryRun) {
+              result.success++;
+            } else {
+              if (action === 'delete') {
+                await this.client.delete(`/repos/${owner}/${repo}/issues/comments/${commentId}`);
+              }
+              result.success++;
+              result.results.push({ commentId, response: { deleted: commentId } });
+            }
+
+            if (onProgress) onProgress(result.success + result.failed, result.total, commentId);
+          } catch (err) {
+            result.failed++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            result.errors.push({ commentId, error: errorMessage });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), commentId);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Helper Methods
+  // ============================================
+
+  private chunkArray<T>(array: T[], size: number): T[][] {
+    const chunks: T[][] = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+}

package/connectors/connect-github/src/api/index.ts

@@ -4,6 +4,7 @@ import { ReposApi } from './repos';
 import { IssuesApi } from './issues';
 import { PullsApi } from './pulls';
 import { UsersApi } from './users';
+import { BulkApi } from './bulk';
 
 /**
  * Main GitHub connector class
@@ -16,6 +17,7 @@ export class GitHub {
   public readonly issues: IssuesApi;
   public readonly pulls: PullsApi;
   public readonly users: UsersApi;
+  public readonly bulk: BulkApi;
 
   constructor(config: GitHubConfig) {
     this.client = new GitHubClient(config);
@@ -23,6 +25,7 @@ export class GitHub {
     this.issues = new IssuesApi(this.client);
     this.pulls = new PullsApi(this.client);
     this.users = new UsersApi(this.client);
+    this.bulk = new BulkApi(this.client);
   }
 
   /**
@@ -60,3 +63,4 @@ export { ReposApi } from './repos';
 export { IssuesApi } from './issues';
 export { PullsApi } from './pulls';
 export { UsersApi } from './users';
+export { BulkApi } from './bulk';

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

@@ -830,5 +830,150 @@ userCmd
     }
   });
 
+// ============================================
+// Bulk Operations Commands
+// ============================================
+const bulkCmd = program
+  .command('bulk')
+  .description('Bulk operations');
+
+bulkCmd
+  .command('issues')
+  .description('Bulk issue operations')
+  .requiredOption('--owner <owner>', 'Repository owner')
+  .requiredOption('--repo <repo>', 'Repository name')
+  .requiredOption('--numbers <numbers>', 'Comma-separated issue numbers')
+  .requiredOption('--action <action>', 'Action: close, reopen, lock, unlock')
+  .option('--lock-reason <reason>', 'Lock reason: off-topic, too_heated, resolved, spam')
+  .option('--concurrency <number>', 'Max concurrent operations', '10')
+  .option('--dry-run', 'Preview without executing')
+  .action(async function(this: Command, opts) {
+    try {
+      const client = getClient();
+      const result = await client.bulk.issues({
+        owner: opts.owner,
+        repo: opts.repo,
+        issueNumbers: opts.numbers.split(',').map((n: string) => parseInt(n.trim())),
+        action: opts.action as 'close' | 'reopen' | 'lock' | 'unlock',
+        lockReason: opts.lockReason,
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => info(`Progress: ${current}/${total}`),
+      });
+      print(result, getFormat(this));
+      info(`Success: ${result.success}, Failed: ${result.failed}, Total: ${result.total}`);
+      if (result.errors.length > 0) {
+        warn('Errors:');
+        result.errors.forEach(e => error(`  #${e.issueNumber}: ${e.error}`));
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('labels')
+  .description('Bulk label operations')
+  .requiredOption('--owner <owner>', 'Repository owner')
+  .requiredOption('--repo <repo>', 'Repository name')
+  .requiredOption('--issue-number <number>', 'Issue number')
+  .requiredOption('--labels <labels>', 'Comma-separated label names')
+  .requiredOption('--action <action>', 'Action: add, remove')
+  .option('--concurrency <number>', 'Max concurrent operations', '10')
+  .option('--dry-run', 'Preview without executing')
+  .action(async function(this: Command, opts) {
+    try {
+      const client = getClient();
+      const result = await client.bulk.labels({
+        owner: opts.owner,
+        repo: opts.repo,
+        issueNumber: parseInt(opts.issueNumber),
+        labels: opts.labels.split(',').map((l: string) => l.trim()),
+        action: opts.action as 'add' | 'remove',
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => info(`Progress: ${current}/${total}`),
+      });
+      print(result, getFormat(this));
+      info(`Success: ${result.success}, Failed: ${result.failed}, Total: ${result.total}`);
+      if (result.errors.length > 0) {
+        warn('Errors:');
+        result.errors.forEach(e => error(`  ${e.label}: ${e.error}`));
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('pull-requests')
+  .description('Bulk pull request operations')
+  .requiredOption('--owner <owner>', 'Repository owner')
+  .requiredOption('--repo <repo>', 'Repository name')
+  .requiredOption('--numbers <numbers>', 'Comma-separated PR numbers')
+  .requiredOption('--action <action>', 'Action: merge, close, update_branch')
+  .option('--merge-method <method>', 'Merge method: merge, squash, rebase', 'merge')
+  .option('--concurrency <number>', 'Max concurrent operations', '10')
+  .option('--dry-run', 'Preview without executing')
+  .action(async function(this: Command, opts) {
+    try {
+      const client = getClient();
+      const result = await client.bulk.pullRequests({
+        owner: opts.owner,
+        repo: opts.repo,
+        pullNumbers: opts.numbers.split(',').map((n: string) => parseInt(n.trim())),
+        action: opts.action as 'merge' | 'close' | 'update_branch',
+        mergeMethod: opts.mergeMethod as 'merge' | 'squash' | 'rebase',
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => info(`Progress: ${current}/${total}`),
+      });
+      print(result, getFormat(this));
+      info(`Success: ${result.success}, Failed: ${result.failed}, Total: ${result.total}`);
+      if (result.errors.length > 0) {
+        warn('Errors:');
+        result.errors.forEach(e => error(`  #${e.pullNumber}: ${e.error}`));
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('comments')
+  .description('Bulk comment operations')
+  .requiredOption('--owner <owner>', 'Repository owner')
+  .requiredOption('--repo <repo>', 'Repository name')
+  .requiredOption('--ids <ids>', 'Comma-separated comment IDs')
+  .requiredOption('--action <action>', 'Action: delete')
+  .option('--concurrency <number>', 'Max concurrent operations', '10')
+  .option('--dry-run', 'Preview without executing')
+  .action(async function(this: Command, opts) {
+    try {
+      const client = getClient();
+      const result = await client.bulk.comments({
+        owner: opts.owner,
+        repo: opts.repo,
+        commentIds: opts.ids.split(',').map((n: string) => parseInt(n.trim())),
+        action: opts.action as 'delete',
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => info(`Progress: ${current}/${total}`),
+      });
+      print(result, getFormat(this));
+      info(`Success: ${result.success}, Failed: ${result.failed}, Total: ${result.total}`);
+      if (result.errors.length > 0) {
+        warn('Errors:');
+        result.errors.forEach(e => error(`  comment ${e.commentId}: ${e.error}`));
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
 // Parse and execute
 program.parse();

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

@@ -0,0 +1,82 @@
+import type { GmailClient } from './client';
+
+// ============================================
+// History API Types
+// ============================================
+
+export interface ListHistoryOptions {
+  startHistoryId: string;
+  historyTypes?: ('messageAdded' | 'messageChanged' | 'messageDeleted' | 'labelAdded' | 'labelRemoved')[];
+  labelId?: string;
+  maxResults?: number;
+  pageToken?: string;
+}
+
+export interface HistoryRecord {
+  id: string;
+  messages?: Array<{
+    id: string;
+    threadId: string;
+  }>;
+  messagesAdded?: Array<{
+    message: { id: string; threadId: string };
+  }>;
+  messagesDeleted?: Array<{
+    message: { id: string; threadId: string };
+  }>;
+  labelsAdded?: Array<{
+    message: { id: string; threadId: string };
+    labelIds: string[];
+  }>;
+  labelsRemoved?: Array<{
+    message: { id: string; threadId: string };
+    labelIds: string[];
+  }>;
+  messageChanged?: Array<{
+    message: { id: string; threadId: string };
+  }>;
+}
+
+export interface ListHistoryResponse {
+  history?: HistoryRecord[];
+  nextPageToken?: string;
+  historyId: string;
+}
+
+/**
+ * History API module - retrieve mailbox change history
+ */
+export class HistoryApi {
+  constructor(private readonly client: GmailClient) {}
+
+  /**
+   * List the history of all changes to the user's mailbox
+   */
+  async list(options: ListHistoryOptions): Promise<ListHistoryResponse> {
+    const params: Record<string, string | number> = {
+      startHistoryId: options.startHistoryId,
+    };
+    if (options.historyTypes && options.historyTypes.length > 0) {
+      params.historyTypes = options.historyTypes.join(',');
+    }
+    if (options.labelId) params.labelId = options.labelId;
+    if (options.maxResults) params.maxResults = options.maxResults;
+    if (options.pageToken) params.pageToken = options.pageToken;
+
+    return this.client.get<ListHistoryResponse>('/v1/users/me/history', params);
+  }
+
+  /**
+   * Iterate over all history records (handles pagination)
+   */
+  async *listAll(options: Omit<ListHistoryOptions, 'pageToken'>): AsyncGenerator<HistoryRecord> {
+    let pageToken: string | undefined;
+    do {
+      const response = await this.list({ ...options, pageToken });
+      for (const record of response.history || []) {
+        yield record;
+      }
+      pageToken = response.nextPageToken;
+    } while (pageToken);
+  }
+}

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

@@ -8,6 +8,9 @@ import { FiltersApi } from './filters';
 import { AttachmentsApi } from './attachments';
 import { ExportApi } from './export';
 import { BulkApi } from './bulk';
+import { HistoryApi } from './history';
+import { SettingsApi } from './settings';
+import { WatchApi } from './watch';
 import { refreshTokens } from '../utils/auth';
 
 /** Tokens passed to Gmail.createWithTokens() */
@@ -33,6 +36,9 @@ export class Gmail {
   public readonly attachments: AttachmentsApi;
   public readonly export: ExportApi;
   public readonly bulk: BulkApi;
+  public readonly history: HistoryApi;
+  public readonly settings: SettingsApi;
+  public readonly watch: WatchApi;
 
   constructor(client?: GmailClient) {
     this.client = client ?? new GmailClient();
@@ -45,6 +51,9 @@ export class Gmail {
     this.attachments = new AttachmentsApi(this.client);
     this.export = new ExportApi(this.client);
     this.bulk = new BulkApi(this.client);
+    this.history = new HistoryApi(this.client);
+    this.settings = new SettingsApi(this.client);
+    this.watch = new WatchApi(this.client);
   }
 
   /**
@@ -156,3 +165,6 @@ export { FiltersApi } from './filters';
 export { AttachmentsApi } from './attachments';
 export { ExportApi } from './export';
 export { BulkApi } from './bulk';
+export { HistoryApi } from './history';
+export { SettingsApi } from './settings';
+export { WatchApi } from './watch';