@hasna/connectors 1.3.2 → 1.3.5

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

@@ -0,0 +1,169 @@
+import type { GitHubClient } from './client';
+import type {
+  Workflow,
+  WorkflowRun,
+  WorkflowJob,
+  ListWorkflowRunsOptions,
+  WorkflowDispatchOptions,
+} from '../types';
+
+/**
+ * GitHub Actions / Workflows API
+ */
+export class WorkflowsApi {
+  constructor(private readonly client: GitHubClient) {}
+
+  // ============================================
+  // Workflows
+  // ============================================
+
+  /**
+   * List workflows in a repository
+   */
+  async list(
+    owner: string,
+    repo: string,
+    options?: { per_page?: number; page?: number }
+  ): Promise<{ total_count: number; workflows: Workflow[] }> {
+    return this.client.get(`/repos/${owner}/${repo}/actions/workflows`, options);
+  }
+
+  /**
+   * Get a workflow by ID or filename (e.g. "ci.yml")
+   */
+  async get(owner: string, repo: string, workflowId: number | string): Promise<Workflow> {
+    return this.client.get<Workflow>(`/repos/${owner}/${repo}/actions/workflows/${workflowId}`);
+  }
+
+  /**
+   * Enable a workflow
+   */
+  async enable(owner: string, repo: string, workflowId: number | string): Promise<void> {
+    await this.client.put(`/repos/${owner}/${repo}/actions/workflows/${workflowId}/enable`, {});
+  }
+
+  /**
+   * Disable a workflow
+   */
+  async disable(owner: string, repo: string, workflowId: number | string): Promise<void> {
+    await this.client.put(`/repos/${owner}/${repo}/actions/workflows/${workflowId}/disable`, {});
+  }
+
+  /**
+   * Trigger a workflow run (workflow_dispatch event)
+   */
+  async trigger(
+    owner: string,
+    repo: string,
+    workflowId: number | string,
+    options: WorkflowDispatchOptions
+  ): Promise<void> {
+    await this.client.post(
+      `/repos/${owner}/${repo}/actions/workflows/${workflowId}/dispatches`,
+      options
+    );
+  }
+
+  // ============================================
+  // Workflow Runs
+  // ============================================
+
+  /**
+   * List workflow runs for a workflow
+   */
+  async listRuns(
+    owner: string,
+    repo: string,
+    workflowId: number | string,
+    options?: ListWorkflowRunsOptions
+  ): Promise<{ total_count: number; workflow_runs: WorkflowRun[] }> {
+    return this.client.get(
+      `/repos/${owner}/${repo}/actions/workflows/${workflowId}/runs`,
+      options as Record<string, string | number | boolean | undefined>
+    );
+  }
+
+  /**
+   * List all workflow runs for a repository
+   */
+  async listAllRuns(
+    owner: string,
+    repo: string,
+    options?: ListWorkflowRunsOptions
+  ): Promise<{ total_count: number; workflow_runs: WorkflowRun[] }> {
+    return this.client.get(
+      `/repos/${owner}/${repo}/actions/runs`,
+      options as Record<string, string | number | boolean | undefined>
+    );
+  }
+
+  /**
+   * Get a workflow run
+   */
+  async getRun(owner: string, repo: string, runId: number): Promise<WorkflowRun> {
+    return this.client.get<WorkflowRun>(`/repos/${owner}/${repo}/actions/runs/${runId}`);
+  }
+
+  /**
+   * Cancel a workflow run
+   */
+  async cancelRun(owner: string, repo: string, runId: number): Promise<void> {
+    await this.client.post(`/repos/${owner}/${repo}/actions/runs/${runId}/cancel`, {});
+  }
+
+  /**
+   * Re-run a workflow run
+   */
+  async rerunRun(owner: string, repo: string, runId: number): Promise<void> {
+    await this.client.post(`/repos/${owner}/${repo}/actions/runs/${runId}/rerun`, {});
+  }
+
+  /**
+   * Delete a workflow run
+   */
+  async deleteRun(owner: string, repo: string, runId: number): Promise<void> {
+    await this.client.delete(`/repos/${owner}/${repo}/actions/runs/${runId}`);
+  }
+
+  /**
+   * Download workflow run logs URL
+   */
+  async getRunLogsUrl(owner: string, repo: string, runId: number): Promise<string> {
+    // Returns a redirect — we return the Location header URL
+    const response = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/actions/runs/${runId}/logs`,
+      {
+        method: 'GET',
+        redirect: 'manual',
+        headers: this.client.getAuthHeaders(),
+      }
+    );
+    return response.headers.get('location') || '';
+  }
+
+  // ============================================
+  // Jobs
+  // ============================================
+
+  /**
+   * List jobs for a workflow run
+   */
+  async listJobs(
+    owner: string,
+    repo: string,
+    runId: number,
+    options?: { filter?: 'latest' | 'all'; per_page?: number; page?: number }
+  ): Promise<{ total_count: number; jobs: WorkflowJob[] }> {
+    return this.client.get(
+      `/repos/${owner}/${repo}/actions/runs/${runId}/jobs`,
+      options as Record<string, string | number | boolean | undefined>
+    );
+  }
+
+  /**
+   * Get a job for a workflow run
+   */
+  async getJob(owner: string, repo: string, jobId: number): Promise<WorkflowJob> {
+    return this.client.get<WorkflowJob>(`/repos/${owner}/${repo}/actions/jobs/${jobId}`);
+  }
+}

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

@@ -495,3 +495,193 @@ export class GitHubApiError extends Error {
     this.documentationUrl = documentationUrl;
   }
 }
+
+// ============================================
+// Releases
+// ============================================
+
+export interface ReleaseAsset {
+  id: number;
+  url: string;
+  browser_download_url: string;
+  name: string;
+  label: string | null;
+  state: 'uploaded' | 'open';
+  content_type: string;
+  size: number;
+  download_count: number;
+  created_at: string;
+  updated_at: string;
+  uploader: User;
+}
+
+export interface Release {
+  id: number;
+  url: string;
+  html_url: string;
+  assets_url: string;
+  upload_url: string;
+  tarball_url: string | null;
+  zipball_url: string | null;
+  tag_name: string;
+  target_commitish: string;
+  name: string | null;
+  body: string | null;
+  draft: boolean;
+  prerelease: boolean;
+  created_at: string;
+  published_at: string | null;
+  author: User;
+  assets: ReleaseAsset[];
+}
+
+export interface CreateReleaseOptions {
+  target_commitish?: string;
+  name?: string;
+  body?: string;
+  draft?: boolean;
+  prerelease?: boolean;
+  generate_release_notes?: boolean;
+  make_latest?: 'true' | 'false' | 'legacy';
+}
+
+export interface UpdateReleaseOptions {
+  tag_name?: string;
+  target_commitish?: string;
+  name?: string;
+  body?: string;
+  draft?: boolean;
+  prerelease?: boolean;
+  make_latest?: 'true' | 'false' | 'legacy';
+}
+
+// ============================================
+// Actions / Workflows
+// ============================================
+
+export interface Workflow {
+  id: number;
+  node_id: string;
+  name: string;
+  path: string;
+  state: 'active' | 'deleted' | 'disabled_fork' | 'disabled_inactivity' | 'disabled_manually';
+  created_at: string;
+  updated_at: string;
+  url: string;
+  html_url: string;
+  badge_url: string;
+}
+
+export interface WorkflowRun {
+  id: number;
+  name: string | null;
+  node_id: string;
+  head_branch: string | null;
+  head_sha: string;
+  run_number: number;
+  run_attempt: number;
+  event: string;
+  status: 'queued' | 'in_progress' | 'completed' | 'waiting' | 'requested' | 'pending' | null;
+  conclusion: 'success' | 'failure' | 'neutral' | 'cancelled' | 'skipped' | 'timed_out' | 'action_required' | 'startup_failure' | null;
+  workflow_id: number;
+  url: string;
+  html_url: string;
+  created_at: string;
+  updated_at: string;
+  run_started_at: string;
+  actor: User;
+  triggering_actor: User;
+}
+
+export interface WorkflowJobStep {
+  name: string;
+  status: 'queued' | 'in_progress' | 'completed';
+  conclusion: string | null;
+  number: number;
+  started_at: string | null;
+  completed_at: string | null;
+}
+
+export interface WorkflowJob {
+  id: number;
+  run_id: number;
+  node_id: string;
+  head_sha: string;
+  url: string;
+  html_url: string;
+  status: 'queued' | 'in_progress' | 'completed' | 'waiting';
+  conclusion: 'success' | 'failure' | 'neutral' | 'cancelled' | 'skipped' | 'timed_out' | 'action_required' | null;
+  name: string;
+  steps: WorkflowJobStep[];
+  started_at: string;
+  completed_at: string | null;
+  runner_name: string | null;
+  runner_group_name: string | null;
+}
+
+export interface WorkflowDispatchOptions {
+  ref: string;
+  inputs?: Record<string, string>;
+}
+
+export interface ListWorkflowRunsOptions {
+  actor?: string;
+  branch?: string;
+  event?: string;
+  status?: 'queued' | 'in_progress' | 'completed' | 'waiting' | 'requested' | 'pending' | 'action_required' | 'cancelled' | 'failure' | 'neutral' | 'skipped' | 'stale' | 'success' | 'timed_out' | 'startup_failure';
+  per_page?: number;
+  page?: number;
+  created?: string;
+  exclude_pull_requests?: boolean;
+  head_sha?: string;
+}
+
+// ============================================
+// Commits & Branches
+// ============================================
+
+export interface Branch {
+  name: string;
+  commit: {
+    sha: string;
+    url: string;
+  };
+  protected: boolean;
+}
+
+export interface CommitStatus {
+  id: number;
+  url: string;
+  state: 'error' | 'failure' | 'pending' | 'success';
+  description: string | null;
+  target_url: string | null;
+  context: string;
+  created_at: string;
+  updated_at: string;
+  creator: User;
+}
+
+export interface CreateCommitStatusOptions {
+  state: 'error' | 'failure' | 'pending' | 'success';
+  target_url?: string;
+  description?: string;
+  context?: string;
+}
+
+export interface CompareResult {
+  url: string;
+  html_url: string;
+  status: 'diverged' | 'ahead' | 'behind' | 'identical';
+  ahead_by: number;
+  behind_by: number;
+  total_commits: number;
+  commits: Commit[];
+  files: Array<{
+    filename: string;
+    status: string;
+    additions: number;
+    deletions: number;
+    changes: number;
+    patch?: string;
+  }>;
+}

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

@@ -131,24 +131,13 @@ authCmd
         saveTokens(result.tokens);
       }
 
-      // Fetch user email and display name, save to the active profile
+      // Fetch user email and save it to the active profile
       try {
         const gmail = Gmail.create();
         const profile = await gmail.profile.get();
         const email = profile.emailAddress;
         setUserEmail(email);
         info(`Email: ${email}`);
-
-        // Try to get display name from Gmail send-as settings
-        try {
-          const displayName = await gmail.profile.getDisplayName();
-          if (displayName) {
-            setUserName(displayName);
-            info(`Name: ${displayName}`);
-          }
-        } catch {
-          // Display name fetch failed — not critical
-        }
       } catch (err) {
         // Email fetch failed but auth succeeded — tokens are saved
         warn(`Could not fetch email address: ${err}`);
@@ -553,29 +542,11 @@ messagesCmd
         if (exactMatch) {
           body = exactMatch.data;
         } else {
-          // Fallback: if looking for text/plain but only text/html exists, strip HTML
+          // Fallback: if looking for text/plain but only text/html exists, use that
           // Or if looking for text/html but only text/plain exists, use that
           const altMatch = textParts.find(p => p.mimeType.startsWith('text/'));
           if (altMatch) {
-            if (!opts.html && altMatch.mimeType === 'text/html') {
-              // Strip HTML to get readable plain text
-              body = altMatch.data
-                .replace(/<br\s*\/?>/gi, '\n')
-                .replace(/<\/p>/gi, '\n\n')
-                .replace(/<\/div>/gi, '\n')
-                .replace(/<\/li>/gi, '\n')
-                .replace(/<[^>]+>/g, '')
-                .replace(/&nbsp;/g, ' ')
-                .replace(/&amp;/g, '&')
-                .replace(/&lt;/g, '<')
-                .replace(/&gt;/g, '>')
-                .replace(/&quot;/g, '"')
-                .replace(/&#39;/g, "'")
-                .replace(/\n{3,}/g, '\n\n')
-                .trim();
-            } else {
-              body = altMatch.data;
-            }
+            body = altMatch.data;
           }
         }
       }

package/connectors/connect-godaddy/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hasna/connect-godaddy",
   "version": "0.1.0",
-  "description": "Connector: connect-godaddy",
+  "description": "GoDaddy API connector CLI - Manage domains, DNS records, and availability checks",
   "type": "module",
   "bin": {
     "connect-godaddy": "./bin/index.js"
@@ -17,11 +17,14 @@
   "scripts": {
     "build": "bun build ./src/index.ts --outdir ./dist --target bun && bun build ./src/cli/index.ts --outdir ./bin --target bun",
     "dev": "bun run ./src/cli/index.ts",
+    "test": "bun test",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "bun run build"
   },
   "keywords": [
     "godaddy",
+    "domains",
+    "dns",
     "api",
     "connector",
     "cli",

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

@@ -1,34 +1,29 @@
-import type { ConnectorConfig, OutputFormat } from '../types';
-import { ConnectorApiError, parseApiError } from '../types';
+import type { GoDaddyConfig } from '../types';
+import { GoDaddyApiError, parseApiError } from '../types';
 
-// TODO: Replace with your API's base URL
-const DEFAULT_BASE_URL = 'https://api.example.com';
+const DEFAULT_BASE_URL = 'https://api.godaddy.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 {
+export class GoDaddyClient {
   private readonly apiKey: string;
-  private readonly apiSecret?: string;
+  private readonly apiSecret: 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');
+  constructor(config: GoDaddyConfig) {
+    if (!config.apiKey || !config.apiSecret) {
+      throw new Error('Both apiKey and apiSecret are required for GoDaddy API authentication');
     }
-    this.apiKey = key;
+    this.apiKey = config.apiKey;
     this.apiSecret = config.apiSecret;
     this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
   }
@@ -47,44 +42,25 @@ export class ConnectorClient {
     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}`,
+      'Authorization': `sso-key ${this.apiKey}:${this.apiSecret}`,
       'Accept': 'application/json',
       ...headers,
     };
@@ -107,7 +83,6 @@ export class ConnectorClient {
 
     for (let attempt = 0; attempt <= retries; attempt++) {
       try {
-        // Create abort controller for timeout
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), timeout);
 
@@ -143,9 +118,7 @@ export class ConnectorClient {
 
         // 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
@@ -162,13 +135,11 @@ export class ConnectorClient {
       } 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)) {
+        if (attempt < retries && !(err instanceof GoDaddyApiError)) {
           await this.sleep(this.getRetryDelay(attempt));
           continue;
         }
@@ -177,8 +148,7 @@ export class ConnectorClient {
       }
     }
 
-    // Should not reach here, but just in case
-    throw lastError || new ConnectorApiError('Request failed', lastStatus);
+    throw lastError || new GoDaddyApiError('Request failed', lastStatus);
   }
 
   async get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
