@hasna/connectors 1.3.2 → 1.3.3

package/connectors/connect-rapid7insightvm/src/api/client.ts

@@ -1,213 +1,27 @@
-import type { ConnectorConfig, OutputFormat } from '../types';
-import { ConnectorApiError, parseApiError } from '../types';
+import type { Rapid7Config } from '../types';
+import { Rapid7ApiError } from '../types';
 
-// TODO: Replace with your API's base URL
-const DEFAULT_BASE_URL = 'https://api.example.com';
-
-export interface RequestOptions {
-  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-  params?: Record<string, string | number | boolean | undefined>;
-  body?: Record<string, unknown> | unknown[] | string;
-  headers?: Record<string, string>;
-  format?: OutputFormat;
-  /** Number of retries for failed requests (default: 3) */
-  retries?: number;
-  /** Timeout in milliseconds (default: 30000) */
-  timeout?: number;
-}
-
-export class ConnectorClient {
-  private readonly apiKey: string;
-  private readonly apiSecret?: string;
+export class Rapid7Client {
+  private readonly authHeader: string;
   private readonly baseUrl: string;
 
-  constructor(config: ConnectorConfig) {
-    // Support both 'apiKey' and 'token' for flexibility
-    // Also support 'accessToken' for OAuth2
-    const key = config.apiKey || config.token || config.accessToken;
-    if (!key) {
-      throw new Error('API key, token, or accessToken is required');
-    }
-    this.apiKey = key;
-    this.apiSecret = config.apiSecret;
-    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+  constructor(config: Rapid7Config) {
+    if (!config.url || !config.username || !config.password) throw new Error('Rapid7 url, username, and password are required');
+    this.authHeader = `Basic ${btoa(`${config.username}:${config.password}`)}`;
+    this.baseUrl = `${config.url.replace(/\/$/, '')}/api/3`;
   }
 
-  private buildUrl(path: string, params?: Record<string, string | number | boolean | undefined>): string {
+  async request<T>(path: string, options: { method?: string; body?: Record<string, unknown>; params?: Record<string, string | number | undefined> } = {}): Promise<T> {
+    const { method = 'GET', body, params } = options;
     const url = new URL(`${this.baseUrl}${path}`);
-
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== undefined && value !== null && value !== '') {
-          url.searchParams.append(key, String(value));
-        }
-      });
-    }
-
-    return url.toString();
-  }
-
-  /**
-   * Sleep for a given number of milliseconds
-   */
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Calculate delay for exponential backoff
-   */
-  private getRetryDelay(attempt: number, baseDelay: number = 1000): number {
-    // Exponential backoff with jitter: base * 2^attempt + random(0-1000)ms
-    return baseDelay * Math.pow(2, attempt) + Math.random() * 1000;
-  }
-
-  /**
-   * Check if error is retryable
-   */
-  private isRetryableStatus(status: number): boolean {
-    // Retry on rate limit (429) and server errors (5xx)
-    return status === 429 || (status >= 500 && status < 600);
-  }
-
-  /**
-   * Make an authenticated request to the API
-   * TODO: Adjust authentication method for your API:
-   * - Bearer token: Authorization: Bearer <token>
-   * - API Key header: X-API-Key: <key>
-   * - Basic auth: Authorization: Basic <base64(key:secret)>
-   */
-  async request<T>(path: string, options: RequestOptions = {}): Promise<T> {
-    const { method = 'GET', params, body, headers = {}, retries = 3, timeout = 30000 } = options;
-
-    const url = this.buildUrl(path, params);
-
-    // TODO: Adjust authentication header for your API
-    const requestHeaders: Record<string, string> = {
-      'Authorization': `Bearer ${this.apiKey}`,
-      'Accept': 'application/json',
-      ...headers,
-    };
-
-    if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
-      requestHeaders['Content-Type'] = 'application/json';
-    }
-
-    const fetchOptions: RequestInit = {
-      method,
-      headers: requestHeaders,
-    };
-
-    if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
-      fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
-    }
-
-    let lastError: Error | null = null;
-    let lastStatus: number = 0;
-
-    for (let attempt = 0; attempt <= retries; attempt++) {
-      try {
-        // Create abort controller for timeout
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-
-        const response = await fetch(url, {
-          ...fetchOptions,
-          signal: controller.signal,
-        });
-
-        clearTimeout(timeoutId);
-        lastStatus = response.status;
-
-        // Handle 204 No Content
-        if (response.status === 204) {
-          return {} as T;
-        }
-
-        // Parse response
-        let data: unknown;
-        const contentType = response.headers.get('content-type') || '';
-
-        if (contentType.includes('application/json')) {
-          const text = await response.text();
-          if (text) {
-            try {
-              data = JSON.parse(text);
-            } catch {
-              data = text;
-            }
-          }
-        } else {
-          data = await response.text();
-        }
-
-        // Handle errors
-        if (!response.ok) {
-          // Check if we should retry
-          if (this.isRetryableStatus(response.status) && attempt < retries) {
-            // Check for Retry-After header
-            const retryAfter = response.headers.get('retry-after');
-            const delay = retryAfter
-              ? parseInt(retryAfter, 10) * 1000
-              : this.getRetryDelay(attempt);
-
-            await this.sleep(delay);
-            continue;
-          }
-
-          throw parseApiError(data, response.status);
-        }
-
-        return data as T;
-      } catch (err) {
-        lastError = err instanceof Error ? err : new Error(String(err));
-
-        // Handle timeout errors
-        if (lastError.name === 'AbortError') {
-          lastError = new Error(`Request timeout after ${timeout}ms`);
-        }
-
-        // Retry on network errors
-        if (attempt < retries && !(err instanceof ConnectorApiError)) {
-          await this.sleep(this.getRetryDelay(attempt));
-          continue;
-        }
-
-        throw err;
-      }
-    }
-
-    // Should not reach here, but just in case
-    throw lastError || new ConnectorApiError('Request failed', lastStatus);
-  }
-
-  async get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'GET', params });
-  }
-
-  async post<T>(path: string, body?: Record<string, unknown> | unknown[] | string | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'POST', body: body as Record<string, unknown>, params });
-  }
-
-  async put<T>(path: string, body?: Record<string, unknown> | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'PUT', body: body as Record<string, unknown>, params });
-  }
-
-  async patch<T>(path: string, body?: Record<string, unknown> | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'PATCH', body: body as Record<string, unknown>, params });
-  }
-
-  async delete<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'DELETE', params });
-  }
-
-  /**
-   * Get a preview of the API key (for display/debugging)
-   */
-  getApiKeyPreview(): string {
-    if (this.apiKey.length > 10) {
-      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
-    }
-    return '***';
+    if (params) Object.entries(params).forEach(([k, v]) => { if (v !== undefined) url.searchParams.append(k, String(v)); });
+    const headers: Record<string, string> = { Authorization: this.authHeader, 'Content-Type': 'application/json' };
+    const fetchOptions: RequestInit = { method, headers };
+    if (body && ['POST', 'PUT', 'PATCH'].includes(method)) fetchOptions.body = JSON.stringify(body);
+    const response = await fetch(url.toString(), fetchOptions);
+    if (response.status === 204) return {} as T;
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) throw new Rapid7ApiError((data as { message?: string })?.message || response.statusText, response.status);
+    return data as T;
   }
 }

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

