@dependabit/github-client 0.1.13 → 0.1.15

package/src/rate-limit.ts

@@ -1,210 +0,0 @@
-/**
- * Rate Limit Handler
- * Manages GitHub API rate limits and request budgeting
- */
-
-import { Octokit } from 'octokit';
-
-export interface RateLimitInfo {
-  limit: number;
-  remaining: number;
-  reset: Date;
-  used: number;
-  warning?: string;
-}
-
-export interface RateLimitStatus {
-  core: RateLimitInfo & { percentageRemaining: number };
-  search: RateLimitInfo & { percentageRemaining: number };
-  graphql: RateLimitInfo & { percentageRemaining: number };
-}
-
-export interface BudgetReservation {
-  reserved: boolean;
-  reason?: string;
-  waitTime?: number;
-}
-
-export class RateLimitHandler {
-  private octokit: Octokit;
-  private lastCheck?: RateLimitStatus;
-  private lastCheckTime?: Date;
-
-  constructor(auth?: string) {
-    this.octokit = new Octokit({
-      auth: auth || process.env['GITHUB_TOKEN']
-    });
-  }
-
-  /**
-   * Checks current rate limit status
-   */
-  async checkRateLimit(): Promise<RateLimitInfo> {
-    const response = await this.octokit.rest.rateLimit.get();
-    const { rate } = response.data;
-
-    const info: RateLimitInfo = {
-      limit: rate.limit,
-      remaining: rate.remaining,
-      reset: new Date(rate.reset * 1000),
-      used: rate.used
-    };
-
-    // Add warning if approaching limit
-    if (info.remaining < info.limit * 0.1) {
-      info.warning = `Only ${info.remaining} requests remaining. Reset at ${info.reset.toISOString()}`;
-    }
-
-    return info;
-  }
-
-  /**
-   * Waits if rate limited
-   */
-  async waitIfNeeded(): Promise<void> {
-    const rateLimit = await this.checkRateLimit();
-
-    if (rateLimit.remaining === 0) {
-      const waitTime = this.calculateWaitTime(rateLimit);
-      if (waitTime > 0) {
-        console.log(`Rate limited. Waiting ${Math.ceil(waitTime / 1000)} seconds until reset...`);
-        await new Promise((resolve) => setTimeout(resolve, waitTime));
-      }
-    }
-  }
-
-  /**
-   * Calculates wait time until rate limit resets
-   */
-  calculateWaitTime(rateLimitInfo: RateLimitInfo): number {
-    if (rateLimitInfo.remaining > 0) {
-      return 0;
-    }
-
-    const now = Date.now();
-    const resetTime = rateLimitInfo.reset.getTime();
-    const waitTime = Math.max(0, resetTime - now);
-
-    return waitTime;
-  }
-
-  /**
-   * Attempts to reserve API call budget with proactive checking
-   */
-  async reserveBudget(
-    callsNeeded: number,
-    options?: {
-      safetyMargin?: number; // Additional buffer (default: 10% of calls needed)
-      maxWaitTime?: number; // Max time to wait in ms
-    }
-  ): Promise<BudgetReservation> {
-    const safetyMargin = options?.safetyMargin ?? Math.ceil(callsNeeded * 0.1);
-    const totalNeeded = callsNeeded + safetyMargin;
-
-    const rateLimit = await this.checkRateLimit();
-
-    if (rateLimit.remaining >= totalNeeded) {
-      return {
-        reserved: true
-      };
-    }
-
-    const waitTime = this.calculateWaitTime(rateLimit);
-
-    // Check if wait time exceeds maximum allowed
-    if (options?.maxWaitTime && waitTime > options.maxWaitTime) {
-      return {
-        reserved: false,
-        reason: `Wait time (${Math.ceil(waitTime / 1000)}s) exceeds maximum (${Math.ceil(options.maxWaitTime / 1000)}s)`,
-        waitTime
-      };
-    }
-
-    return {
-      reserved: false,
-      reason: `Insufficient API quota. Need ${callsNeeded} + ${safetyMargin} margin, have ${rateLimit.remaining}`,
-      waitTime
-    };
-  }
-
-  /**
-   * Proactively check if operation can proceed without hitting rate limit
-   */
-  async canProceed(
-    estimatedCalls: number,
-    options?: {
-      threshold?: number; // Minimum remaining calls (default: 100)
-      safetyMargin?: number;
-    }
-  ): Promise<{ canProceed: boolean; reason?: string }> {
-    const threshold = options?.threshold ?? 100;
-    const safetyMargin = options?.safetyMargin ?? Math.ceil(estimatedCalls * 0.1);
-    const totalNeeded = estimatedCalls + safetyMargin;
-
-    const rateLimit = await this.checkRateLimit();
-
-    // Check if we have enough remaining calls
-    if (rateLimit.remaining < totalNeeded) {
-      return {
-        canProceed: false,
-        reason: `Insufficient quota: need ${totalNeeded}, have ${rateLimit.remaining}`
-      };
-    }
-
-    // Check if we'd drop below threshold
-    if (rateLimit.remaining - totalNeeded < threshold) {
-      return {
-        canProceed: false,
-        reason: `Operation would leave only ${rateLimit.remaining - totalNeeded} calls (threshold: ${threshold})`
-      };
-    }
-
-    return { canProceed: true };
-  }
-
-  /**
-   * Gets detailed rate limit status for all API categories
-   */
-  async getRateLimitStatus(): Promise<RateLimitStatus> {
-    const response = await this.octokit.rest.rateLimit.get();
-    const { resources } = response.data;
-
-    const createInfo = (resource: {
-      limit: number;
-      remaining: number;
-      reset: number;
-      used: number;
-    }): RateLimitInfo & { percentageRemaining: number } => ({
-      limit: resource.limit,
-      remaining: resource.remaining,
-      reset: new Date(resource.reset * 1000),
-      used: resource.used,
-      percentageRemaining: resource.limit > 0 ? (resource.remaining / resource.limit) * 100 : 0
-    });
-
-    const status: RateLimitStatus = {
-      core: createInfo(resources.core),
-      search: createInfo(resources.search),
-      graphql: createInfo(resources.graphql || { limit: 0, remaining: 0, reset: 0, used: 0 })
-    };
-
-    this.lastCheck = status;
-    this.lastCheckTime = new Date();
-
-    return status;
-  }
-
-  /**
-   * Gets cached rate limit status (avoids API call)
-   */
-  getCachedStatus(): RateLimitStatus | undefined {
-    // Return cached status if less than 60 seconds old
-    if (this.lastCheck && this.lastCheckTime) {
-      const age = Date.now() - this.lastCheckTime.getTime();
-      if (age < 60000) {
-        return this.lastCheck;
-      }
-    }
-    return undefined;
-  }
-}

