crca 1.4.0__py3-none-any.whl

tools/bolt.diy/app/routes/api.supabase.query.ts

@@ -0,0 +1,92 @@
+import { type ActionFunctionArgs } from '@remix-run/cloudflare';
+import { createScopedLogger } from '~/utils/logger';
+
+const logger = createScopedLogger('api.supabase.query');
+
+export async function action({ request }: ActionFunctionArgs) {
+  if (request.method !== 'POST') {
+    return new Response('Method not allowed', { status: 405 });
+  }
+
+  const authHeader = request.headers.get('Authorization');
+
+  if (!authHeader) {
+    return new Response('No authorization token provided', { status: 401 });
+  }
+
+  try {
+    const { projectId, query } = (await request.json()) as any;
+    logger.debug('Executing query:', { projectId, query });
+
+    const response = await fetch(`https://api.supabase.com/v1/projects/${projectId}/database/query`, {
+      method: 'POST',
+      headers: {
+        Authorization: authHeader,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ query }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorData;
+
+      try {
+        errorData = JSON.parse(errorText);
+      } catch (e) {
+        console.log(e);
+        errorData = { message: errorText };
+      }
+
+      logger.error(
+        'Supabase API error:',
+        JSON.stringify({
+          status: response.status,
+          statusText: response.statusText,
+          error: errorData,
+        }),
+      );
+
+      return new Response(
+        JSON.stringify({
+          error: {
+            status: response.status,
+            statusText: response.statusText,
+            message: errorData.message || errorData.error || errorText,
+            details: errorData,
+          },
+        }),
+        {
+          status: response.status,
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        },
+      );
+    }
+
+    const result = await response.json();
+
+    return new Response(JSON.stringify(result), {
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+  } catch (error) {
+    logger.error('Query execution error:', error);
+    return new Response(
+      JSON.stringify({
+        error: {
+          message: error instanceof Error ? error.message : 'Query execution failed',
+          stack: error instanceof Error ? error.stack : undefined,
+        },
+      }),
+      {
+        status: 500,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      },
+    );
+  }
+}

tools/bolt.diy/app/routes/api.supabase.ts

@@ -0,0 +1,56 @@
+import { json, type ActionFunction } from '@remix-run/cloudflare';
+import type { SupabaseProject } from '~/types/supabase';
+
+export const action: ActionFunction = async ({ request }) => {
+  if (request.method !== 'POST') {
+    return json({ error: 'Method not allowed' }, { status: 405 });
+  }
+
+  try {
+    const { token } = (await request.json()) as any;
+
+    const projectsResponse = await fetch('https://api.supabase.com/v1/projects', {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!projectsResponse.ok) {
+      const errorText = await projectsResponse.text();
+      console.error('Projects fetch failed:', errorText);
+
+      return json({ error: 'Failed to fetch projects' }, { status: 401 });
+    }
+
+    const projects = (await projectsResponse.json()) as SupabaseProject[];
+
+    const uniqueProjectsMap = new Map<string, SupabaseProject>();
+
+    for (const project of projects) {
+      if (!uniqueProjectsMap.has(project.id)) {
+        uniqueProjectsMap.set(project.id, project);
+      }
+    }
+
+    const uniqueProjects = Array.from(uniqueProjectsMap.values());
+
+    uniqueProjects.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+
+    return json({
+      user: { email: 'Connected', role: 'Admin' },
+      stats: {
+        projects: uniqueProjects,
+        totalProjects: uniqueProjects.length,
+      },
+    });
+  } catch (error) {
+    console.error('Supabase API error:', error);
+    return json(
+      {
+        error: error instanceof Error ? error.message : 'Authentication failed',
+      },
+      { status: 401 },
+    );
+  }
+};

tools/bolt.diy/app/routes/api.supabase.variables.ts

@@ -0,0 +1,32 @@
+import { json, type ActionFunctionArgs } from '@remix-run/cloudflare';
+
+export async function action({ request }: ActionFunctionArgs) {
+  try {
+    // Add proper type assertion for the request body
+    const body = (await request.json()) as { projectId?: string; token?: string };
+    const { projectId, token } = body;
+
+    if (!projectId || !token) {
+      return json({ error: 'Project ID and token are required' }, { status: 400 });
+    }
+
+    const response = await fetch(`https://api.supabase.com/v1/projects/${projectId}/api-keys`, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      return json({ error: `Failed to fetch API keys: ${response.statusText}` }, { status: response.status });
+    }
+
+    const apiKeys = await response.json();
+
+    return json({ apiKeys });
+  } catch (error) {
+    console.error('Error fetching project API keys:', error);
+    return json({ error: error instanceof Error ? error.message : 'Unknown error occurred' }, { status: 500 });
+  }
+}

tools/bolt.diy/app/routes/api.system.diagnostics.ts

@@ -0,0 +1,142 @@
+import { json, type LoaderFunction, type LoaderFunctionArgs } from '@remix-run/cloudflare';
+
+/**
+ * Diagnostic API for troubleshooting connection issues
+ */
+
+interface AppContext {
+  env?: {
+    GITHUB_ACCESS_TOKEN?: string;
+    NETLIFY_TOKEN?: string;
+  };
+}
+
+export const loader: LoaderFunction = async ({ request, context }: LoaderFunctionArgs & { context: AppContext }) => {
+  // Get environment variables
+  const envVars = {
+    hasGithubToken: Boolean(process.env.GITHUB_ACCESS_TOKEN || context.env?.GITHUB_ACCESS_TOKEN),
+    hasNetlifyToken: Boolean(process.env.NETLIFY_TOKEN || context.env?.NETLIFY_TOKEN),
+    nodeEnv: process.env.NODE_ENV,
+  };
+
+  // Check cookies
+  const cookieHeader = request.headers.get('Cookie') || '';
+  const cookies = cookieHeader.split(';').reduce(
+    (acc, cookie) => {
+      const [key, value] = cookie.trim().split('=');
+
+      if (key) {
+        acc[key] = value;
+      }
+
+      return acc;
+    },
+    {} as Record<string, string>,
+  );
+
+  const hasGithubTokenCookie = Boolean(cookies.githubToken);
+  const hasGithubUsernameCookie = Boolean(cookies.githubUsername);
+  const hasNetlifyCookie = Boolean(cookies.netlifyToken);
+
+  // Get local storage status (this can only be checked client-side)
+  const localStorageStatus = {
+    explanation: 'Local storage can only be checked on the client side. Use browser devtools to check.',
+    githubKeysToCheck: ['github_connection'],
+    netlifyKeysToCheck: ['netlify_connection'],
+  };
+
+  // Check if CORS might be an issue
+  const corsStatus = {
+    headers: {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    },
+  };
+
+  // Check if API endpoints are reachable
+  const apiEndpoints = {
+    githubUser: '/api/system/git-info?action=getUser',
+    githubRepos: '/api/system/git-info?action=getRepos',
+    githubOrgs: '/api/system/git-info?action=getOrgs',
+    githubActivity: '/api/system/git-info?action=getActivity',
+    gitInfo: '/api/system/git-info',
+  };
+
+  // Test GitHub API connectivity
+  let githubApiStatus;
+
+  try {
+    const githubResponse = await fetch('https://api.github.com/zen', {
+      method: 'GET',
+      headers: {
+        Accept: 'application/vnd.github.v3+json',
+      },
+    });
+
+    githubApiStatus = {
+      isReachable: githubResponse.ok,
+      status: githubResponse.status,
+      statusText: githubResponse.statusText,
+    };
+  } catch (error) {
+    githubApiStatus = {
+      isReachable: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+
+  // Test Netlify API connectivity
+  let netlifyApiStatus;
+
+  try {
+    const netlifyResponse = await fetch('https://api.netlify.com/api/v1/', {
+      method: 'GET',
+    });
+
+    netlifyApiStatus = {
+      isReachable: netlifyResponse.ok,
+      status: netlifyResponse.status,
+      statusText: netlifyResponse.statusText,
+    };
+  } catch (error) {
+    netlifyApiStatus = {
+      isReachable: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+
+  // Provide technical details about the environment
+  const technicalDetails = {
+    serverTimestamp: new Date().toISOString(),
+    userAgent: request.headers.get('User-Agent'),
+    referrer: request.headers.get('Referer'),
+    host: request.headers.get('Host'),
+    method: request.method,
+    url: request.url,
+  };
+
+  // Return diagnostics
+  return json(
+    {
+      status: 'success',
+      environment: envVars,
+      cookies: {
+        hasGithubTokenCookie,
+        hasGithubUsernameCookie,
+        hasNetlifyCookie,
+      },
+      localStorage: localStorageStatus,
+      apiEndpoints,
+      externalApis: {
+        github: githubApiStatus,
+        netlify: netlifyApiStatus,
+      },
+      corsStatus,
+      technicalDetails,
+    },
+    {
+      headers: corsStatus.headers,
+    },
+  );
+};

tools/bolt.diy/app/routes/api.system.disk-info.ts

@@ -0,0 +1,311 @@
+import type { ActionFunctionArgs, LoaderFunction } from '@remix-run/cloudflare';
+import { json } from '@remix-run/cloudflare';
+
+// Only import child_process if we're not in a Cloudflare environment
+let execSync: any;
+
+try {
+  // Check if we're in a Node.js environment
+  if (typeof process !== 'undefined' && process.platform) {
+    // Using dynamic import to avoid require()
+    const childProcess = { execSync: null };
+    execSync = childProcess.execSync;
+  }
+} catch {
+  // In Cloudflare environment, this will fail, which is expected
+  console.log('Running in Cloudflare environment, child_process not available');
+}
+
+// For development environments, we'll always provide mock data if real data isn't available
+const isDevelopment = process.env.NODE_ENV === 'development';
+
+interface DiskInfo {
+  filesystem: string;
+  size: number;
+  used: number;
+  available: number;
+  percentage: number;
+  mountpoint: string;
+  timestamp: string;
+  error?: string;
+}
+
+const getDiskInfo = (): DiskInfo[] => {
+  // If we're in a Cloudflare environment and not in development, return error
+  if (!execSync && !isDevelopment) {
+    return [
+      {
+        filesystem: 'N/A',
+        size: 0,
+        used: 0,
+        available: 0,
+        percentage: 0,
+        mountpoint: 'N/A',
+        timestamp: new Date().toISOString(),
+        error: 'Disk information is not available in this environment',
+      },
+    ];
+  }
+
+  // If we're in development but not in Node environment, return mock data
+  if (!execSync && isDevelopment) {
+    // Generate random percentage between 40-60%
+    const percentage = Math.floor(40 + Math.random() * 20);
+    const totalSize = 500 * 1024 * 1024 * 1024; // 500GB
+    const usedSize = Math.floor((totalSize * percentage) / 100);
+    const availableSize = totalSize - usedSize;
+
+    return [
+      {
+        filesystem: 'MockDisk',
+        size: totalSize,
+        used: usedSize,
+        available: availableSize,
+        percentage,
+        mountpoint: '/',
+        timestamp: new Date().toISOString(),
+      },
+      {
+        filesystem: 'MockDisk2',
+        size: 1024 * 1024 * 1024 * 1024, // 1TB
+        used: 300 * 1024 * 1024 * 1024, // 300GB
+        available: 724 * 1024 * 1024 * 1024, // 724GB
+        percentage: 30,
+        mountpoint: '/data',
+        timestamp: new Date().toISOString(),
+      },
+    ];
+  }
+
+  try {
+    // Different commands for different operating systems
+    const platform = process.platform;
+    let disks: DiskInfo[] = [];
+
+    if (platform === 'darwin') {
+      // macOS - use df command to get disk information
+      try {
+        const output = execSync('df -k', { encoding: 'utf-8' }).toString().trim();
+
+        // Skip the header line
+        const lines = output.split('\n').slice(1);
+
+        disks = lines.map((line: string) => {
+          const parts = line.trim().split(/\s+/);
+          const filesystem = parts[0];
+          const size = parseInt(parts[1], 10) * 1024; // Convert KB to bytes
+          const used = parseInt(parts[2], 10) * 1024;
+          const available = parseInt(parts[3], 10) * 1024;
+          const percentageStr = parts[4].replace('%', '');
+          const percentage = parseInt(percentageStr, 10);
+          const mountpoint = parts[5];
+
+          return {
+            filesystem,
+            size,
+            used,
+            available,
+            percentage,
+            mountpoint,
+            timestamp: new Date().toISOString(),
+          };
+        });
+
+        // Filter out non-physical disks
+        disks = disks.filter(
+          (disk) =>
+            !disk.filesystem.startsWith('devfs') &&
+            !disk.filesystem.startsWith('map') &&
+            !disk.mountpoint.startsWith('/System/Volumes') &&
+            disk.size > 0,
+        );
+      } catch (error) {
+        console.error('Failed to get macOS disk info:', error);
+        return [
+          {
+            filesystem: 'Unknown',
+            size: 0,
+            used: 0,
+            available: 0,
+            percentage: 0,
+            mountpoint: '/',
+            timestamp: new Date().toISOString(),
+            error: error instanceof Error ? error.message : 'Unknown error',
+          },
+        ];
+      }
+    } else if (platform === 'linux') {
+      // Linux - use df command to get disk information
+      try {
+        const output = execSync('df -k', { encoding: 'utf-8' }).toString().trim();
+
+        // Skip the header line
+        const lines = output.split('\n').slice(1);
+
+        disks = lines.map((line: string) => {
+          const parts = line.trim().split(/\s+/);
+          const filesystem = parts[0];
+          const size = parseInt(parts[1], 10) * 1024; // Convert KB to bytes
+          const used = parseInt(parts[2], 10) * 1024;
+          const available = parseInt(parts[3], 10) * 1024;
+          const percentageStr = parts[4].replace('%', '');
+          const percentage = parseInt(percentageStr, 10);
+          const mountpoint = parts[5];
+
+          return {
+            filesystem,
+            size,
+            used,
+            available,
+            percentage,
+            mountpoint,
+            timestamp: new Date().toISOString(),
+          };
+        });
+
+        // Filter out non-physical disks
+        disks = disks.filter(
+          (disk) =>
+            !disk.filesystem.startsWith('/dev/loop') &&
+            !disk.filesystem.startsWith('tmpfs') &&
+            !disk.filesystem.startsWith('devtmpfs') &&
+            disk.size > 0,
+        );
+      } catch (error) {
+        console.error('Failed to get Linux disk info:', error);
+        return [
+          {
+            filesystem: 'Unknown',
+            size: 0,
+            used: 0,
+            available: 0,
+            percentage: 0,
+            mountpoint: '/',
+            timestamp: new Date().toISOString(),
+            error: error instanceof Error ? error.message : 'Unknown error',
+          },
+        ];
+      }
+    } else if (platform === 'win32') {
+      // Windows - use PowerShell to get disk information
+      try {
+        const output = execSync(
+          'powershell "Get-PSDrive -PSProvider FileSystem | Select-Object Name, Used, Free, @{Name=\'Size\';Expression={$_.Used + $_.Free}} | ConvertTo-Json"',
+          { encoding: 'utf-8' },
+        )
+          .toString()
+          .trim();
+
+        const driveData = JSON.parse(output);
+        const drivesArray = Array.isArray(driveData) ? driveData : [driveData];
+
+        disks = drivesArray.map((drive) => {
+          const size = drive.Size || 0;
+          const used = drive.Used || 0;
+          const available = drive.Free || 0;
+          const percentage = size > 0 ? Math.round((used / size) * 100) : 0;
+
+          return {
+            filesystem: drive.Name + ':\\',
+            size,
+            used,
+            available,
+            percentage,
+            mountpoint: drive.Name + ':\\',
+            timestamp: new Date().toISOString(),
+          };
+        });
+      } catch (error) {
+        console.error('Failed to get Windows disk info:', error);
+        return [
+          {
+            filesystem: 'Unknown',
+            size: 0,
+            used: 0,
+            available: 0,
+            percentage: 0,
+            mountpoint: 'C:\\',
+            timestamp: new Date().toISOString(),
+            error: error instanceof Error ? error.message : 'Unknown error',
+          },
+        ];
+      }
+    } else {
+      console.warn(`Unsupported platform: ${platform}`);
+      return [
+        {
+          filesystem: 'Unknown',
+          size: 0,
+          used: 0,
+          available: 0,
+          percentage: 0,
+          mountpoint: '/',
+          timestamp: new Date().toISOString(),
+          error: `Unsupported platform: ${platform}`,
+        },
+      ];
+    }
+
+    return disks;
+  } catch (error) {
+    console.error('Failed to get disk info:', error);
+    return [
+      {
+        filesystem: 'Unknown',
+        size: 0,
+        used: 0,
+        available: 0,
+        percentage: 0,
+        mountpoint: '/',
+        timestamp: new Date().toISOString(),
+        error: error instanceof Error ? error.message : 'Unknown error',
+      },
+    ];
+  }
+};
+
+export const loader: LoaderFunction = async ({ request: _request }) => {
+  try {
+    return json(getDiskInfo());
+  } catch (error) {
+    console.error('Failed to get disk info:', error);
+    return json(
+      [
+        {
+          filesystem: 'Unknown',
+          size: 0,
+          used: 0,
+          available: 0,
+          percentage: 0,
+          mountpoint: '/',
+          timestamp: new Date().toISOString(),
+          error: error instanceof Error ? error.message : 'Unknown error',
+        },
+      ],
+      { status: 500 },
+    );
+  }
+};
+
+export const action = async ({ request: _request }: ActionFunctionArgs) => {
+  try {
+    return json(getDiskInfo());
+  } catch (error) {
+    console.error('Failed to get disk info:', error);
+    return json(
+      [
+        {
+          filesystem: 'Unknown',
+          size: 0,
+          used: 0,
+          available: 0,
+          percentage: 0,
+          mountpoint: '/',
+          timestamp: new Date().toISOString(),
+          error: error instanceof Error ? error.message : 'Unknown error',
+        },
+      ],
+      { status: 500 },
+    );
+  }
+};