@hasna/connectors 1.3.2 → 1.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/connectors",
-  "version": "1.3.2",
+  "version": "1.3.5",
   "description": "Open source connector library - Install API connectors with a single command",
   "type": "module",
   "bin": {
@@ -30,6 +30,7 @@
     "dev": "bun run ./src/cli/index.tsx",
     "typecheck": "tsc --noEmit",
     "test": "bun test",
+    "sdk:build": "cd sdk && bun run build",
     "prepublishOnly": "bun test && bun run build"
   },
   "keywords": [

package/connectors/connect-godaddy/src/api/example.ts

@@ -1,48 +0,0 @@
-import type { ConnectorClient } from './client';
-import type { ExampleResource, ExampleListResponse, ExampleCreateParams } from '../types';
-
-/**
- * Example API module - demonstrates the pattern for API modules
- * TODO: Replace with your actual API endpoints
- */
-export class ExampleApi {
-  constructor(private readonly client: ConnectorClient) {}
-
-  /**
-   * List resources with optional pagination
-   */
-  async list(options?: { maxResults?: number; pageToken?: string }): Promise<ExampleListResponse> {
-    return this.client.get<ExampleListResponse>('/resources', {
-      max_results: options?.maxResults,
-      page_token: options?.pageToken,
-    });
-  }
-
-  /**
-   * Get a single resource by ID
-   */
-  async get(id: string): Promise<ExampleResource> {
-    return this.client.get<ExampleResource>(`/resources/${id}`);
-  }
-
-  /**
-   * Create a new resource
-   */
-  async create(params: ExampleCreateParams): Promise<ExampleResource> {
-    return this.client.post<ExampleResource>('/resources', params);
-  }
-
-  /**
-   * Update an existing resource
-   */
-  async update(id: string, params: Partial<ExampleCreateParams>): Promise<ExampleResource> {
-    return this.client.patch<ExampleResource>(`/resources/${id}`, params);
-  }
-
-  /**
-   * Delete a resource
-   */
-  async delete(id: string): Promise<void> {
-    await this.client.delete(`/resources/${id}`);
-  }
-}

package/connectors/connect-godaddy/src/utils/auth.ts

@@ -1,274 +0,0 @@
-import { createServer } from 'http';
-import type { OAuth2Tokens, OAuth2Config } from '../types';
-import { saveOAuthTokens, loadOAuthTokens, getOAuthConfig } from './config';
-
-// ============================================
-// OAuth2 Authentication Utility
-// ============================================
-
-// TODO: Replace with your OAuth provider's endpoints
-const DEFAULT_AUTH_URL = 'https://accounts.example.com/oauth2/authorize';
-const DEFAULT_TOKEN_URL = 'https://accounts.example.com/oauth2/token';
-
-// TODO: Define your OAuth scopes
-const DEFAULT_SCOPES = ['read', 'write'].join(' ');
-
-const REDIRECT_PORT = 8089;
-const REDIRECT_URI = `http://localhost:${REDIRECT_PORT}/callback`;
-
-export interface AuthResult {
-  success: boolean;
-  tokens?: OAuth2Tokens;
-  error?: string;
-}
-
-export interface AuthUrlOptions {
-  authUrl?: string;
-  scopes?: string;
-  state?: string;
-  extraParams?: Record<string, string>;
-}
-
-/**
- * Generate the OAuth2 authorization URL
- */
-export function getAuthUrl(options: AuthUrlOptions = {}): string {
-  const config = getOAuthConfig();
-  if (!config?.clientId) {
-    throw new Error('OAuth client ID not configured. Run "config set-credentials" first.');
-  }
-
-  const authUrl = options.authUrl || DEFAULT_AUTH_URL;
-  const scopes = options.scopes || DEFAULT_SCOPES;
-
-  const params = new URLSearchParams({
-    client_id: config.clientId,
-    redirect_uri: REDIRECT_URI,
-    response_type: 'code',
-    scope: scopes,
-    access_type: 'offline',
-    prompt: 'consent', // Force consent to get refresh token
-    ...(options.state && { state: options.state }),
-    ...options.extraParams,
-  });
-
-  return `${authUrl}?${params.toString()}`;
-}
-
-/**
- * Exchange authorization code for tokens
- */
-export async function exchangeCodeForTokens(
-  code: string,
-  tokenUrl: string = DEFAULT_TOKEN_URL
-): Promise<OAuth2Tokens> {
-  const config = getOAuthConfig();
-
-  if (!config?.clientId || !config?.clientSecret) {
-    throw new Error('OAuth credentials not configured');
-  }
-
-  const response = await fetch(tokenUrl, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/x-www-form-urlencoded',
-    },
-    body: new URLSearchParams({
-      code,
-      client_id: config.clientId,
-      client_secret: config.clientSecret,
-      redirect_uri: REDIRECT_URI,
-      grant_type: 'authorization_code',
-    }),
-  });
-
-  if (!response.ok) {
-    const error = await response.json().catch(() => ({ error: response.statusText }));
-    throw new Error(`Token exchange failed: ${error.error_description || error.error}`);
-  }
-
-  const data = await response.json();
-
-  const tokens: OAuth2Tokens = {
-    accessToken: data.access_token,
-    refreshToken: data.refresh_token,
-    expiresAt: Date.now() + data.expires_in * 1000,
-    tokenType: data.token_type,
-    scope: data.scope,
-  };
-
-  return tokens;
-}
-
-/**
- * Refresh the access token using the refresh token
- */
-export async function refreshAccessToken(
-  tokenUrl: string = DEFAULT_TOKEN_URL
-): Promise<OAuth2Tokens> {
-  const config = getOAuthConfig();
-  const currentTokens = loadOAuthTokens();
-
-  if (!config?.clientId || !config?.clientSecret) {
-    throw new Error('OAuth credentials not configured');
-  }
-
-  if (!currentTokens?.refreshToken) {
-    throw new Error('No refresh token available. Please login again.');
-  }
-
-  const response = await fetch(tokenUrl, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/x-www-form-urlencoded',
-    },
-    body: new URLSearchParams({
-      client_id: config.clientId,
-      client_secret: config.clientSecret,
-      refresh_token: currentTokens.refreshToken,
-      grant_type: 'refresh_token',
-    }),
-  });
-
-  if (!response.ok) {
-    const error = await response.json().catch(() => ({ error: response.statusText }));
-    throw new Error(`Token refresh failed: ${error.error_description || error.error}`);
-  }
-
-  const data = await response.json();
-
-  const tokens: OAuth2Tokens = {
-    accessToken: data.access_token,
-    refreshToken: data.refresh_token || currentTokens.refreshToken, // Keep original if not returned
-    expiresAt: Date.now() + data.expires_in * 1000,
-    tokenType: data.token_type,
-    scope: data.scope || currentTokens.scope,
-  };
-
-  saveOAuthTokens(tokens);
-  return tokens;
-}
-
-/**
- * Start a local HTTP server to receive the OAuth callback
- */
-export function startCallbackServer(): Promise<AuthResult> {
-  return new Promise((resolve) => {
-    const server = createServer(async (req, res) => {
-      const url = new URL(req.url || '', `http://localhost:${REDIRECT_PORT}`);
-
-      if (url.pathname === '/callback') {
-        const code = url.searchParams.get('code');
-        const error = url.searchParams.get('error');
-
-        if (error) {
-          res.writeHead(200, { 'Content-Type': 'text/html' });
-          res.end(`
-            <html>
-              <body style="font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
-                <div style="text-align: center;">
-                  <h1 style="color: #dc3545;">Authentication Failed</h1>
-                  <p>Error: ${error}</p>
-                  <p>You can close this window.</p>
-                </div>
-              </body>
-            </html>
-          `);
-          server.close();
-          resolve({ success: false, error });
-          return;
-        }
-
-        if (code) {
-          try {
-            const tokens = await exchangeCodeForTokens(code);
-            res.writeHead(200, { 'Content-Type': 'text/html' });
-            res.end(`
-              <html>
-                <body style="font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
-                  <div style="text-align: center;">
-                    <h1 style="color: #28a745;">Authentication Successful!</h1>
-                    <p>You can close this window and return to the terminal.</p>
-                  </div>
-                </body>
-              </html>
-            `);
-            server.close();
-            resolve({ success: true, tokens });
-          } catch (err) {
-            res.writeHead(200, { 'Content-Type': 'text/html' });
-            res.end(`
-              <html>
-                <body style="font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
-                  <div style="text-align: center;">
-                    <h1 style="color: #dc3545;">Authentication Failed</h1>
-                    <p>Error: ${String(err)}</p>
-                    <p>You can close this window.</p>
-                  </div>
-                </body>
-              </html>
-            `);
-            server.close();
-            resolve({ success: false, error: String(err) });
-          }
-        }
-      }
-    });
-
-    server.listen(REDIRECT_PORT, () => {
-      // Server is ready
-    });
-
-    // Timeout after 5 minutes
-    setTimeout(() => {
-      server.close();
-      resolve({ success: false, error: 'Authentication timed out' });
-    }, 5 * 60 * 1000);
-  });
-}
-
-/**
- * Get a valid access token, refreshing if necessary
- * @param tokenUrl - Token endpoint URL for refresh
- * @param bufferMs - Refresh buffer in ms (default: 5 minutes)
- */
-export async function getValidAccessToken(
-  tokenUrl: string = DEFAULT_TOKEN_URL,
-  bufferMs: number = 5 * 60 * 1000
-): Promise<string> {
-  const tokens = loadOAuthTokens();
-
-  if (!tokens) {
-    throw new Error('Not authenticated. Run "auth login" first.');
-  }
-
-  // Check if token is expired or will expire within buffer time
-  if (Date.now() >= tokens.expiresAt - bufferMs) {
-    const newTokens = await refreshAccessToken(tokenUrl);
-    return newTokens.accessToken;
-  }
-
-  return tokens.accessToken;
-}
-
-/**
- * Check if the user is authenticated
- */
-export function isAuthenticated(): boolean {
-  const tokens = loadOAuthTokens();
-  return !!tokens?.accessToken;
-}
-
-/**
- * Get the redirect URI for OAuth configuration
- */
-export function getRedirectUri(): string {
-  return REDIRECT_URI;
-}
-
-/**
- * Get the redirect port for OAuth callback
- */
-export function getRedirectPort(): number {
-  return REDIRECT_PORT;
-}

