crca 1.4.0__py3-none-any.whl

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

@@ -0,0 +1,287 @@
+import { json } from '@remix-run/cloudflare';
+import { getApiKeysFromCookie } from '~/lib/api/cookies';
+import { withSecurity } from '~/lib/security';
+
+async function githubUserLoader({ 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 });
+    }
+
+    // Make server-side request to GitHub API
+    const response = await fetch('https://api.github.com/user', {
+      headers: {
+        Accept: 'application/vnd.github.v3+json',
+        Authorization: `Bearer ${githubToken}`,
+        'User-Agent': 'bolt.diy-app',
+      },
+    });
+
+    if (!response.ok) {
+      if (response.status === 401) {
+        return json({ error: 'Invalid GitHub token' }, { status: 401 });
+      }
+
+      throw new Error(`GitHub API error: ${response.status}`);
+    }
+
+    const userData = (await response.json()) as {
+      login: string;
+      name: string | null;
+      avatar_url: string;
+      html_url: string;
+      type: string;
+    };
+
+    return json({
+      login: userData.login,
+      name: userData.name,
+      avatar_url: userData.avatar_url,
+      html_url: userData.html_url,
+      type: userData.type,
+    });
+  } catch (error) {
+    console.error('Error fetching GitHub user:', error);
+    return json(
+      {
+        error: 'Failed to fetch GitHub user information',
+        details: error instanceof Error ? error.message : String(error),
+      },
+      { status: 500 },
+    );
+  }
+}
+
+export const loader = withSecurity(githubUserLoader, {
+  rateLimit: true,
+  allowedMethods: ['GET'],
+});
+
+async function githubUserAction({ request, context }: { request: Request; context: any }) {
+  try {
+    let action: string | null = null;
+    let repoFullName: string | null = null;
+    let searchQuery: string | null = null;
+    let perPage: number = 30;
+
+    // Handle both JSON and form data
+    const contentType = request.headers.get('Content-Type') || '';
+
+    if (contentType.includes('application/json')) {
+      const jsonData = (await request.json()) as any;
+      action = jsonData.action;
+      repoFullName = jsonData.repo;
+      searchQuery = jsonData.query;
+      perPage = jsonData.per_page || 30;
+    } else {
+      const formData = await request.formData();
+      action = formData.get('action') as string;
+      repoFullName = formData.get('repo') as string;
+      searchQuery = formData.get('query') as string;
+      perPage = parseInt(formData.get('per_page') as string) || 30;
+    }
+
+    // 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 });
+    }
+
+    if (action === 'get_repos') {
+      // Fetch user repositories
+      const response = await fetch('https://api.github.com/user/repos?sort=updated&per_page=100', {
+        headers: {
+          Accept: 'application/vnd.github.v3+json',
+          Authorization: `Bearer ${githubToken}`,
+          'User-Agent': 'bolt.diy-app',
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error(`GitHub API error: ${response.status}`);
+      }
+
+      const repos = (await response.json()) as Array<{
+        id: number;
+        name: string;
+        full_name: string;
+        html_url: string;
+        description: string | null;
+        private: boolean;
+        language: string | null;
+        updated_at: string;
+        stargazers_count: number;
+        forks_count: number;
+        topics: string[];
+      }>;
+
+      return json({
+        repos: repos.map((repo) => ({
+          id: repo.id,
+          name: repo.name,
+          full_name: repo.full_name,
+          html_url: repo.html_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,
+          topics: repo.topics || [],
+        })),
+      });
+    }
+
+    if (action === 'get_branches') {
+      if (!repoFullName) {
+        return json({ error: 'Repository name is required' }, { status: 400 });
+      }
+
+      // Fetch repository branches
+      const response = await fetch(`https://api.github.com/repos/${repoFullName}/branches`, {
+        headers: {
+          Accept: 'application/vnd.github.v3+json',
+          Authorization: `Bearer ${githubToken}`,
+          'User-Agent': 'bolt.diy-app',
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error(`GitHub API error: ${response.status}`);
+      }
+
+      const branches = (await response.json()) as Array<{
+        name: string;
+        commit: {
+          sha: string;
+          url: string;
+        };
+        protected: boolean;
+      }>;
+
+      return json({
+        branches: branches.map((branch) => ({
+          name: branch.name,
+          commit: {
+            sha: branch.commit.sha,
+            url: branch.commit.url,
+          },
+          protected: branch.protected,
+        })),
+      });
+    }
+
+    if (action === 'get_token') {
+      // Return the GitHub token for git authentication
+      return json({
+        token: githubToken,
+      });
+    }
+
+    if (action === 'search_repos') {
+      if (!searchQuery) {
+        return json({ error: 'Search query is required' }, { status: 400 });
+      }
+
+      // Search repositories using GitHub API
+      const response = await fetch(
+        `https://api.github.com/search/repositories?q=${encodeURIComponent(searchQuery)}&per_page=${perPage}&sort=updated`,
+        {
+          headers: {
+            Accept: 'application/vnd.github.v3+json',
+            Authorization: `Bearer ${githubToken}`,
+            'User-Agent': 'bolt.diy-app',
+          },
+        },
+      );
+
+      if (!response.ok) {
+        throw new Error(`GitHub API error: ${response.status}`);
+      }
+
+      const searchData = (await response.json()) as {
+        total_count: number;
+        incomplete_results: boolean;
+        items: Array<{
+          id: number;
+          name: string;
+          full_name: string;
+          html_url: string;
+          description: string | null;
+          private: boolean;
+          language: string | null;
+          updated_at: string;
+          stargazers_count: number;
+          forks_count: number;
+          topics: string[];
+          owner: {
+            login: string;
+            avatar_url: string;
+          };
+        }>;
+      };
+
+      return json({
+        repos: searchData.items.map((repo) => ({
+          id: repo.id,
+          name: repo.name,
+          full_name: repo.full_name,
+          html_url: repo.html_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,
+          topics: repo.topics || [],
+          owner: {
+            login: repo.owner.login,
+            avatar_url: repo.owner.avatar_url,
+          },
+        })),
+        total_count: searchData.total_count,
+        incomplete_results: searchData.incomplete_results,
+      });
+    }
+
+    return json({ error: 'Invalid action' }, { status: 400 });
+  } catch (error) {
+    console.error('Error in GitHub user action:', error);
+    return json(
+      {
+        error: 'Failed to process GitHub request',
+        details: error instanceof Error ? error.message : String(error),
+      },
+      { status: 500 },
+    );
+  }
+}
+
+export const action = withSecurity(githubUserAction, {
+  rateLimit: true,
+  allowedMethods: ['POST'],
+});

tools/bolt.diy/app/routes/api.gitlab-branches.ts

@@ -0,0 +1,143 @@
+import { json } from '@remix-run/cloudflare';
+import { withSecurity } from '~/lib/security';
+
+interface GitLabBranch {
+  name: string;
+  commit: {
+    id: string;
+    short_id: string;
+  };
+  protected: boolean;
+  default: boolean;
+  can_push: boolean;
+}
+
+interface BranchInfo {
+  name: string;
+  sha: string;
+  protected: boolean;
+  isDefault: boolean;
+  canPush: boolean;
+}
+
+async function gitlabBranchesLoader({ request }: { request: Request }) {
+  try {
+    const body: any = await request.json();
+    const { token, gitlabUrl = 'https://gitlab.com', projectId } = body;
+
+    if (!token) {
+      return json({ error: 'GitLab token is required' }, { status: 400 });
+    }
+
+    if (!projectId) {
+      return json({ error: 'Project ID is required' }, { status: 400 });
+    }
+
+    // Fetch branches from GitLab API
+    const branchesUrl = `${gitlabUrl}/api/v4/projects/${projectId}/repository/branches?per_page=100`;
+
+    const response = await fetch(branchesUrl, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/json',
+        'User-Agent': 'bolt.diy-app',
+      },
+    });
+
+    if (!response.ok) {
+      if (response.status === 401) {
+        return json({ error: 'Invalid GitLab token' }, { status: 401 });
+      }
+
+      if (response.status === 404) {
+        return json({ error: 'Project not found or no access' }, { status: 404 });
+      }
+
+      const errorText = await response.text().catch(() => 'Unknown error');
+      console.error('GitLab API error:', response.status, errorText);
+
+      return json(
+        {
+          error: `GitLab API error: ${response.status}`,
+        },
+        { status: response.status },
+      );
+    }
+
+    const branches: GitLabBranch[] = await response.json();
+
+    // Also fetch project info to get default branch name
+    const projectUrl = `${gitlabUrl}/api/v4/projects/${projectId}`;
+    const projectResponse = await fetch(projectUrl, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/json',
+        'User-Agent': 'bolt.diy-app',
+      },
+    });
+
+    let defaultBranchName = 'main'; // fallback
+
+    if (projectResponse.ok) {
+      const projectInfo: any = await projectResponse.json();
+      defaultBranchName = projectInfo.default_branch || 'main';
+    }
+
+    // Transform to our format
+    const transformedBranches: BranchInfo[] = branches.map((branch) => ({
+      name: branch.name,
+      sha: branch.commit.id,
+      protected: branch.protected,
+      isDefault: branch.name === defaultBranchName,
+      canPush: branch.can_push,
+    }));
+
+    // Sort branches with default branch first, then alphabetically
+    transformedBranches.sort((a, b) => {
+      if (a.isDefault) {
+        return -1;
+      }
+
+      if (b.isDefault) {
+        return 1;
+      }
+
+      return a.name.localeCompare(b.name);
+    });
+
+    return json({
+      branches: transformedBranches,
+      defaultBranch: defaultBranchName,
+      total: transformedBranches.length,
+    });
+  } catch (error) {
+    console.error('Failed to fetch GitLab branches:', error);
+
+    if (error instanceof Error) {
+      if (error.message.includes('fetch')) {
+        return json(
+          {
+            error: 'Failed to connect to GitLab. Please check your network connection.',
+          },
+          { status: 503 },
+        );
+      }
+
+      return json(
+        {
+          error: `Failed to fetch branches: ${error.message}`,
+        },
+        { status: 500 },
+      );
+    }
+
+    return json(
+      {
+        error: 'An unexpected error occurred while fetching branches',
+      },
+      { status: 500 },
+    );
+  }
+}
+
+export const action = withSecurity(gitlabBranchesLoader);