@@ -1,51 +1,43 @@
-import type { ConnectorConfig } from '../types';
-import { ConnectorClient } from './client';
-import { ExampleApi } from './example';
-
-/**
- * Main Connector class
- * TODO: Rename to your API name (e.g., Perplexity, Twitter, etc.)
- */
-export class Connector {
-  private readonly client: ConnectorClient;
-
-  // API modules - add more as needed
-  public readonly example: ExampleApi;
-
-  constructor(config: ConnectorConfig) {
-    this.client = new ConnectorClient(config);
-    this.example = new ExampleApi(this.client);
+// Rapid7 InsightVM Connector — Vulnerability management and risk assessment
+import { Rapid7Client } from './client';
+import type { Rapid7Config, R7Asset, R7AssetList, R7Vulnerability, R7Scan, R7Site, R7Report } from '../types';
+export { Rapid7Client } from './client';
+
+export class Rapid7InsightVM {
+  private readonly client: Rapid7Client;
+  constructor(config: Rapid7Config) { this.client = new Rapid7Client(config); }
+  static fromEnv(): Rapid7InsightVM {
+    const url = process.env.RAPID7_URL;
+    const username = process.env.RAPID7_USERNAME;
+    const password = process.env.RAPID7_PASSWORD;
+    if (!url || !username || !password) throw new Error('RAPID7_URL, RAPID7_USERNAME, and RAPID7_PASSWORD are required');
+    return new Rapid7InsightVM({ url, username, password });
   }
 
-  /**
-   * Create a client from environment variables
-   * TODO: Update env var names for your API
-   * Looks for CONNECTOR_API_KEY and optionally CONNECTOR_API_SECRET
-   */
-  static fromEnv(): Connector {
-    const apiKey = process.env.CONNECTOR_API_KEY;
-    const apiSecret = process.env.CONNECTOR_API_SECRET;
+  async listAssets(options?: { page?: number; size?: number; sort?: string }): Promise<R7AssetList> {
+    return this.client.request<R7AssetList>('/assets', { params: { page: options?.page, size: options?.size, sort: options?.sort } });
+  }
+  async getAsset(assetId: number): Promise<R7Asset> { return this.client.request<R7Asset>(`/assets/${assetId}`); }
+  async getAssetVulnerabilities(assetId: number): Promise<{ resources: R7Vulnerability[] }> {
+    return this.client.request(`/assets/${assetId}/vulnerabilities`);
+  }
 
-    if (!apiKey) {
-      throw new Error('CONNECTOR_API_KEY environment variable is required');
-    }
-    return new Connector({ apiKey, apiSecret });
+  async getVulnerability(vulnId: string): Promise<R7Vulnerability> { return this.client.request<R7Vulnerability>(`/vulnerabilities/${vulnId}`); }
+  async searchVulnerabilities(query: string): Promise<{ resources: R7Vulnerability[] }> {
+    return this.client.request('/vulnerabilities', { params: { query } });
   }
 
-  /**
-   * Get a preview of the API key (for debugging)
-   */
-  getApiKeyPreview(): string {
-    return this.client.getApiKeyPreview();
+  async listScans(options?: { page?: number; size?: number }): Promise<{ resources: R7Scan[] }> {
+    return this.client.request('/scans', { params: { page: options?.page, size: options?.size } });
   }
+  async getScan(scanId: number): Promise<R7Scan> { return this.client.request<R7Scan>(`/scans/${scanId}`); }
 
-  /**
-   * Get the underlying client for direct API access
-   */
-  getClient(): ConnectorClient {
-    return this.client;
+  async listSites(options?: { page?: number; size?: number }): Promise<{ resources: R7Site[] }> {
+    return this.client.request('/sites', { params: { page: options?.page, size: options?.size } });
   }
-}
+  async getSite(siteId: number): Promise<R7Site> { return this.client.request<R7Site>(`/sites/${siteId}`); }
 
-export { ConnectorClient } from './client';
-export { ExampleApi } from './example';
+  async listReports(): Promise<{ resources: R7Report[] }> { return this.client.request('/reports'); }
+
+  getClient(): Rapid7Client { return this.client; }
+}

package/connectors/connect-rapid7insightvm/src/types/index.ts

@@ -1,237 +1,13 @@
-// Scaffold Connector Types
-// Replace CONNECTOR with your API name (e.g., Perplexity, Twitter, etc.)
+export interface Rapid7Config { url: string; username: string; password: string; }
 
-// ============================================
-// Configuration
-// ============================================
+export interface R7Asset { id: number; ip: string; hostName: string; mac: string; os: string; riskScore: number; vulnerabilities: { total: number; critical: number; severe: number; moderate: number }; lastScanTime: string; }
+export interface R7AssetList { resources: R7Asset[]; page: { number: number; size: number; totalResources: number; totalPages: number }; }
+export interface R7Vulnerability { id: string; title: string; description: string; severity: string; cvss: { v2: { score: number } | null; v3: { score: number } | null }; published: string; modified: string; references: string[]; }
+export interface R7Scan { id: number; scanName: string; status: string; startTime: string; endTime: string | null; assets: number; vulnerabilities: { total: number }; }
+export interface R7Site { id: number; name: string; description: string; assets: number; riskScore: number; lastScanTime: string; }
+export interface R7Report { id: number; name: string; format: string; status: string; generated: string; uri: string; }
 
-export interface ConnectorConfig {
-  apiKey?: string;      // For API key authentication
-  token?: string;       // Alias for apiKey (some APIs use 'token')
-  apiSecret?: string;   // Optional - some APIs need only a key
-  accessToken?: string; // For OAuth2 authentication
-  baseUrl?: string;     // Override default base URL
-}
-
-// ============================================
-// OAuth2 Types
-// ============================================
-
-export interface OAuth2Config {
-  clientId: string;
-  clientSecret: string;
-  redirectUri?: string;
-}
-
-export interface OAuth2Tokens {
-  accessToken: string;
-  refreshToken?: string;
-  expiresAt: number;
-  tokenType?: string;
-  scope?: string;
-}
-
-// ============================================
-// Common Types
-// ============================================
-
-export type OutputFormat = 'json' | 'pretty';
-
-export interface PaginatedResponse<T> {
-  data: T[];
-  nextToken?: string;
-  hasMore: boolean;
-}
-
-// ============================================
-// Example Resource Types
-// ============================================
-
-// Replace with your API's resource types
-export interface ExampleResource {
-  id: string;
-  name: string;
-  createdAt: string;
-  updatedAt: string;
-  // Add more fields as needed
-}
-
-export interface ExampleListResponse {
-  items: ExampleResource[];
-  nextPageToken?: string;
-  total?: number;
-}
-
-export interface ExampleCreateParams {
-  name: string;
-  // Add more params as needed
-}
-
-// ============================================
-// API Error Types
-// ============================================
-
-export interface ApiErrorDetail {
-  code: string;
-  message: string;
-  field?: string;
-  resource?: string;
-}
-
-export class ConnectorApiError extends Error {
+export class Rapid7ApiError extends Error {
   public readonly statusCode: number;
-  public readonly errors?: ApiErrorDetail[];
-  public readonly documentationUrl?: string;
-  public readonly requestId?: string;
-
-  constructor(
-    message: string,
-    statusCode: number,
-    options?: {
-      errors?: ApiErrorDetail[];
-      documentationUrl?: string;
-      requestId?: string;
-    }
-  ) {
-    super(message);
-    this.name = 'ConnectorApiError';
-    this.statusCode = statusCode;
-    this.errors = options?.errors;
-    this.documentationUrl = options?.documentationUrl;
-    this.requestId = options?.requestId;
-  }
-
-  /**
-   * Check if this is a rate limit error
-   */
-  isRateLimited(): boolean {
-    return this.statusCode === 429;
-  }
-
-  /**
-   * Check if this is a server error
-   */
-  isServerError(): boolean {
-    return this.statusCode >= 500 && this.statusCode < 600;
-  }
-
-  /**
-   * Check if this is a client error
-   */
-  isClientError(): boolean {
-    return this.statusCode >= 400 && this.statusCode < 500;
-  }
-
-  /**
-   * Check if this is an authentication error
-   */
-  isAuthError(): boolean {
-    return this.statusCode === 401 || this.statusCode === 403;
-  }
-
-  /**
-   * Check if this is a not found error
-   */
-  isNotFound(): boolean {
-    return this.statusCode === 404;
-  }
-
-  /**
-   * Get a user-friendly error message
-   */
-  getUserMessage(): string {
-    switch (this.statusCode) {
-      case 400:
-        return 'Bad request. Please check your input.';
-      case 401:
-        return 'Authentication failed. Please check your API key or login again.';
-      case 403:
-        return 'Access denied. You do not have permission to perform this action.';
-      case 404:
-        return 'Resource not found.';
-      case 429:
-        return 'Rate limit exceeded. Please wait and try again.';
-      case 500:
-        return 'Server error. Please try again later.';
-      case 502:
-      case 503:
-      case 504:
-        return 'Service temporarily unavailable. Please try again later.';
-      default:
-        return this.message;
-    }
-  }
-
-  /**
-   * Convert to JSON for logging/debugging
-   */
-  toJSON(): Record<string, unknown> {
-    return {
-      name: this.name,
-      message: this.message,
-      statusCode: this.statusCode,
-      errors: this.errors,
-      documentationUrl: this.documentationUrl,
-      requestId: this.requestId,
-    };
-  }
-}
-
-/**
- * Parse an API error response into a ConnectorApiError
- * Handles various common API error response formats
- */
-export function parseApiError(
-  response: unknown,
-  statusCode: number
-): ConnectorApiError {
-  // Handle string responses
-  if (typeof response === 'string') {
-    return new ConnectorApiError(response, statusCode);
-  }
-
-  // Handle null/undefined
-  if (!response || typeof response !== 'object') {
-    return new ConnectorApiError(`HTTP ${statusCode} Error`, statusCode);
-  }
-
-  const data = response as Record<string, unknown>;
-
-  // Extract message from various common formats
-  const message =
-    (data.message as string) ||
-    (data.error as string) ||
-    ((data.error as Record<string, unknown>)?.message as string) ||
-    (data.error_description as string) ||
-    (data.detail as string) ||
-    `HTTP ${statusCode} Error`;
-
-  // Extract errors array if present
-  let errors: ApiErrorDetail[] | undefined;
-  if (Array.isArray(data.errors)) {
-    errors = data.errors.map((e: Record<string, unknown>) => ({
-      code: String(e.code || e.error || 'unknown'),
-      message: String(e.message || e.description || 'Unknown error'),
-      field: e.field as string,
-      resource: e.resource as string,
-    }));
-  }
-
-  // Extract documentation URL
-  const documentationUrl =
-    (data.documentation_url as string) ||
-    (data.docs_url as string) ||
-    (data.help_url as string);
-
-  // Extract request ID
-  const requestId =
-    (data.request_id as string) ||
-    (data.requestId as string) ||
-    (data.trace_id as string);
-
-  return new ConnectorApiError(message, statusCode, {
-    errors,
-    documentationUrl,
-    requestId,
-  });
+  constructor(message: string, statusCode: number) { super(message); this.name = 'Rapid7ApiError'; this.statusCode = statusCode; }
 }