package/connectors/connect-godaddy/src/utils/bulk.ts

@@ -1,212 +0,0 @@
-// ============================================
-// Bulk Operations Utility
-// ============================================
-
-/**
- * Options for bulk operations
- */
-export interface BulkOperationOptions<T> {
-  /** Items to process */
-  items: T[];
-  /** Maximum concurrent operations (default: 10) */
-  concurrency?: number;
-  /** Dry run - preview without making changes */
-  dryRun?: boolean;
-  /** Progress callback */
-  onProgress?: (current: number, total: number, item: T) => void;
-  /** Error callback (return true to continue, false to stop) */
-  onError?: (error: Error, item: T) => boolean | void;
-  /** Delay between batches in ms (useful for rate limiting) */
-  batchDelay?: number;
-}
-
-/**
- * Result of a bulk operation
- */
-export interface BulkOperationResult<T, R = void> {
-  /** Total items processed */
-  total: number;
-  /** Successfully processed count */
-  success: number;
-  /** Failed count */
-  failed: number;
-  /** Skipped count (dry run) */
-  skipped: number;
-  /** List of errors */
-  errors: Array<{ item: T; error: string }>;
-  /** Successfully processed items with results */
-  results: Array<{ item: T; result: R }>;
-}
-
-/**
- * Split an array into chunks of a given size
- */
-export function 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;
-}
-
-/**
- * Sleep for a given number of milliseconds
- */
-export function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-/**
- * Execute a bulk operation with concurrency control
- *
- * @param options - Bulk operation options
- * @param operation - Async function to execute for each item
- * @returns Result summary
- *
- * @example
- * ```typescript
- * const result = await executeBulk(
- *   {
- *     items: users,
- *     concurrency: 5,
- *     onProgress: (current, total, user) => {
- *       console.log(`Processing ${current}/${total}: ${user.email}`);
- *     },
- *   },
- *   async (user) => {
- *     await api.updateUser(user.id, { status: 'active' });
- *   }
- * );
- * console.log(`Success: ${result.success}, Failed: ${result.failed}`);
- * ```
- */
-export async function executeBulk<T, R = void>(
-  options: BulkOperationOptions<T>,
-  operation: (item: T) => Promise<R>
-): Promise<BulkOperationResult<T, R>> {
-  const {
-    items,
-    concurrency = 10,
-    dryRun = false,
-    onProgress,
-    onError,
-    batchDelay = 0,
-  } = options;
-
-  const result: BulkOperationResult<T, R> = {
-    total: items.length,
-    success: 0,
-    failed: 0,
-    skipped: 0,
-    errors: [],
-    results: [],
-  };
-
-  if (items.length === 0) {
-    return result;
-  }
-
-  // Process in batches with concurrency control
-  const chunks = chunkArray(items, concurrency);
-  let shouldStop = false;
-
-  for (let chunkIndex = 0; chunkIndex < chunks.length && !shouldStop; chunkIndex++) {
-    const chunk = chunks[chunkIndex];
-
-    await Promise.all(
-      chunk.map(async (item) => {
-        if (shouldStop) return;
-
-        try {
-          if (dryRun) {
-            result.skipped++;
-            result.results.push({ item, result: undefined as R });
-          } else {
-            const opResult = await operation(item);
-            result.success++;
-            result.results.push({ item, result: opResult });
-          }
-
-          if (onProgress) {
-            onProgress(result.success + result.failed + result.skipped, result.total, item);
-          }
-        } catch (err) {
-          result.failed++;
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          result.errors.push({ item, error: errorMessage });
-
-          if (onError) {
-            const shouldContinue = onError(err instanceof Error ? err : new Error(errorMessage), item);
-            if (shouldContinue === false) {
-              shouldStop = true;
-            }
-          }
-        }
-      })
-    );
-
-    // Add delay between batches if specified (for rate limiting)
-    if (batchDelay > 0 && chunkIndex < chunks.length - 1) {
-      await sleep(batchDelay);
-    }
-  }
-
-  return result;
-}
-
-/**
- * Execute operations sequentially (one at a time)
- * Useful when operations must be processed in order
- */
-export async function executeSequential<T, R = void>(
-  options: Omit<BulkOperationOptions<T>, 'concurrency'>,
-  operation: (item: T) => Promise<R>
-): Promise<BulkOperationResult<T, R>> {
-  return executeBulk({ ...options, concurrency: 1 }, operation);
-}
-
-/**
- * Create a progress reporter for bulk operations
- */
-export function createProgressReporter(prefix: string = 'Processing') {
-  let lastPercent = -1;
-
-  return (current: number, total: number, _item: unknown): void => {
-    const percent = Math.floor((current / total) * 100);
-    if (percent !== lastPercent) {
-      lastPercent = percent;
-      process.stdout.write(`\r${prefix}: ${current}/${total} (${percent}%)`);
-      if (current === total) {
-        process.stdout.write('\n');
-      }
-    }
-  };
-}
-
-/**
- * Format bulk operation result for display
- */
-export function formatBulkResult<T>(result: BulkOperationResult<T, unknown>): string {
-  const lines: string[] = [
-    `Total: ${result.total}`,
-    `Success: ${result.success}`,
-    `Failed: ${result.failed}`,
-  ];
-
-  if (result.skipped > 0) {
-    lines.push(`Skipped (dry run): ${result.skipped}`);
-  }
-
-  if (result.errors.length > 0) {
-    lines.push('');
-    lines.push('Errors:');
-    for (const { error } of result.errors.slice(0, 10)) {
-      lines.push(`  - ${error}`);
-    }
-    if (result.errors.length > 10) {
-      lines.push(`  ... and ${result.errors.length - 10} more errors`);
-    }
-  }
-
-  return lines.join('\n');
-}