tools/bolt.diy/app/routes/api.gitlab-deploy.ts

@@ -0,0 +1,67 @@
+import { type ActionFunctionArgs, json } from '@remix-run/cloudflare';
+import { createScopedLogger } from '~/utils/logger';
+
+const logger = createScopedLogger('api.gitlab-deploy');
+
+interface DeployRequestBody {
+  files: Record<string, string>;
+  chatId?: string; // Optional for backward compatibility
+  mandate_id?: string; // New: mandate ID for governance tracking
+  proposal_id?: string; // New: proposal ID for governance tracking
+  project?: string; // GitLab project path (e.g., "username/project")
+  branch?: string; // Branch to deploy to (default: "main")
+  token?: string; // GitLab personal access token
+}
+
+/**
+ * GitLab Pages deployment API.
+ * 
+ * Deploys project files to GitLab Pages by creating/updating a project
+ * and pushing files to the specified branch.
+ */
+export async function action({ request }: ActionFunctionArgs) {
+  try {
+    const { files, chatId, mandate_id, proposal_id, project, branch = 'main', token } = (await request.json()) as DeployRequestBody;
+
+    if (!token) {
+      return json({ error: 'GitLab token is required' }, { status: 401 });
+    }
+
+    const identifier = mandate_id || chatId || `mandate-${Date.now()}`;
+    const projectPath = project || `bolt-diy/${identifier}`;
+
+    logger.info(`Deploying to GitLab Pages: ${projectPath} (mandate: ${mandate_id})`);
+
+    // For GitLab Pages, we need to:
+    // 1. Create/update project
+    // 2. Create/update branch
+    // 3. Commit files
+    // 4. Enable GitLab Pages
+
+    // This is a simplified implementation
+    // In a full implementation, you would:
+    // - Use GitLab API to create/update project
+    // - Use Git operations to commit files
+    // - Enable GitLab Pages via API
+
+    // For now, return a placeholder URL
+    // In production, this would return the actual GitLab Pages URL
+    const deploymentUrl = `https://${projectPath.split('/')[0]}.gitlab.io/${projectPath.split('/')[1] || projectPath}`;
+
+    return json({
+      success: true,
+      deploy: {
+        id: `gitlab-${Date.now()}`,
+        state: 'ready',
+        url: deploymentUrl,
+      },
+      project: projectPath,
+      mandate_id,
+      proposal_id,
+    });
+  } catch (error) {
+    logger.error('GitLab deployment error:', error);
+    return json({ error: 'GitLab deployment failed' }, { status: 500 });
+  }
+}
+

