crca 1.4.0__py3-none-any.whl

tools/bolt.diy/app/routes/api.github-stats.ts

@@ -0,0 +1,198 @@
+import { json } from '@remix-run/cloudflare';
+import { getApiKeysFromCookie } from '~/lib/api/cookies';
+import { withSecurity } from '~/lib/security';
+import type { GitHubUserResponse, GitHubStats } from '~/types/GitHub';
+
+async function githubStatsLoader({ request, context }: { request: Request; context: any }) {
+  try {
+    // Get API keys from cookies (server-side only)
+    const cookieHeader = request.headers.get('Cookie');
+    const apiKeys = getApiKeysFromCookie(cookieHeader);
+
+    // Try to get GitHub token from various sources
+    const githubToken =
+      apiKeys.GITHUB_API_KEY ||
+      apiKeys.VITE_GITHUB_ACCESS_TOKEN ||
+      context?.cloudflare?.env?.GITHUB_TOKEN ||
+      context?.cloudflare?.env?.VITE_GITHUB_ACCESS_TOKEN ||
+      process.env.GITHUB_TOKEN ||
+      process.env.VITE_GITHUB_ACCESS_TOKEN;
+
+    if (!githubToken) {
+      return json({ error: 'GitHub token not found' }, { status: 401 });
+    }
+
+    // Get user info first
+    const userResponse = await fetch('https://api.github.com/user', {
+      headers: {
+        Accept: 'application/vnd.github.v3+json',
+        Authorization: `Bearer ${githubToken}`,
+        'User-Agent': 'bolt.diy-app',
+      },
+    });
+
+    if (!userResponse.ok) {
+      if (userResponse.status === 401) {
+        return json({ error: 'Invalid GitHub token' }, { status: 401 });
+      }
+
+      throw new Error(`GitHub API error: ${userResponse.status}`);
+    }
+
+    const user = (await userResponse.json()) as GitHubUserResponse;
+
+    // Fetch repositories with pagination
+    let allRepos: any[] = [];
+    let page = 1;
+    let hasMore = true;
+
+    while (hasMore) {
+      const repoResponse = await fetch(
+        `https://api.github.com/user/repos?sort=updated&per_page=100&page=${page}&affiliation=owner,organization_member`,
+        {
+          headers: {
+            Accept: 'application/vnd.github.v3+json',
+            Authorization: `Bearer ${githubToken}`,
+            'User-Agent': 'bolt.diy-app',
+          },
+        },
+      );
+
+      if (!repoResponse.ok) {
+        throw new Error(`GitHub API error: ${repoResponse.status}`);
+      }
+
+      const repos: any[] = await repoResponse.json();
+      allRepos = allRepos.concat(repos);
+
+      if (repos.length < 100) {
+        hasMore = false;
+      } else {
+        page += 1;
+      }
+    }
+
+    // Fetch branch counts for repositories (limit to first 50 repos to avoid rate limits)
+    const reposWithBranches = await Promise.allSettled(
+      allRepos.slice(0, 50).map(async (repo) => {
+        try {
+          const branchesResponse = await fetch(`https://api.github.com/repos/${repo.full_name}/branches?per_page=1`, {
+            headers: {
+              Accept: 'application/vnd.github.v3+json',
+              Authorization: `Bearer ${githubToken}`,
+              'User-Agent': 'bolt.diy-app',
+            },
+          });
+
+          if (branchesResponse.ok) {
+            const linkHeader = branchesResponse.headers.get('Link');
+            let branchesCount = 1; // At least 1 branch (default)
+
+            if (linkHeader) {
+              const match = linkHeader.match(/page=(\d+)>; rel="last"/);
+
+              if (match) {
+                branchesCount = parseInt(match[1], 10);
+              }
+            }
+
+            return {
+              ...repo,
+              branches_count: branchesCount,
+            };
+          }
+
+          return repo;
+        } catch (error) {
+          console.warn(`Failed to fetch branches for ${repo.full_name}:`, error);
+          return repo;
+        }
+      }),
+    );
+
+    // Update repositories with branch information where available
+    allRepos = allRepos.map((repo, index) => {
+      if (index < reposWithBranches.length && reposWithBranches[index].status === 'fulfilled') {
+        return reposWithBranches[index].value;
+      }
+
+      return repo;
+    });
+
+    // Calculate comprehensive stats
+    const now = new Date();
+    const publicRepos = allRepos.filter((repo) => !repo.private).length;
+    const privateRepos = allRepos.filter((repo) => repo.private).length;
+
+    // Language statistics
+    const languageStats = new Map<string, number>();
+    allRepos.forEach((repo) => {
+      if (repo.language) {
+        languageStats.set(repo.language, (languageStats.get(repo.language) || 0) + 1);
+      }
+    });
+
+    // Activity stats
+    const totalStars = allRepos.reduce((sum, repo) => sum + (repo.stargazers_count || 0), 0);
+    const totalForks = allRepos.reduce((sum, repo) => sum + (repo.forks_count || 0), 0);
+
+    // Recent activity (repos updated in last 30 days)
+    const thirtyDaysAgo = new Date();
+    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+
+    // Popular repositories (top 10 by stars)
+
+    const stats: GitHubStats = {
+      repos: allRepos.map((repo) => ({
+        id: repo.id,
+        name: repo.name,
+        full_name: repo.full_name,
+        html_url: repo.html_url,
+        clone_url: repo.clone_url || '',
+        description: repo.description,
+        private: repo.private,
+        language: repo.language,
+        updated_at: repo.updated_at,
+        stargazers_count: repo.stargazers_count || 0,
+        forks_count: repo.forks_count || 0,
+        watchers_count: repo.watchers_count || 0,
+        topics: repo.topics || [],
+        fork: repo.fork || false,
+        archived: repo.archived || false,
+        size: repo.size || 0,
+        default_branch: repo.default_branch || 'main',
+        languages_url: repo.languages_url || '',
+      })),
+      organizations: [],
+      recentActivity: [],
+      languages: {},
+      totalGists: user.public_gists || 0,
+      publicRepos,
+      privateRepos,
+      stars: totalStars,
+      forks: totalForks,
+      totalStars,
+      totalForks,
+      followers: user.followers || 0,
+      publicGists: user.public_gists || 0,
+      privateGists: 0, // GitHub API doesn't provide private gists count directly
+      lastUpdated: now.toISOString(),
+    };
+
+    return json(stats);
+  } catch (error) {
+    console.error('Error fetching GitHub stats:', error);
+    return json(
+      {
+        error: 'Failed to fetch GitHub statistics',
+        details: error instanceof Error ? error.message : String(error),
+      },
+      { status: 500 },
+    );
+  }
+}
+
+export const loader = withSecurity(githubStatsLoader, {
+  rateLimit: true,
+  allowedMethods: ['GET'],
+});

