2025-09-05 14:01:33 +02:00
parent 8a685603be
commit 3ea96506ea
46 changed files with 4401 additions and 4025 deletions
							
							
							
						
@@ -0,0 +1,338 @@
import type {
  GitHubUserResponse,
  GitHubRepoInfo,
  GitHubEvent,
  GitHubStats,
  GitHubLanguageStats,
  GitHubRateLimits,
} from '~/types/GitHub';
const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
interface CacheEntry<T> {
  data: T;
  timestamp: number;
  expiresAt: number;
}
class GitHubCache {
  private _cache = new Map<string, CacheEntry<any>>();
  set<T>(key: string, data: T, duration = CACHE_DURATION): void {
    const timestamp = Date.now();
    this._cache.set(key, {
      data,
      timestamp,
      expiresAt: timestamp + duration,
    });
  }
  get<T>(key: string): T | null {
    const entry = this._cache.get(key);
    if (!entry) {
      return null;
    }
    if (Date.now() > entry.expiresAt) {
      this._cache.delete(key);
      return null;
    }
    return entry.data;
  }
  clear(): void {
    this._cache.clear();
  }
  isExpired(key: string): boolean {
    const entry = this._cache.get(key);
    return !entry || Date.now() > entry.expiresAt;
  }
  delete(key: string): void {
    this._cache.delete(key);
  }
}
class GitHubApiService {
  private _cache = new GitHubCache();
  private _baseUrl = 'https://api.github.com';
  private async _makeRequest<T>(
    endpoint: string,
    token: string,
    tokenType: 'classic' | 'fine-grained' = 'classic',
    options: RequestInit = {},
  ): Promise<{ data: T; rateLimit?: GitHubRateLimits }> {
    const authHeader = tokenType === 'classic' ? `token ${token}` : `Bearer ${token}`;
    const response = await fetch(`${this._baseUrl}${endpoint}`, {
      ...options,
      headers: {
        'Content-Type': 'application/json',
        Authorization: authHeader,
        'User-Agent': 'bolt.diy-app',
        ...options.headers,
      },
    });
    // Extract rate limit information
    const rateLimit: GitHubRateLimits = {
      limit: parseInt(response.headers.get('x-ratelimit-limit') || '5000'),
      remaining: parseInt(response.headers.get('x-ratelimit-remaining') || '5000'),
      reset: new Date(parseInt(response.headers.get('x-ratelimit-reset') || '0') * 1000),
      used: parseInt(response.headers.get('x-ratelimit-used') || '0'),
    };
    if (!response.ok) {
      const errorBody = await response.text();
      throw new Error(`GitHub API Error (${response.status}): ${response.statusText}. ${errorBody}`);
    }
    const data = (await response.json()) as T;
    return { data, rateLimit };
  }
  async fetchUser(
    token: string,
    _tokenType: 'classic' | 'fine-grained' = 'classic',
  ): Promise<{
    user: GitHubUserResponse;
    rateLimit: GitHubRateLimits;
  }> {
    const cacheKey = `user:${token.slice(0, 8)}`;
    const cached = this._cache.get<{ user: GitHubUserResponse; rateLimit: GitHubRateLimits }>(cacheKey);
    if (cached) {
      return cached;
    }
    try {
      // Use server-side API endpoint for user validation
      const response = await fetch('/api/system/git-info?action=getUser', {
        method: 'GET',
        headers: {
          'Content-Type': 'application/json',
          Authorization: `Bearer ${token}`,
        },
      });
      if (!response.ok) {
        throw new Error(`GitHub API Error (${response.status}): ${response.statusText}`);
      }
      // Get rate limit information from headers
      const rateLimit: GitHubRateLimits = {
        limit: parseInt(response.headers.get('x-ratelimit-limit') || '5000'),
        remaining: parseInt(response.headers.get('x-ratelimit-remaining') || '5000'),
        reset: new Date(parseInt(response.headers.get('x-ratelimit-reset') || '0') * 1000),
        used: parseInt(response.headers.get('x-ratelimit-used') || '0'),
      };
      const data = (await response.json()) as { user: GitHubUserResponse };
      const user = data.user;
      if (!user || !user.login) {
        throw new Error('Invalid user data received');
      }
      const result = { user, rateLimit };
      this._cache.set(cacheKey, result);
      return result;
    } catch (error) {
      console.error('Failed to fetch GitHub user:', error);
      throw error;
    }
  }
  async fetchRepositories(token: string, tokenType: 'classic' | 'fine-grained' = 'classic'): Promise<GitHubRepoInfo[]> {
    const cacheKey = `repos:${token.slice(0, 8)}`;
    const cached = this._cache.get<GitHubRepoInfo[]>(cacheKey);
    if (cached) {
      return cached;
    }
    try {
      let allRepos: any[] = [];
      let page = 1;
      let hasMore = true;
      while (hasMore) {
        const { data: repos } = await this._makeRequest<any[]>(
          `/user/repos?per_page=100&page=${page}`,
          token,
          tokenType,
        );
        allRepos = [...allRepos, ...repos];
        hasMore = repos.length === 100;
        page++;
      }
      const repositories: GitHubRepoInfo[] = allRepos.map((repo) => ({
        id: repo.id.toString(),
        name: repo.name,
        full_name: repo.full_name,
        html_url: repo.html_url,
        description: repo.description || '',
        stargazers_count: repo.stargazers_count || 0,
        forks_count: repo.forks_count || 0,
        default_branch: repo.default_branch || 'main',
        updated_at: repo.updated_at,
        language: repo.language || '',
        languages_url: repo.languages_url,
        private: repo.private || false,
        topics: repo.topics || [],
      }));
      this._cache.set(cacheKey, repositories);
      return repositories;
    } catch (error) {
      console.error('Failed to fetch GitHub repositories:', error);
      throw error;
    }
  }
  async fetchRecentActivity(
    username: string,
    token: string,
    tokenType: 'classic' | 'fine-grained' = 'classic',
  ): Promise<GitHubEvent[]> {
    const cacheKey = `activity:${username}:${token.slice(0, 8)}`;
    const cached = this._cache.get<GitHubEvent[]>(cacheKey);
    if (cached) {
      return cached;
    }
    try {
      const { data: events } = await this._makeRequest<any[]>(
        `/users/${username}/events?per_page=10`,
        token,
        tokenType,
      );
      const recentActivity: GitHubEvent[] = events.slice(0, 5).map((event) => ({
        id: event.id,
        type: event.type,
        created_at: event.created_at,
        repo: {
          name: event.repo?.name || '',
          url: event.repo?.url || '',
        },
        payload: {
          action: event.payload?.action,
          ref: event.payload?.ref,
          ref_type: event.payload?.ref_type,
          description: event.payload?.description,
        },
      }));
      this._cache.set(cacheKey, recentActivity);
      return recentActivity;
    } catch (error) {
      console.error('Failed to fetch GitHub recent activity:', error);
      throw error;
    }
  }
  async fetchRepositoryLanguages(languagesUrl: string, token: string): Promise<GitHubLanguageStats> {
    const cacheKey = `languages:${languagesUrl}`;
    const cached = this._cache.get<GitHubLanguageStats>(cacheKey);
    if (cached) {
      return cached;
    }
    try {
      const response = await fetch(languagesUrl, {
        headers: {
          Authorization: `token ${token}`,
          'User-Agent': 'bolt.diy-app',
        },
      });
      if (!response.ok) {
        throw new Error(`Failed to fetch languages: ${response.statusText}`);
      }
      const languages = (await response.json()) as GitHubLanguageStats;
      this._cache.set(cacheKey, languages);
      return languages;
    } catch (error) {
      console.error('Failed to fetch repository languages:', error);
      return {};
    }
  }
  async fetchStats(token: string, tokenType: 'classic' | 'fine-grained' = 'classic'): Promise<GitHubStats> {
    try {
      // Fetch user data
      const { user } = await this.fetchUser(token, tokenType);
      // Fetch repositories
      const repositories = await this.fetchRepositories(token, tokenType);
      // Fetch recent activity
      const recentActivity = await this.fetchRecentActivity(user.login, token, tokenType);
      // Calculate stats
      const totalStars = repositories.reduce((sum, repo) => sum + repo.stargazers_count, 0);
      const totalForks = repositories.reduce((sum, repo) => sum + repo.forks_count, 0);
      const privateRepos = repositories.filter((repo) => repo.private).length;
      // Calculate language statistics
      const languages: GitHubLanguageStats = {};
      for (const repo of repositories) {
        if (repo.language) {
          languages[repo.language] = (languages[repo.language] || 0) + 1;
        }
      }
      const stats: GitHubStats = {
        repos: repositories,
        totalStars,
        totalForks,
        organizations: [], // TODO: Implement organizations fetching if needed
        recentActivity,
        languages,
        totalGists: user.public_gists || 0,
        publicRepos: user.public_repos || 0,
        privateRepos,
        stars: totalStars,
        forks: totalForks,
        followers: user.followers || 0,
        publicGists: user.public_gists || 0,
        privateGists: 0, // GitHub API doesn't provide private gists count directly
        lastUpdated: new Date().toISOString(),
      };
      return stats;
    } catch (error) {
      console.error('Failed to fetch GitHub stats:', error);
      throw error;
    }
  }
  clearCache(): void {
    this._cache.clear();
  }
  clearUserCache(token: string): void {
    const keyPrefix = token.slice(0, 8);
    this._cache.delete(`user:${keyPrefix}`);
    this._cache.delete(`repos:${keyPrefix}`);
  }
}
export const gitHubApiService = new GitHubApiService();
							
							
							
						
@@ -0,0 +1,421 @@
import type {
  GitLabUserResponse,
  GitLabProjectInfo,
  GitLabEvent,
  GitLabGroupInfo,
  GitLabProjectResponse,
  GitLabCommitRequest,
} from '~/types/GitLab';
const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
interface CacheEntry<T> {
  data: T;
  timestamp: number;
  expiresAt: number;
}
class GitLabCache {
  private _cache = new Map<string, CacheEntry<any>>();
  set<T>(key: string, data: T, duration = CACHE_DURATION): void {
    const timestamp = Date.now();
    this._cache.set(key, {
      data,
      timestamp,
      expiresAt: timestamp + duration,
    });
  }
  get<T>(key: string): T | null {
    const entry = this._cache.get(key);
    if (!entry) {
      return null;
    }
    if (Date.now() > entry.expiresAt) {
      this._cache.delete(key);
      return null;
    }
    return entry.data;
  }
  clear(): void {
    this._cache.clear();
  }
  isExpired(key: string): boolean {
    const entry = this._cache.get(key);
    return !entry || Date.now() > entry.expiresAt;
  }
}
const gitlabCache = new GitLabCache();
async function fetchWithRetry(url: string, options: RequestInit, maxRetries = 3): Promise<Response> {
  let lastError: Error;
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);
      // Don't retry on client errors (4xx) except 429 (rate limit)
      if (response.status >= 400 && response.status < 500 && response.status !== 429) {
        return response;
      }
      // Retry on server errors (5xx) and rate limits
      if (response.status >= 500 || response.status === 429) {
        if (attempt === maxRetries) {
          return response;
        }
        const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
        await new Promise((resolve) => setTimeout(resolve, delay));
        continue;
      }
      return response;
    } catch (error) {
      lastError = error as Error;
      if (attempt === maxRetries) {
        throw lastError;
      }
      const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }
  throw lastError!;
}
export class GitLabApiService {
  private _baseUrl: string;
  private _token: string;
  constructor(token: string, baseUrl = 'https://gitlab.com') {
    this._token = token;
    this._baseUrl = baseUrl;
  }
  private get _headers() {
    return {
      'Content-Type': 'application/json',
      'PRIVATE-TOKEN': this._token,
    };
  }
  private async _request(endpoint: string, options: RequestInit = {}): Promise<Response> {
    const url = `${this._baseUrl}/api/v4${endpoint}`;
    return fetchWithRetry(url, {
      ...options,
      headers: {
        ...this._headers,
        ...options.headers,
      },
    });
  }
  async getUser(): Promise<GitLabUserResponse> {
    const response = await this._request('/user');
    if (!response.ok) {
      throw new Error(`Failed to fetch user: ${response.status}`);
    }
    const user: GitLabUserResponse = await response.json();
    // Get rate limit information from headers if available
    const rateLimit = {
      limit: parseInt(response.headers.get('ratelimit-limit') || '0'),
      remaining: parseInt(response.headers.get('ratelimit-remaining') || '0'),
      reset: parseInt(response.headers.get('ratelimit-reset') || '0'),
    };
    // Handle different avatar URL fields that GitLab might return
    const processedUser = {
      ...user,
      avatar_url: user.avatar_url || (user as any).avatarUrl || (user as any).profile_image_url || null,
    };
    return { ...processedUser, rateLimit } as GitLabUserResponse & { rateLimit: typeof rateLimit };
  }
  async getProjects(membership = true, minAccessLevel = 20, perPage = 50): Promise<GitLabProjectInfo[]> {
    const cacheKey = `projects_${this._token}_${membership}_${minAccessLevel}`;
    const cached = gitlabCache.get<GitLabProjectInfo[]>(cacheKey);
    if (cached) {
      return cached;
    }
    let allProjects: any[] = [];
    let page = 1;
    const maxPages = 10; // Limit to prevent excessive API calls
    while (page <= maxPages) {
      const response = await this._request(
        `/projects?membership=${membership}&min_access_level=${minAccessLevel}&per_page=${perPage}&page=${page}&order_by=updated_at&sort=desc`,
      );
      if (!response.ok) {
        throw new Error(`Failed to fetch projects: ${response.statusText}`);
      }
      const projects: any[] = await response.json();
      if (projects.length === 0) {
        break;
      }
      allProjects = [...allProjects, ...projects];
      // Break if we have enough projects for initial load
      if (allProjects.length >= 100) {
        break;
      }
      page++;
    }
    // Transform to our interface
    const transformedProjects: GitLabProjectInfo[] = allProjects.map((project: any) => ({
      id: project.id,
      name: project.name,
      path_with_namespace: project.path_with_namespace,
      description: project.description,
      http_url_to_repo: project.http_url_to_repo,
      star_count: project.star_count,
      forks_count: project.forks_count,
      default_branch: project.default_branch,
      updated_at: project.updated_at,
      visibility: project.visibility,
    }));
    gitlabCache.set(cacheKey, transformedProjects);
    return transformedProjects;
  }
  async getEvents(perPage = 10): Promise<GitLabEvent[]> {
    const response = await this._request(`/events?per_page=${perPage}`);
    if (!response.ok) {
      throw new Error(`Failed to fetch events: ${response.statusText}`);
    }
    const events: any[] = await response.json();
    return events.slice(0, 5).map((event: any) => ({
      id: event.id,
      action_name: event.action_name,
      project_id: event.project_id,
      project: event.project,
      created_at: event.created_at,
    }));
  }
  async getGroups(minAccessLevel = 10): Promise<GitLabGroupInfo[]> {
    const response = await this._request(`/groups?min_access_level=${minAccessLevel}`);
    if (response.ok) {
      return await response.json();
    }
    return [];
  }
  async getSnippets(): Promise<any[]> {
    const response = await this._request('/snippets');
    if (response.ok) {
      return await response.json();
    }
    return [];
  }
  async createProject(name: string, isPrivate: boolean = false): Promise<GitLabProjectResponse> {
    const response = await this._request('/projects', {
      method: 'POST',
      body: JSON.stringify({
        name,
        visibility: isPrivate ? 'private' : 'public',
        initialize_with_readme: false, // Don't initialize with README to avoid conflicts
        default_branch: 'main', // Explicitly set default branch
      }),
    });
    if (!response.ok) {
      throw new Error(`Failed to create project: ${response.statusText}`);
    }
    return await response.json();
  }
  async getProject(owner: string, name: string): Promise<GitLabProjectResponse | null> {
    const response = await this._request(`/projects/${encodeURIComponent(`${owner}/${name}`)}`);
    if (response.ok) {
      return await response.json();
    }
    return null;
  }
  async createBranch(projectId: number, branchName: string, ref: string): Promise<any> {
    const response = await this._request(`/projects/${projectId}/repository/branches`, {
      method: 'POST',
      body: JSON.stringify({
        branch: branchName,
        ref,
      }),
    });
    if (!response.ok) {
      throw new Error(`Failed to create branch: ${response.statusText}`);
    }
    return await response.json();
  }
  async commitFiles(projectId: number, commitRequest: GitLabCommitRequest): Promise<any> {
    const response = await this._request(`/projects/${projectId}/repository/commits`, {
      method: 'POST',
      body: JSON.stringify(commitRequest),
    });
    if (!response.ok) {
      let errorMessage = `Failed to commit files: ${response.status} ${response.statusText}`;
      try {
        const errorData = (await response.json()) as { message?: string; error?: string };
        if (errorData.message) {
          errorMessage = errorData.message;
        } else if (errorData.error) {
          errorMessage = errorData.error;
        }
      } catch {
        // If JSON parsing fails, keep the default error message
      }
      throw new Error(errorMessage);
    }
    return await response.json();
  }
  async getFile(projectId: number, filePath: string, ref: string): Promise<Response> {
    return this._request(`/projects/${projectId}/repository/files/${encodeURIComponent(filePath)}?ref=${ref}`);
  }
  async getProjectByPath(projectPath: string): Promise<GitLabProjectResponse | null> {
    try {
      const response = await this._request(`/projects/${encodeURIComponent(projectPath)}`);
      if (response.ok) {
        return await response.json();
      }
      if (response.status === 404) {
        return null;
      }
      throw new Error(`Failed to fetch project: ${response.status} ${response.statusText}`);
    } catch (error) {
      if (error instanceof Error && error.message.includes('404')) {
        return null;
      }
      throw error;
    }
  }
  async updateProjectVisibility(projectId: number, visibility: 'public' | 'private'): Promise<void> {
    const response = await this._request(`/projects/${projectId}`, {
      method: 'PUT',
      body: JSON.stringify({ visibility }),
    });
    if (!response.ok) {
      throw new Error(`Failed to update project visibility: ${response.status} ${response.statusText}`);
    }
  }
  async createProjectWithFiles(
    name: string,
    isPrivate: boolean,
    files: Record<string, string>,
  ): Promise<GitLabProjectResponse> {
    // Create the project first
    const project = await this.createProject(name, isPrivate);
    // If we have files to commit, commit them
    if (Object.keys(files).length > 0) {
      const actions = Object.entries(files).map(([filePath, content]) => ({
        action: 'create' as const,
        file_path: filePath,
        content,
      }));
      const commitRequest: GitLabCommitRequest = {
        branch: 'main',
        commit_message: 'Initial commit from Bolt.diy',
        actions,
      };
      await this.commitFiles(project.id, commitRequest);
    }
    return project;
  }
  async updateProjectWithFiles(projectId: number, files: Record<string, string>): Promise<void> {
    if (Object.keys(files).length === 0) {
      return;
    }
    // For existing projects, we need to determine which files exist and which are new
    const actions = Object.entries(files).map(([filePath, content]) => ({
      action: 'create' as const, // Start with create, we'll handle conflicts in the API response
      file_path: filePath,
      content,
    }));
    const commitRequest: GitLabCommitRequest = {
      branch: 'main',
      commit_message: 'Update from Bolt.diy',
      actions,
    };
    try {
      await this.commitFiles(projectId, commitRequest);
    } catch (error) {
      // If we get file conflicts, retry with update actions
      if (error instanceof Error && error.message.includes('already exists')) {
        const updateActions = Object.entries(files).map(([filePath, content]) => ({
          action: 'update' as const,
          file_path: filePath,
          content,
        }));
        const updateCommitRequest: GitLabCommitRequest = {
          branch: 'main',
          commit_message: 'Update from Bolt.diy',
          actions: updateActions,
        };
        await this.commitFiles(projectId, updateCommitRequest);
      } else {
        throw error;
      }
    }
  }
}
export { gitlabCache };