package/src/releases.ts

@@ -1,149 +0,0 @@
-/**
- * Release Manager
- * Handles fetching and comparing GitHub releases
- */
-
-import { Octokit } from 'octokit';
-
-export interface Release {
-  tagName: string;
-  name: string;
-  publishedAt: Date;
-  body?: string | undefined;
-  htmlUrl: string;
-  prerelease?: boolean;
-  draft?: boolean;
-}
-
-export interface ReleaseComparison {
-  newReleases: Release[];
-  oldReleases: Release[];
-}
-
-export class ReleaseManager {
-  private octokit: Octokit;
-
-  constructor(auth?: string) {
-    this.octokit = new Octokit({
-      auth: auth || process.env['GITHUB_TOKEN']
-    });
-  }
-
-  /**
-   * Fetches the latest release from a repository
-   */
-  async getLatestRelease(params: { owner: string; repo: string }): Promise<Release | null> {
-    const { owner, repo } = params;
-
-    try {
-      const response = await this.octokit.rest.repos.getLatestRelease({
-        owner,
-        repo
-      });
-
-      return {
-        tagName: response.data.tag_name,
-        name: response.data.name || response.data.tag_name,
-        publishedAt: new Date(response.data.published_at || response.data.created_at),
-        body: response.data.body || undefined,
-        htmlUrl: response.data.html_url,
-        prerelease: response.data.prerelease,
-        draft: response.data.draft
-      };
-    } catch (error) {
-      if ((error as { status?: number }).status === 404) {
-        return null;
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Fetches all releases from a repository
-   */
-  async getAllReleases(params: {
-    owner: string;
-    repo: string;
-    page?: number;
-    perPage?: number;
-  }): Promise<Release[]> {
-    const { owner, repo, page = 1, perPage = 30 } = params;
-
-    try {
-      const response = await this.octokit.rest.repos.listReleases({
-        owner,
-        repo,
-        page,
-        per_page: perPage
-      });
-
-      return response.data.map((release) => ({
-        tagName: release.tag_name,
-        name: release.name || release.tag_name,
-        publishedAt: new Date(release.published_at || release.created_at),
-        body: release.body || undefined,
-        htmlUrl: release.html_url,
-        prerelease: release.prerelease,
-        draft: release.draft
-      }));
-    } catch (error) {
-      if ((error as { status?: number }).status === 404) {
-        return [];
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Compares two sets of releases to find new ones
-   */
-  compareReleases(oldReleases: Release[], newReleases: Release[]): ReleaseComparison {
-    const oldTags = new Set(oldReleases.map((r) => r.tagName));
-    const newTags = new Set(newReleases.map((r) => r.tagName));
-
-    // Find releases in new but not in old
-    const newOnes = newReleases.filter((r) => !oldTags.has(r.tagName));
-
-    // Find releases in old but not in new (removed/deleted)
-    const oldOnes = oldReleases.filter((r) => !newTags.has(r.tagName));
-
-    return {
-      newReleases: newOnes,
-      oldReleases: oldOnes
-    };
-  }
-
-  /**
-   * Fetches release notes for a specific tag
-   */
-  async getReleaseByTag(params: {
-    owner: string;
-    repo: string;
-    tag: string;
-  }): Promise<Release | null> {
-    const { owner, repo, tag } = params;
-
-    try {
-      const response = await this.octokit.rest.repos.getReleaseByTag({
-        owner,
-        repo,
-        tag
-      });
-
-      return {
-        tagName: response.data.tag_name,
-        name: response.data.name || response.data.tag_name,
-        publishedAt: new Date(response.data.published_at || response.data.created_at),
-        body: response.data.body || undefined,
-        htmlUrl: response.data.html_url,
-        prerelease: response.data.prerelease,
-        draft: response.data.draft
-      };
-    } catch (error) {
-      if ((error as { status?: number }).status === 404) {
-        return null;
-      }
-      throw error;
-    }
-  }
-}

package/test/auth/basic.test.ts

@@ -1,122 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { BasicAuthHandler } from '../../src/auth/basic';
-
-describe('BasicAuthHandler', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('constructor', () => {
-    it('should create handler with username and password', () => {
-      const handler = new BasicAuthHandler('user', 'pass');
-      expect(handler).toBeInstanceOf(BasicAuthHandler);
-    });
-
-    it('should throw error for empty username', () => {
-      expect(() => new BasicAuthHandler('', 'pass')).toThrow('Username cannot be empty');
-    });
-
-    it('should throw error for empty password', () => {
-      expect(() => new BasicAuthHandler('user', '')).toThrow('Password cannot be empty');
-    });
-  });
-
-  describe('authenticate', () => {
-    it('should return auth object with credentials', async () => {
-      const handler = new BasicAuthHandler('testuser', 'testpass');
-      const auth = await handler.authenticate();
-
-      expect(auth).toEqual({
-        type: 'basic',
-        username: 'testuser',
-        password: 'testpass'
-      });
-    });
-
-    it('should encode credentials properly', async () => {
-      const handler = new BasicAuthHandler('user@example.com', 'p@ssw0rd!');
-      const auth = await handler.authenticate();
-
-      expect(auth.username).toBe('user@example.com');
-      expect(auth.password).toBe('p@ssw0rd!');
-    });
-  });
-
-  describe('getAuthHeader', () => {
-    it('should generate base64 encoded auth header', () => {
-      const handler = new BasicAuthHandler('user', 'pass');
-      const header = handler.getAuthHeader();
-
-      // "user:pass" in base64 is "dXNlcjpwYXNz"
-      expect(header).toBe('Basic dXNlcjpwYXNz');
-    });
-
-    it('should handle special characters in credentials', () => {
-      const handler = new BasicAuthHandler('user@example.com', 'p@ss:word');
-      const header = handler.getAuthHeader();
-
-      expect(header).toMatch(/^Basic [A-Za-z0-9+/=]+$/);
-    });
-  });
-
-  describe('validate', () => {
-    it('should validate credentials format', () => {
-      const handler = new BasicAuthHandler('user', 'pass');
-      expect(handler.validate()).toBe(true);
-    });
-
-    it('should reject username with invalid characters', () => {
-      const handler = new BasicAuthHandler('user\n', 'pass');
-      expect(handler.validate()).toBe(false);
-    });
-
-    it('should reject password with newline', () => {
-      const handler = new BasicAuthHandler('user', 'pass\n');
-      expect(handler.validate()).toBe(false);
-    });
-
-    it('should accept email as username', () => {
-      const handler = new BasicAuthHandler('user@example.com', 'pass');
-      expect(handler.validate()).toBe(true);
-    });
-  });
-
-  describe('getType', () => {
-    it('should return basic type', () => {
-      const handler = new BasicAuthHandler('user', 'pass');
-      expect(handler.getType()).toBe('basic');
-    });
-  });
-
-  describe('credential rotation', () => {
-    it('should allow password update', () => {
-      const handler = new BasicAuthHandler('user', 'oldpass');
-      handler.updateCredentials('user', 'newpass');
-
-      const header = handler.getAuthHeader();
-      expect(header).toContain(Buffer.from('user:newpass').toString('base64'));
-    });
-
-    it('should throw error on empty password update', () => {
-      const handler = new BasicAuthHandler('user', 'pass');
-      expect(() => handler.updateCredentials('user', '')).toThrow('Password cannot be empty');
-    });
-  });
-
-  describe('security', () => {
-    it('should not expose password in toString', () => {
-      const handler = new BasicAuthHandler('user', 'secretpass');
-      const str = handler.toString();
-
-      expect(str).not.toContain('secretpass');
-      expect(str).toContain('***');
-    });
-
-    it('should not expose password in JSON', () => {
-      const handler = new BasicAuthHandler('user', 'secretpass');
-      const json = JSON.stringify(handler);
-
-      expect(json).not.toContain('secretpass');
-    });
-  });
-});

package/test/auth/oauth.test.ts

@@ -1,196 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { OAuthHandler } from '../../src/auth/oauth';
-
-describe('OAuthHandler', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('constructor', () => {
-    it('should create handler with client credentials', () => {
-      const config = {
-        clientId: 'test_client_id',
-        clientSecret: 'test_client_secret',
-        redirectUri: 'http://localhost:3000/callback'
-      };
-      const handler = new OAuthHandler(config);
-      expect(handler).toBeInstanceOf(OAuthHandler);
-    });
-
-    it('should throw error for missing clientId', () => {
-      const config = {
-        clientId: '',
-        clientSecret: 'secret',
-        redirectUri: 'http://localhost:3000/callback'
-      };
-      expect(() => new OAuthHandler(config)).toThrow('clientId is required');
-    });
-
-    it('should throw error for missing clientSecret', () => {
-      const config = {
-        clientId: 'client',
-        clientSecret: '',
-        redirectUri: 'http://localhost:3000/callback'
-      };
-      expect(() => new OAuthHandler(config)).toThrow('clientSecret is required');
-    });
-  });
-
-  describe('authenticate', () => {
-    it('should exchange code for access token', async () => {
-      const config = {
-        clientId: 'test_client',
-        clientSecret: 'test_secret',
-        redirectUri: 'http://localhost:3000/callback'
-      };
-      const handler = new OAuthHandler(config);
-
-      // Mock the token exchange
-      vi.spyOn(handler as any, 'exchangeCodeForToken').mockResolvedValue({
-        access_token: 'gho_accesstoken123',
-        token_type: 'bearer',
-        scope: 'repo'
-      });
-
-      const auth = await handler.authenticate('test_code');
-
-      expect(auth).toEqual({
-        type: 'oauth',
-        token: 'gho_accesstoken123',
-        tokenType: 'bearer',
-        scope: 'repo'
-      });
-    });
-
-    it('should throw error for invalid code', async () => {
-      const config = {
-        clientId: 'test_client',
-        clientSecret: 'test_secret',
-        redirectUri: 'http://localhost:3000/callback'
-      };
-      const handler = new OAuthHandler(config);
-
-      await expect(handler.authenticate('')).rejects.toThrow('Authorization code is required');
-    });
-
-    it('should handle token exchange failure', async () => {
-      const config = {
-        clientId: 'test_client',
-        clientSecret: 'test_secret',
-        redirectUri: 'http://localhost:3000/callback'
-      };
-      const handler = new OAuthHandler(config);
-
-      vi.spyOn(handler as any, 'exchangeCodeForToken').mockRejectedValue(
-        new Error('Invalid authorization code')
-      );
-
-      await expect(handler.authenticate('bad_code')).rejects.toThrow('Invalid authorization code');
-    });
-  });
-
-  describe('getAuthorizationUrl', () => {
-    it('should generate authorization URL with scopes', () => {
-      const config = {
-        clientId: 'test_client',
-        clientSecret: 'test_secret',
-        redirectUri: 'http://localhost:3000/callback'
-      };
-      const handler = new OAuthHandler(config);
-
-      const url = handler.getAuthorizationUrl(['repo', 'user']);
-
-      expect(url).toContain('https://github.com/login/oauth/authorize');
-      expect(url).toContain('client_id=test_client');
-      expect(url).toContain('redirect_uri=http%3A%2F%2Flocalhost%3A3000%2Fcallback');
-      expect(url).toContain('scope=repo+user'); // URLSearchParams uses + for spaces
-    });
-
-    it('should include state parameter for CSRF protection', () => {
-      const config = {
-        clientId: 'test_client',
-        clientSecret: 'test_secret',
-        redirectUri: 'http://localhost:3000/callback'
-      };
-      const handler = new OAuthHandler(config);
-
-      const url = handler.getAuthorizationUrl(['repo'], 'random_state_123');
-
-      expect(url).toContain('state=random_state_123');
-    });
-  });
-
-  describe('refreshToken', () => {
-    it('should refresh expired access token', async () => {
-      const config = {
-        clientId: 'test_client',
-        clientSecret: 'test_secret',
-        redirectUri: 'http://localhost:3000/callback'
-      };
-      const handler = new OAuthHandler(config);
-
-      vi.spyOn(handler as any, 'performTokenRefresh').mockResolvedValue({
-        access_token: 'gho_newtoken456',
-        token_type: 'bearer',
-        scope: 'repo'
-      });
-
-      const result = await handler.refreshToken('refresh_token_123');
-
-      expect(result).toEqual({
-        type: 'oauth',
-        token: 'gho_newtoken456',
-        tokenType: 'bearer',
-        scope: 'repo'
-      });
-    });
-
-    it('should throw error for missing refresh token', async () => {
-      const config = {
-        clientId: 'test_client',
-        clientSecret: 'test_secret',
-        redirectUri: 'http://localhost:3000/callback'
-      };
-      const handler = new OAuthHandler(config);
-
-      await expect(handler.refreshToken('')).rejects.toThrow('Refresh token is required');
-    });
-  });
-
-  describe('validate', () => {
-    it('should validate OAuth configuration', () => {
-      const config = {
-        clientId: 'test_client',
-        clientSecret: 'test_secret',
-        redirectUri: 'http://localhost:3000/callback'
-      };
-      const handler = new OAuthHandler(config);
-
-      expect(handler.validate()).toBe(true);
-    });
-
-    it('should fail validation for invalid redirect URI', () => {
-      const config = {
-        clientId: 'test_client',
-        clientSecret: 'test_secret',
-        redirectUri: 'invalid-uri'
-      };
-      const handler = new OAuthHandler(config);
-
-      expect(handler.validate()).toBe(false);
-    });
-  });
-
-  describe('getType', () => {
-    it('should return oauth type', () => {
-      const config = {
-        clientId: 'test_client',
-        clientSecret: 'test_secret',
-        redirectUri: 'http://localhost:3000/callback'
-      };
-      const handler = new OAuthHandler(config);
-
-      expect(handler.getType()).toBe('oauth');
-    });
-  });
-});