package/connectors/connect-godaddy/src/utils/settings.ts

@@ -1,114 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { getConfigDir, ensureConfigDir } from './config';
-
-// ============================================
-// Settings Storage Utility
-// ============================================
-
-/**
- * TODO: Define your connector-specific settings
- * Add fields for user preferences, defaults, etc.
- */
-export interface Settings {
-  // Display settings
-  defaultFormat: 'json' | 'table' | 'pretty';
-
-  // Behavior settings
-  confirmDestructive: boolean;  // Require confirmation for destructive operations
-  verboseOutput: boolean;       // Enable verbose output by default
-
-  // API settings
-  defaultMaxResults: number;    // Default page size for list operations
-  requestTimeout: number;       // Request timeout in ms
-
-  // Add more settings as needed for your connector
-}
-
-const DEFAULT_SETTINGS: Settings = {
-  defaultFormat: 'pretty',
-  confirmDestructive: true,
-  verboseOutput: false,
-  defaultMaxResults: 20,
-  requestTimeout: 30000,
-};
-
-function getSettingsPath(): string {
-  return join(getConfigDir(), 'settings.json');
-}
-
-/**
- * Load settings from disk, merging with defaults
- */
-export function loadSettings(): Settings {
-  ensureConfigDir();
-  const filepath = getSettingsPath();
-
-  if (!existsSync(filepath)) {
-    // Create default settings file
-    saveSettings(DEFAULT_SETTINGS);
-    return DEFAULT_SETTINGS;
-  }
-
-  try {
-    const content = readFileSync(filepath, 'utf-8');
-    const loaded = JSON.parse(content);
-    // Merge with defaults to ensure all fields exist
-    return { ...DEFAULT_SETTINGS, ...loaded };
-  } catch {
-    return DEFAULT_SETTINGS;
-  }
-}
-
-/**
- * Save settings to disk
- */
-export function saveSettings(settings: Settings): void {
-  ensureConfigDir();
-  const filepath = getSettingsPath();
-  writeFileSync(filepath, JSON.stringify(settings, null, 2));
-}
-
-/**
- * Get a specific setting value
- */
-export function getSetting<K extends keyof Settings>(key: K): Settings[K] {
-  return loadSettings()[key];
-}
-
-/**
- * Set a specific setting value
- */
-export function setSetting<K extends keyof Settings>(key: K, value: Settings[K]): void {
-  const settings = loadSettings();
-  settings[key] = value;
-  saveSettings(settings);
-}
-
-/**
- * Reset settings to defaults
- */
-export function resetSettings(): void {
-  saveSettings(DEFAULT_SETTINGS);
-}
-
-/**
- * Get default settings (useful for CLI help text)
- */
-export function getDefaultSettings(): Settings {
-  return { ...DEFAULT_SETTINGS };
-}
-
-/**
- * Check if verbose output is enabled
- */
-export function isVerbose(): boolean {
-  return loadSettings().verboseOutput;
-}
-
-/**
- * Check if destructive operations need confirmation
- */
-export function needsConfirmation(): boolean {
-  return loadSettings().confirmDestructive;
-}