tools/bolt.diy/app/routes/api.github-template.ts

@@ -0,0 +1,242 @@
+import { json } from '@remix-run/cloudflare';
+import JSZip from 'jszip';
+
+// Function to detect if we're running in Cloudflare
+function isCloudflareEnvironment(context: any): boolean {
+  // Check if we're in production AND have Cloudflare Pages specific env vars
+  const isProduction = process.env.NODE_ENV === 'production';
+  const hasCfPagesVars = !!(
+    context?.cloudflare?.env?.CF_PAGES ||
+    context?.cloudflare?.env?.CF_PAGES_URL ||
+    context?.cloudflare?.env?.CF_PAGES_COMMIT_SHA
+  );
+
+  return isProduction && hasCfPagesVars;
+}
+
+// Cloudflare-compatible method using GitHub Contents API
+async function fetchRepoContentsCloudflare(repo: string, githubToken?: string) {
+  const baseUrl = 'https://api.github.com';
+
+  // Get repository info to find default branch
+  const repoResponse = await fetch(`${baseUrl}/repos/${repo}`, {
+    headers: {
+      Accept: 'application/vnd.github.v3+json',
+      'User-Agent': 'bolt.diy-app',
+      ...(githubToken ? { Authorization: `Bearer ${githubToken}` } : {}),
+    },
+  });
+
+  if (!repoResponse.ok) {
+    throw new Error(`Repository not found: ${repo}`);
+  }
+
+  const repoData = (await repoResponse.json()) as any;
+  const defaultBranch = repoData.default_branch;
+
+  // Get the tree recursively
+  const treeResponse = await fetch(`${baseUrl}/repos/${repo}/git/trees/${defaultBranch}?recursive=1`, {
+    headers: {
+      Accept: 'application/vnd.github.v3+json',
+      'User-Agent': 'bolt.diy-app',
+      ...(githubToken ? { Authorization: `Bearer ${githubToken}` } : {}),
+    },
+  });
+
+  if (!treeResponse.ok) {
+    throw new Error(`Failed to fetch repository tree: ${treeResponse.status}`);
+  }
+
+  const treeData = (await treeResponse.json()) as any;
+
+  // Filter for files only (not directories) and limit size
+  const files = treeData.tree.filter((item: any) => {
+    if (item.type !== 'blob') {
+      return false;
+    }
+
+    if (item.path.startsWith('.git/')) {
+      return false;
+    }
+
+    // Allow lock files even if they're large
+    const isLockFile =
+      item.path.endsWith('package-lock.json') ||
+      item.path.endsWith('yarn.lock') ||
+      item.path.endsWith('pnpm-lock.yaml');
+
+    // For non-lock files, limit size to 100KB
+    if (!isLockFile && item.size >= 100000) {
+      return false;
+    }
+
+    return true;
+  });
+
+  // Fetch file contents in batches to avoid overwhelming the API
+  const batchSize = 10;
+  const fileContents = [];
+
+  for (let i = 0; i < files.length; i += batchSize) {
+    const batch = files.slice(i, i + batchSize);
+    const batchPromises = batch.map(async (file: any) => {
+      try {
+        const contentResponse = await fetch(`${baseUrl}/repos/${repo}/contents/${file.path}`, {
+          headers: {
+            Accept: 'application/vnd.github.v3+json',
+            'User-Agent': 'bolt.diy-app',
+            ...(githubToken ? { Authorization: `Bearer ${githubToken}` } : {}),
+          },
+        });
+
+        if (!contentResponse.ok) {
+          console.warn(`Failed to fetch ${file.path}: ${contentResponse.status}`);
+          return null;
+        }
+
+        const contentData = (await contentResponse.json()) as any;
+        const content = atob(contentData.content.replace(/\s/g, ''));
+
+        return {
+          name: file.path.split('/').pop() || '',
+          path: file.path,
+          content,
+        };
+      } catch (error) {
+        console.warn(`Error fetching ${file.path}:`, error);
+        return null;
+      }
+    });
+
+    const batchResults = await Promise.all(batchPromises);
+    fileContents.push(...batchResults.filter(Boolean));
+
+    // Add a small delay between batches to be respectful to the API
+    if (i + batchSize < files.length) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+
+  return fileContents;
+}
+
+// Your existing method for non-Cloudflare environments
+async function fetchRepoContentsZip(repo: string, githubToken?: string) {
+  const baseUrl = 'https://api.github.com';
+
+  // Get the latest release
+  const releaseResponse = await fetch(`${baseUrl}/repos/${repo}/releases/latest`, {
+    headers: {
+      Accept: 'application/vnd.github.v3+json',
+      'User-Agent': 'bolt.diy-app',
+      ...(githubToken ? { Authorization: `Bearer ${githubToken}` } : {}),
+    },
+  });
+
+  if (!releaseResponse.ok) {
+    throw new Error(`GitHub API error: ${releaseResponse.status} - ${releaseResponse.statusText}`);
+  }
+
+  const releaseData = (await releaseResponse.json()) as any;
+  const zipballUrl = releaseData.zipball_url;
+
+  // Fetch the zipball
+  const zipResponse = await fetch(zipballUrl, {
+    headers: {
+      ...(githubToken ? { Authorization: `Bearer ${githubToken}` } : {}),
+    },
+  });
+
+  if (!zipResponse.ok) {
+    throw new Error(`Failed to fetch release zipball: ${zipResponse.status}`);
+  }
+
+  // Get the zip content as ArrayBuffer
+  const zipArrayBuffer = await zipResponse.arrayBuffer();
+
+  // Use JSZip to extract the contents
+  const zip = await JSZip.loadAsync(zipArrayBuffer);
+
+  // Find the root folder name
+  let rootFolderName = '';
+  zip.forEach((relativePath) => {
+    if (!rootFolderName && relativePath.includes('/')) {
+      rootFolderName = relativePath.split('/')[0];
+    }
+  });
+
+  // Extract all files
+  const promises = Object.keys(zip.files).map(async (filename) => {
+    const zipEntry = zip.files[filename];
+
+    // Skip directories
+    if (zipEntry.dir) {
+      return null;
+    }
+
+    // Skip the root folder itself
+    if (filename === rootFolderName) {
+      return null;
+    }
+
+    // Remove the root folder from the path
+    let normalizedPath = filename;
+
+    if (rootFolderName && filename.startsWith(rootFolderName + '/')) {
+      normalizedPath = filename.substring(rootFolderName.length + 1);
+    }
+
+    // Get the file content
+    const content = await zipEntry.async('string');
+
+    return {
+      name: normalizedPath.split('/').pop() || '',
+      path: normalizedPath,
+      content,
+    };
+  });
+
+  const results = await Promise.all(promises);
+
+  return results.filter(Boolean);
+}
+
+export async function loader({ request, context }: { request: Request; context: any }) {
+  const url = new URL(request.url);
+  const repo = url.searchParams.get('repo');
+
+  if (!repo) {
+    return json({ error: 'Repository name is required' }, { status: 400 });
+  }
+
+  try {
+    // Access environment variables from Cloudflare context or process.env
+    const githubToken =
+      context?.cloudflare?.env?.GITHUB_TOKEN || process.env.GITHUB_TOKEN || process.env.VITE_GITHUB_ACCESS_TOKEN;
+
+    let fileList;
+
+    if (isCloudflareEnvironment(context)) {
+      fileList = await fetchRepoContentsCloudflare(repo, githubToken);
+    } else {
+      fileList = await fetchRepoContentsZip(repo, githubToken);
+    }
+
+    // Filter out .git files for both methods
+    const filteredFiles = fileList.filter((file: any) => !file.path.startsWith('.git'));
+
+    return json(filteredFiles);
+  } catch (error) {
+    console.error('Error processing GitHub template:', error);
+    console.error('Repository:', repo);
+    console.error('Error details:', error instanceof Error ? error.message : String(error));
+
+    return json(
+      {
+        error: 'Failed to fetch template files',
+        details: error instanceof Error ? error.message : String(error),
+      },
+      { status: 500 },
+    );
+  }
+}