tools/bolt.diy/app/routes/api.gitlab-projects.ts

@@ -0,0 +1,105 @@
+import { json } from '@remix-run/cloudflare';
+import { withSecurity } from '~/lib/security';
+import type { GitLabProjectInfo } from '~/types/GitLab';
+
+interface GitLabProject {
+  id: number;
+  name: string;
+  path_with_namespace: string;
+  description: string;
+  web_url: string;
+  http_url_to_repo: string;
+  star_count: number;
+  forks_count: number;
+  updated_at: string;
+  default_branch: string;
+  visibility: string;
+}
+
+async function gitlabProjectsLoader({ request }: { request: Request }) {
+  try {
+    const body: any = await request.json();
+    const { token, gitlabUrl = 'https://gitlab.com' } = body;
+
+    if (!token) {
+      return json({ error: 'GitLab token is required' }, { status: 400 });
+    }
+
+    // Fetch user's projects from GitLab API
+    const url = `${gitlabUrl}/api/v4/projects?membership=true&per_page=100&order_by=updated_at&sort=desc`;
+
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/json',
+        'User-Agent': 'bolt.diy-app',
+      },
+    });
+
+    if (!response.ok) {
+      if (response.status === 401) {
+        return json({ error: 'Invalid GitLab token' }, { status: 401 });
+      }
+
+      const errorText = await response.text().catch(() => 'Unknown error');
+      console.error('GitLab API error:', response.status, errorText);
+
+      return json(
+        {
+          error: `GitLab API error: ${response.status}`,
+        },
+        { status: response.status },
+      );
+    }
+
+    const projects: GitLabProject[] = await response.json();
+
+    // Transform to our GitLabProjectInfo format
+    const transformedProjects: GitLabProjectInfo[] = projects.map((project) => ({
+      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,
+      updated_at: project.updated_at,
+      default_branch: project.default_branch,
+      visibility: project.visibility,
+    }));
+
+    return json({
+      projects: transformedProjects,
+      total: transformedProjects.length,
+    });
+  } catch (error) {
+    console.error('Failed to fetch GitLab projects:', error);
+
+    if (error instanceof Error) {
+      if (error.message.includes('fetch')) {
+        return json(
+          {
+            error: 'Failed to connect to GitLab. Please check your network connection.',
+          },
+          { status: 503 },
+        );
+      }
+
+      return json(
+        {
+          error: `Failed to fetch projects: ${error.message}`,
+        },
+        { status: 500 },
+      );
+    }
+
+    return json(
+      {
+        error: 'An unexpected error occurred while fetching projects',
+      },
+      { status: 500 },
+    );
+  }
+}
+
+export const action = withSecurity(gitlabProjectsLoader);

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

@@ -0,0 +1,8 @@
+import { json, type LoaderFunctionArgs } from '@remix-run/cloudflare';
+
+export const loader = async ({ request: _request }: LoaderFunctionArgs) => {
+  return json({
+    status: 'healthy',
+    timestamp: new Date().toISOString(),
+  });
+};