@@ -189,7 +159,7 @@ export class ConnectorClient {
     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> {
+  async put<T>(path: string, body?: Record<string, unknown> | 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 });
   }
 
@@ -201,13 +171,10 @@ export class ConnectorClient {
     return this.request<T>(path, { method: 'DELETE', params });
   }
 
-  /**
-   * Get a preview of the API key (for display/debugging)
-   */
-  getApiKeyPreview(): string {
+  getCredentialPreview(): string {
     if (this.apiKey.length > 10) {
-      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
+      return `Key: ${this.apiKey.substring(0, 6)}...`;
     }
-    return '***';
+    return 'Key: ***';
   }
 }

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

@@ -0,0 +1,65 @@
+import type { GoDaddyClient } from './client';
+import type { GoDaddyDnsRecord } from '../types';
+
+export class DnsApi {
+  constructor(private readonly client: GoDaddyClient) {}
+
+  /**
+   * Get all DNS records for a domain, optionally filtered by type
+   */
+  async getRecords(domain: string, type?: string): Promise<GoDaddyDnsRecord[]> {
+    const path = type
+      ? `/v1/domains/${encodeURIComponent(domain)}/records/${encodeURIComponent(type)}`
+      : `/v1/domains/${encodeURIComponent(domain)}/records`;
+    return this.client.get<GoDaddyDnsRecord[]>(path);
+  }
+
+  /**
+   * Get DNS records for a domain filtered by type and name
+   */
+  async getRecordsByName(domain: string, type: string, name: string): Promise<GoDaddyDnsRecord[]> {
+    return this.client.get<GoDaddyDnsRecord[]>(
+      `/v1/domains/${encodeURIComponent(domain)}/records/${encodeURIComponent(type)}/${encodeURIComponent(name)}`
+    );
+  }
+
+  /**
+   * Replace all DNS records for a domain of a given type
+   */
+  async setRecords(domain: string, type: string, records: GoDaddyDnsRecord[]): Promise<void> {
+    await this.client.put<void>(
+      `/v1/domains/${encodeURIComponent(domain)}/records/${encodeURIComponent(type)}`,
+      records as unknown as Record<string, unknown>[]
+    );
+  }
+
+  /**
+   * Replace all DNS records for a domain
+   */
+  async replaceAllRecords(domain: string, records: GoDaddyDnsRecord[]): Promise<void> {
+    await this.client.put<void>(
+      `/v1/domains/${encodeURIComponent(domain)}/records`,
+      records as unknown as Record<string, unknown>[]
+    );
+  }
+
+  /**
+   * Add DNS records to a domain (append, does not replace)
+   */
+  async addRecords(domain: string, records: GoDaddyDnsRecord[]): Promise<void> {
+    await this.client.patch<void>(
+      `/v1/domains/${encodeURIComponent(domain)}/records`,
+      records as unknown as Record<string, unknown>[]
+    );
+  }
+
+  /**
+   * Replace DNS records for a domain by type and name
+   */
+  async setRecordsByName(domain: string, type: string, name: string, records: GoDaddyDnsRecord[]): Promise<void> {
+    await this.client.put<void>(
+      `/v1/domains/${encodeURIComponent(domain)}/records/${encodeURIComponent(type)}/${encodeURIComponent(name)}`,
+      records as unknown as Record<string, unknown>[]
+    );
+  }
+}