@hasna/connectors 1.3.3 → 1.3.6

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

@@ -1,51 +1,76 @@
-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);
+import type { GoDaddyConfig } from '../types';
+import { GoDaddyClient } from './client';
+import { DomainsApi } from './domains';
+import { DnsApi } from './dns';
+import {
+  getApiKey,
+  getApiSecret,
+} from '../utils/config';
+
+export class GoDaddy {
+  private readonly client: GoDaddyClient;
+
+  // API modules
+  public readonly domains: DomainsApi;
+  public readonly dns: DnsApi;
+
+  constructor(config: GoDaddyConfig) {
+    this.client = new GoDaddyClient(config);
+    this.domains = new DomainsApi(this.client);
+    this.dns = new DnsApi(this.client);
   }
 
   /**
-   * Create a client from environment variables
-   * TODO: Update env var names for your API
-   * Looks for CONNECTOR_API_KEY and optionally CONNECTOR_API_SECRET
+   * Create a GoDaddy client from config file or environment variables
+   * Priority: env vars > config file
    */
-  static fromEnv(): Connector {
-    const apiKey = process.env.CONNECTOR_API_KEY;
-    const apiSecret = process.env.CONNECTOR_API_SECRET;
+  static create(): GoDaddy {
+    const apiKey = getApiKey();
+    const apiSecret = getApiSecret();
 
-    if (!apiKey) {
-      throw new Error('CONNECTOR_API_KEY environment variable is required');
+    if (!apiKey || !apiSecret) {
+      throw new Error(
+        'GoDaddy credentials not configured. ' +
+        'Set GODADDY_API_KEY and GODADDY_API_SECRET environment variables, ' +
+        'or run "connect-godaddy config set-credentials <key> <secret>"'
+      );
     }
-    return new Connector({ apiKey, apiSecret });
+
+    return new GoDaddy({ apiKey, apiSecret });
+  }
+
+  /**
+   * Create a GoDaddy client from environment variables only
+   */
+  static fromEnv(): GoDaddy {
+    const apiKey = process.env.GODADDY_API_KEY;
+    const apiSecret = process.env.GODADDY_API_SECRET;
+
+    if (!apiKey || !apiSecret) {
+      throw new Error(
+        'GODADDY_API_KEY and GODADDY_API_SECRET environment variables are required'
+      );
+    }
+
+    return new GoDaddy({ apiKey, apiSecret });
   }
 
   /**
-   * Get a preview of the API key (for debugging)
+   * Get a preview of the credentials (for debugging)
    */
-  getApiKeyPreview(): string {
-    return this.client.getApiKeyPreview();
+  getCredentialPreview(): string {
+    return this.client.getCredentialPreview();
   }
 
   /**
    * Get the underlying client for direct API access
    */
-  getClient(): ConnectorClient {
+  getClient(): GoDaddyClient {
     return this.client;
   }
 }
 
-export { ConnectorClient } from './client';
-export { ExampleApi } from './example';
+// Export the client and all API modules
+export { GoDaddyClient } from './client';
+export { DomainsApi } from './domains';
+export { DnsApi } from './dns';

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

@@ -1,12 +1,14 @@
 #!/usr/bin/env bun
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { Connector } from '../api';
+import { GoDaddy } from '../api';
 import {
   getApiKey,
-  setApiKey,
+  getApiSecret,
+  setCredentials,
   clearConfig,
   getConfigDir,
+  isAuthenticated,
   setProfileOverride,
   getCurrentProfile,
   setCurrentProfile,
@@ -19,44 +21,31 @@ import {
 import type { OutputFormat } from '../utils/output';
 import { success, error, info, print, warn, setVerboseMode, debug } from '../utils/output';
 
-// TODO: Update connector name and version
-const CONNECTOR_NAME = 'connector';
-const VERSION = '0.1.0';
-
 const program = new Command();
 
 program
-  .name(CONNECTOR_NAME)
-  .description('API connector CLI - TODO: Add your description')
-  .version(VERSION)
-  .option('-k, --api-key <key>', 'API key (overrides config)')
+  .name('connect-godaddy')
+  .description('GoDaddy API connector CLI - Manage domains, DNS records, and availability')
+  .version('0.1.0')
   .option('-f, --format <format>', 'Output format (json, pretty)', 'pretty')
   .option('-p, --profile <profile>', 'Use a specific profile')
   .option('-v, --verbose', 'Enable verbose output for debugging')
   .hook('preAction', (thisCommand) => {
     const opts = thisCommand.opts();
 
-    // Enable verbose mode if flag is set
     if (opts.verbose) {
       setVerboseMode(true);
       debug('Verbose mode enabled');
     }
 
-    // Set profile override before any command runs
     if (opts.profile) {
       if (!profileExists(opts.profile)) {
-        error(`Profile "${opts.profile}" does not exist. Create it with "${CONNECTOR_NAME} profile create ${opts.profile}"`);
+        error(`Profile "${opts.profile}" does not exist. Create it with "connect-godaddy profile create ${opts.profile}"`);
         process.exit(1);
       }
       setProfileOverride(opts.profile);
       debug(`Using profile: ${opts.profile}`);
     }
-
-    // Set API key from flag if provided
-    if (opts.apiKey) {
-      process.env.CONNECTOR_API_KEY = opts.apiKey;
-      debug('API key set from command line flag');
-    }
   });
 
 // Helper to get output format
@@ -66,13 +55,12 @@ function getFormat(cmd: Command): OutputFormat {
 }
 
 // Helper to get authenticated client
-function getClient(): Connector {
-  const apiKey = getApiKey();
-  if (!apiKey) {
-    error(`No API key configured. Run "${CONNECTOR_NAME} config set-key <key>" or set CONNECTOR_API_KEY environment variable.`);
+function requireAuth(): GoDaddy {
+  if (!isAuthenticated()) {
+    error('Not authenticated. Run "connect-godaddy config set-credentials <key> <secret>" or set GODADDY_API_KEY and GODADDY_API_SECRET.');
     process.exit(1);
   }
-  return new Connector({ apiKey });
+  return GoDaddy.create();
 }
 
 // ============================================
@@ -94,7 +82,7 @@ profileCmd
       return;
     }
 
-    success(`Profiles:`);
+    success('Profiles:');
     profiles.forEach(p => {
       const isActive = p === current ? chalk.green(' (active)') : '';
       console.log(`  ${p}${isActive}`);
@@ -117,6 +105,7 @@ profileCmd
   .command('create <name>')
   .description('Create a new profile')
   .option('--api-key <key>', 'API key')
+  .option('--api-secret <secret>', 'API secret')
   .option('--use', 'Switch to this profile after creation')
   .action((name: string, opts) => {
     if (profileExists(name)) {
@@ -126,6 +115,7 @@ profileCmd
 
     createProfile(name, {
       apiKey: opts.apiKey,
+      apiSecret: opts.apiSecret,
     });
     success(`Profile "${name}" created`);
 
@@ -161,6 +151,7 @@ profileCmd
 
     console.log(chalk.bold(`Profile: ${profileName}${profileName === active ? chalk.green(' (active)') : ''}`));
     info(`API Key: ${config.apiKey ? `${config.apiKey.substring(0, 8)}...` : chalk.gray('not set')}`);
+    info(`API Secret: ${config.apiSecret ? `${config.apiSecret.substring(0, 4)}...` : chalk.gray('not set')}`);
   });
 
 // ============================================
@@ -168,14 +159,15 @@ profileCmd
 // ============================================
 const configCmd = program
   .command('config')
-  .description('Manage CLI configuration (for active profile)');
+  .description('Manage CLI configuration');
 
 configCmd
-  .command('set-key <apiKey>')
-  .description('Set API key')
-  .action((apiKey: string) => {
-    setApiKey(apiKey);
-    success(`API key saved to profile: ${getCurrentProfile()}`);
+  .command('set-credentials <apiKey> <apiSecret>')
+  .description('Set GoDaddy API key and secret')
+  .action((apiKey: string, apiSecret: string) => {
+    setCredentials(apiKey, apiSecret);
+    success(`Credentials saved to profile: ${getCurrentProfile()}`);
+    info(`Config stored in: ${getConfigDir()}`);
   });
 
 configCmd
@@ -184,10 +176,13 @@ configCmd
   .action(() => {
     const profileName = getCurrentProfile();
     const apiKey = getApiKey();
+    const apiSecret = getApiSecret();
 
     console.log(chalk.bold(`Active Profile: ${profileName}`));
     info(`Config directory: ${getConfigDir()}`);
+    info(`Authenticated: ${isAuthenticated() ? chalk.green('Yes') : chalk.red('No')}`);
     info(`API Key: ${apiKey ? `${apiKey.substring(0, 8)}...` : chalk.gray('not set')}`);
+    info(`API Secret: ${apiSecret ? `${apiSecret.substring(0, 4)}...` : chalk.gray('not set')}`);
   });
 
 configCmd
@@ -199,51 +194,199 @@ configCmd
   });
 
 // ============================================
-// Example API Commands - TODO: Replace with your API commands
+// Domains Commands
 // ============================================
-const exampleCmd = program
-  .command('example')
-  .description('Example API commands (replace with your commands)');
+const domainsCmd = program
+  .command('domains')
+  .description('Domain management commands');
 
-exampleCmd
+domainsCmd
   .command('list')
-  .description('List resources')
-  .option('-n, --max <number>', 'Maximum results', '10')
+  .description('List all domains in your account')
+  .option('-l, --limit <limit>', 'Maximum domains to return')
+  .option('-s, --statuses <statuses>', 'Filter by status (comma-separated: ACTIVE,EXPIRED)')
   .action(async (opts) => {
     try {
-      const client = getClient();
-      const result = await client.example.list({ maxResults: parseInt(opts.max) });
-      print(result, getFormat(exampleCmd));
+      const gd = requireAuth();
+      const params: { limit?: number; statuses?: string[] } = {};
+      if (opts.limit) params.limit = parseInt(opts.limit);
+      if (opts.statuses) params.statuses = opts.statuses.split(',');
+
+      const domains = await gd.domains.list(params);
+
+      if (!domains || domains.length === 0) {
+        info('No domains found');
+        return;
+      }
+
+      const formatted = domains.map(d => ({
+        domain: d.domain,
+        status: d.status,
+        expires: d.expires ? new Date(d.expires).toLocaleDateString() : 'N/A',
+        autoRenew: d.renewAuto ? 'Yes' : 'No',
+        nameservers: d.nameServers?.join(', ') || '',
+      }));
+
+      success(`Found ${domains.length} domain(s):`);
+      print(formatted, getFormat(domainsCmd));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+domainsCmd
+  .command('get <domain>')
+  .description('Get detailed information for a domain')
+  .action(async (domain: string) => {
+    try {
+      const gd = requireAuth();
+      const detail = await gd.domains.getInfo(domain);
+      print(detail, getFormat(domainsCmd));
     } catch (err) {
       error(String(err));
       process.exit(1);
     }
   });
 
-exampleCmd
-  .command('get <id>')
-  .description('Get a resource by ID')
-  .action(async (id: string) => {
+domainsCmd
+  .command('renew <domain>')
+  .description('Renew a domain')
+  .option('-y, --years <years>', 'Number of years to renew', '1')
+  .action(async (domain: string, opts) => {
     try {
-      const client = getClient();
-      const result = await client.example.get(id);
-      print(result, getFormat(exampleCmd));
+      const gd = requireAuth();
+      const result = await gd.domains.renew(domain, parseInt(opts.years));
+      success(`Domain "${domain}" renewed!`);
+      info(`Order ID: ${result.orderId}`);
+      info(`Total: ${result.total}`);
     } catch (err) {
       error(String(err));
       process.exit(1);
     }
   });
 
-exampleCmd
-  .command('create')
-  .description('Create a new resource')
-  .requiredOption('-n, --name <name>', 'Resource name')
-  .action(async (opts) => {
+domainsCmd
+  .command('available <domain>')
+  .description('Check if a domain is available for purchase')
+  .action(async (domain: string) => {
     try {
-      const client = getClient();
-      const result = await client.example.create({ name: opts.name });
-      success('Resource created!');
-      print(result, getFormat(exampleCmd));
+      const gd = requireAuth();
+      const result = await gd.domains.checkAvailability(domain);
+
+      if (result.available) {
+        success(`${domain} is available!`);
+        info(`Price: ${result.price} ${result.currency}`);
+        info(`Period: ${result.period} year(s)`);
+      } else {
+        warn(`${domain} is not available`);
+      }
+
+      print(result, getFormat(domainsCmd));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// DNS Commands
+// ============================================
+const dnsCmd = program
+  .command('dns')
+  .description('DNS record management commands');
+
+dnsCmd
+  .command('list <domain>')
+  .description('List DNS records for a domain')
+  .option('-t, --type <type>', 'Filter by record type (A, AAAA, CNAME, TXT, MX, etc.)')
+  .action(async (domain: string, opts) => {
+    try {
+      const gd = requireAuth();
+      const records = await gd.dns.getRecords(domain, opts.type);
+
+      if (!records || records.length === 0) {
+        info('No DNS records found');
+        return;
+      }
+
+      const formatted = records.map(r => ({
+        type: r.type,
+        name: r.name,
+        data: r.data.length > 50 ? r.data.substring(0, 50) + '...' : r.data,
+        ttl: r.ttl,
+        priority: r.priority ?? '-',
+      }));
+
+      success(`Found ${records.length} record(s):`);
+      print(formatted, getFormat(dnsCmd));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+dnsCmd
+  .command('get <domain> <type> <name>')
+  .description('Get DNS records by type and name')
+  .action(async (domain: string, type: string, name: string) => {
+    try {
+      const gd = requireAuth();
+      const records = await gd.dns.getRecordsByName(domain, type.toUpperCase(), name);
+      print(records, getFormat(dnsCmd));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+dnsCmd
+  .command('set <domain> <type>')
+  .description('Set DNS records for a domain by type (replaces existing records of that type)')
+  .requiredOption('-r, --records <json>', 'JSON array of records [{name, data, ttl, priority?}]')
+  .action(async (domain: string, type: string, opts) => {
+    try {
+      const gd = requireAuth();
+      const records = JSON.parse(opts.records);
+
+      if (!Array.isArray(records)) {
+        error('Records must be a JSON array');
+        process.exit(1);
+      }
+
+      await gd.dns.setRecords(domain, type.toUpperCase(), records);
+      success(`DNS records of type ${type.toUpperCase()} set for ${domain}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+dnsCmd
+  .command('add <domain>')
+  .description('Add a DNS record to a domain')
+  .requiredOption('-t, --type <type>', 'Record type (A, AAAA, CNAME, TXT, MX, etc.)')
+  .requiredOption('-n, --name <name>', 'Record name (@ for root)')
+  .requiredOption('-d, --data <data>', 'Record data (IP address, hostname, text, etc.)')
+  .option('--ttl <ttl>', 'TTL in seconds', '3600')
+  .option('--priority <priority>', 'Priority (for MX records)')
+  .action(async (domain: string, opts) => {
+    try {
+      const gd = requireAuth();
+      const record: Record<string, unknown> = {
+        type: opts.type.toUpperCase(),
+        name: opts.name,
+        data: opts.data,
+        ttl: parseInt(opts.ttl),
+      };
+
+      if (opts.priority !== undefined) {
+        record.priority = parseInt(opts.priority);
+      }
+
+      await gd.dns.addRecords(domain, [record as any]);
+      success(`DNS record added to ${domain}`);
+      info(`Type: ${opts.type.toUpperCase()}, Name: ${opts.name}, Data: ${opts.data}`);
     } catch (err) {
       error(String(err));
       process.exit(1);

package/connectors/connect-godaddy/src/index.ts

@@ -1,11 +1,15 @@
-// Connector API
-// A TypeScript wrapper for your API - TODO: Update description
+// GoDaddy API Connector
+// A TypeScript wrapper for the GoDaddy API with multi-profile support
 
-export { Connector } from './api';
+export { GoDaddy } from './api';
 export * from './types';
 
 // Re-export individual API classes for advanced usage
-export { ConnectorClient, ExampleApi } from './api';
+export {
+  GoDaddyClient,
+  DomainsApi,
+  DnsApi,
+} from './api';
 
 // Export config utilities
 export {
@@ -13,8 +17,8 @@ export {
   setApiKey,
   getApiSecret,
   setApiSecret,
-  getToken,
-  setToken,
+  setCredentials,
+  isAuthenticated,
   getCurrentProfile,
   setCurrentProfile,
   listProfiles,
@@ -23,68 +27,8 @@ export {
   loadProfile,
   saveProfile,
   clearConfig,
-  getOAuthConfig,
-  setOAuthConfig,
-  loadOAuthTokens,
-  saveOAuthTokens,
-  clearOAuthTokens,
-  getAccessToken,
 } from './utils/config';
 
-// Export OAuth2 utilities
-export {
-  getAuthUrl,
-  exchangeCodeForTokens,
-  refreshAccessToken,
-  startCallbackServer,
-  getValidAccessToken,
-  isAuthenticated,
-  getRedirectUri,
-  getRedirectPort,
-  type AuthResult,
-  type AuthUrlOptions,
-} from './utils/auth';
-
-// Export settings utilities
-export {
-  loadSettings,
-  saveSettings,
-  getSetting,
-  setSetting,
-  resetSettings,
-  getDefaultSettings,
-  isVerbose,
-  needsConfirmation,
-  type Settings,
-} from './utils/settings';
-
-// Export storage utilities
-export {
-  saveEntity,
-  getEntity,
-  entityExists,
-  getAllEntities,
-  deleteEntity,
-  searchEntities,
-  searchEntitiesByText,
-  countEntities,
-  clearEntities,
-  createStorage,
-  type Storable,
-} from './utils/storage';
-
-// Export bulk operation utilities
-export {
-  executeBulk,
-  executeSequential,
-  chunkArray,
-  sleep,
-  createProgressReporter,
-  formatBulkResult,
-  type BulkOperationOptions,
-  type BulkOperationResult,
-} from './utils/bulk';
-
 // Export output utilities
 export {
   formatOutput,