dev3000 0.0.121 → 0.0.124

package/mcp-server/app/api/integration/webhook/route.ts

@@ -1,290 +0,0 @@
-/**
- * Vercel Integration Webhook Handler
- *
- * This endpoint receives webhooks from Vercel when deployments are ready.
- * It automatically triggers PR checks for preview deployments.
- *
- * Note: This uses Vercel's deployment metadata which includes GitHub info
- * automatically - no GitHub token setup required!
- */
-
-export async function POST(request: Request) {
-  try {
-    const payload = await request.json()
-
-    console.log("[Webhook] Received deployment event")
-    console.log(`[Webhook] Type: ${payload.type}`)
-    console.log(`[Webhook] Deployment: ${payload.deployment?.url}`)
-
-    // Only process deployment.created events for preview deployments
-    if (payload.type !== "deployment.created") {
-      return Response.json({ message: "Ignoring non-deployment event" })
-    }
-
-    const deployment = payload.deployment
-
-    // Only process preview deployments (not production)
-    if (deployment.target === "production") {
-      console.log("[Webhook] Skipping production deployment")
-      return Response.json({ message: "Skipping production deployment" })
-    }
-
-    // Check if this is a PR deployment
-    if (!deployment.meta?.githubCommitRef || !deployment.meta?.githubOrg || !deployment.meta?.githubRepo) {
-      console.log("[Webhook] Not a GitHub PR deployment")
-      return Response.json({ message: "Not a GitHub PR deployment" })
-    }
-
-    const branch = deployment.meta.githubCommitRef
-    const owner = deployment.meta.githubOrg
-    const repo = deployment.meta.githubRepo
-    const previewUrl = `https://${deployment.url}`
-
-    console.log(`[Webhook] Processing PR deployment for ${owner}/${repo}#${branch}`)
-
-    // Find the PR number for this branch
-    const prNumber = await findPRNumber(owner, repo, branch)
-
-    if (!prNumber) {
-      console.log(`[Webhook] No PR found for branch: ${branch}`)
-      return Response.json({ message: "No PR found for this branch" })
-    }
-
-    console.log(`[Webhook] Found PR #${prNumber}`)
-
-    // Fetch PR details
-    const prDetails = await fetchPRDetails(owner, repo, prNumber)
-
-    if (!prDetails) {
-      console.log(`[Webhook] Failed to fetch PR details`)
-      return Response.json({ error: "Failed to fetch PR details" }, { status: 500 })
-    }
-
-    // Get changed files
-    const changedFiles = await getChangedFiles(owner, repo, prNumber)
-
-    // Trigger the check-pr workflow
-    console.log(`[Webhook] Triggering PR check workflow`)
-
-    const workflowUrl = "https://dev3000-mcp.vercel.sh/api/cloud/check-pr"
-
-    const workflowResponse = await fetch(workflowUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        previewUrl,
-        prTitle: prDetails.title,
-        prBody: prDetails.body,
-        changedFiles,
-        repoOwner: owner,
-        repoName: repo,
-        prNumber
-      })
-    })
-
-    if (!workflowResponse.ok) {
-      console.error(`[Webhook] Workflow failed: ${workflowResponse.status}`)
-      return Response.json({ error: "Workflow failed" }, { status: 500 })
-    }
-
-    const result = await workflowResponse.json()
-
-    console.log(`[Webhook] Workflow completed: ${result.success ? "success" : "failed"}`)
-    console.log(`[Webhook] Report URL: ${result.reportUrl}`)
-
-    // Optional: Post comment on PR if GITHUB_TOKEN is set
-    if (process.env.GITHUB_TOKEN) {
-      await postPRComment(owner, repo, prNumber, result)
-      await setGitHubCheck(owner, repo, deployment.meta.githubCommitSha, result)
-      console.log(`[Webhook] Posted results to PR`)
-    } else {
-      console.log(`[Webhook] Skipping GitHub comment (no GITHUB_TOKEN set)`)
-      console.log(`[Webhook] View report at: ${result.reportUrl}`)
-    }
-
-    return Response.json({
-      success: true,
-      prNumber,
-      reportUrl: result.reportUrl,
-      checksPassed: result.success,
-      githubCommentPosted: !!process.env.GITHUB_TOKEN
-    })
-  } catch (error) {
-    console.error("[Webhook] Error:", error)
-    return Response.json({ error: error instanceof Error ? error.message : "Unknown error" }, { status: 500 })
-  }
-}
-
-/**
- * Find PR number for a given branch
- */
-async function findPRNumber(owner: string, repo: string, branch: string): Promise<string | null> {
-  try {
-    const headers: Record<string, string> = {
-      Accept: "application/vnd.github.v3+json"
-    }
-
-    // Only add Authorization header if token is available
-    if (process.env.GITHUB_TOKEN) {
-      headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`
-    }
-
-    const response = await fetch(
-      `https://api.github.com/repos/${owner}/${repo}/pulls?head=${owner}:${branch}&state=open`,
-      { headers }
-    )
-
-    if (!response.ok) {
-      console.error(`Failed to find PR: ${response.status}`)
-      return null
-    }
-
-    const prs = await response.json()
-    return prs.length > 0 ? String(prs[0].number) : null
-  } catch (error) {
-    console.error("Error finding PR:", error)
-    return null
-  }
-}
-
-/**
- * Fetch PR details from GitHub
- */
-async function fetchPRDetails(owner: string, repo: string, prNumber: string) {
-  try {
-    const headers: Record<string, string> = {
-      Accept: "application/vnd.github.v3+json"
-    }
-
-    // Only add Authorization header if token is available
-    if (process.env.GITHUB_TOKEN) {
-      headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`
-    }
-
-    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}`, {
-      headers
-    })
-
-    if (!response.ok) {
-      return null
-    }
-
-    const pr = await response.json()
-    return {
-      title: pr.title,
-      body: pr.body || "",
-      number: pr.number
-    }
-  } catch (error) {
-    console.error("Error fetching PR details:", error)
-    return null
-  }
-}
-
-/**
- * Get changed files in PR
- */
-async function getChangedFiles(owner: string, repo: string, prNumber: string): Promise<string[]> {
-  try {
-    const headers: Record<string, string> = {
-      Accept: "application/vnd.github.v3+json"
-    }
-
-    // Only add Authorization header if token is available
-    if (process.env.GITHUB_TOKEN) {
-      headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`
-    }
-
-    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}/files`, {
-      headers
-    })
-
-    if (!response.ok) {
-      return []
-    }
-
-    const files = await response.json()
-    // biome-ignore lint/suspicious/noExplicitAny: GitHub API file objects have dynamic structure
-    return files.map((file: any) => file.filename)
-  } catch (error) {
-    console.error("Error getting changed files:", error)
-    return []
-  }
-}
-
-/**
- * Post comment on PR with results
- */
-// biome-ignore lint/suspicious/noExplicitAny: Workflow result object has dynamic structure
-async function postPRComment(owner: string, repo: string, prNumber: string, result: any) {
-  try {
-    const statusEmoji = result.success ? "✅" : "❌"
-    const comment = `## ${statusEmoji} dev3000 PR Check Results
-
-**Status**: ${result.success ? "All checks passed" : "Some checks failed"}
-
-### Summary
-${result.verification?.summary || "Check completed"}
-
-${result.performance?.slowPagesCount > 0 ? `\n⚠️ **Performance**: ${result.performance.slowPagesCount} slow page(s) detected` : ""}
-
-**Full Report**: [View Details](${result.reportUrl})
-
----
-*Powered by [dev3000](https://github.com/vercel-labs/dev3000)*`
-
-    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/issues/${prNumber}/comments`, {
-      method: "POST",
-      headers: {
-        Accept: "application/vnd.github.v3+json",
-        Authorization: `Bearer ${process.env.GITHUB_TOKEN}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ body: comment })
-    })
-
-    if (!response.ok) {
-      console.error(`Failed to post comment: ${response.status}`)
-    } else {
-      console.log(`[Webhook] Posted comment on PR #${prNumber}`)
-    }
-  } catch (error) {
-    console.error("Error posting PR comment:", error)
-  }
-}
-
-/**
- * Set GitHub Check status
- */
-// biome-ignore lint/suspicious/noExplicitAny: Workflow result object has dynamic structure
-async function setGitHubCheck(owner: string, repo: string, sha: string, result: any) {
-  try {
-    const status = result.success ? "success" : "failure"
-    const description = result.success ? "All PR checks passed" : "Some PR checks failed"
-
-    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/statuses/${sha}`, {
-      method: "POST",
-      headers: {
-        Accept: "application/vnd.github.v3+json",
-        Authorization: `Bearer ${process.env.GITHUB_TOKEN}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        state: status,
-        target_url: result.reportUrl,
-        description,
-        context: "dev3000/pr-check"
-      })
-    })
-
-    if (!response.ok) {
-      console.error(`Failed to set GitHub check: ${response.status}`)
-    } else {
-      console.log(`[Webhook] Set GitHub check status: ${status}`)
-    }
-  } catch (error) {
-    console.error("Error setting GitHub check:", error)
-  }
-}

package/mcp-server/app/api/projects/[projectId]/bypass-token/route.ts

@@ -1,48 +0,0 @@
-import { cookies } from "next/headers"
-
-export async function POST(request: Request, { params }: { params: Promise<{ projectId: string }> }) {
-  try {
-    const { projectId } = await params
-    const url = new URL(request.url)
-    const teamId = url.searchParams.get("teamId")
-
-    // Get access token from cookies
-    const cookieStore = await cookies()
-    const accessToken = cookieStore.get("access_token")?.value
-
-    if (!accessToken) {
-      return Response.json({ error: "Unauthorized" }, { status: 401 })
-    }
-
-    // Generate/update deployment protection bypass token for the project
-    const response = await fetch(
-      `https://api.vercel.com/v1/projects/${projectId}/protection-bypass${teamId ? `?teamId=${teamId}` : ""}`,
-      {
-        method: "PATCH",
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          generate: true
-        })
-      }
-    )
-
-    if (!response.ok) {
-      const error = await response.text()
-      console.error("Failed to generate bypass token:", response.status, error)
-      return Response.json({ error: "Failed to generate bypass token", details: error }, { status: response.status })
-    }
-
-    const data = await response.json()
-
-    return Response.json({
-      success: true,
-      token: data.secret
-    })
-  } catch (error) {
-    console.error("Error generating bypass token:", error)
-    return Response.json({ error: error instanceof Error ? error.message : String(error) }, { status: 500 })
-  }
-}

package/mcp-server/app/api/projects/branches/route.ts

@@ -1,115 +0,0 @@
-import { getValidAccessToken } from "@/lib/auth"
-
-/**
- * API Route to fetch branches with recent deployments for a project
- *
- * Query params:
- * - projectId: Vercel project ID (required)
- * - teamId: Team ID or username (optional)
- * - limit: Number of deployments to check (default: 20)
- */
-export async function GET(request: Request) {
-  try {
-    const accessToken = await getValidAccessToken()
-
-    if (!accessToken) {
-      return Response.json({ error: "Not authenticated" }, { status: 401 })
-    }
-
-    const url = new URL(request.url)
-    const projectId = url.searchParams.get("projectId")
-    const teamId = url.searchParams.get("teamId")
-    const limit = url.searchParams.get("limit") || "20"
-
-    if (!projectId) {
-      return Response.json({ error: "projectId is required" }, { status: 400 })
-    }
-
-    // Build the API URL to fetch recent deployments
-    const apiUrl = new URL(`https://api.vercel.com/v6/deployments`)
-    apiUrl.searchParams.set("projectId", projectId)
-    apiUrl.searchParams.set("limit", limit)
-    if (teamId) {
-      apiUrl.searchParams.set("teamId", teamId)
-    }
-
-    console.log("Fetching deployments from Vercel API:", apiUrl.toString())
-    const response = await fetch(apiUrl.toString(), {
-      headers: {
-        Authorization: `Bearer ${accessToken}`
-      }
-    })
-
-    if (!response.ok) {
-      const errorText = await response.text()
-      console.error("Failed to fetch deployments:", response.status, errorText)
-      return Response.json(
-        { error: `Failed to fetch deployments: ${response.status} ${errorText}` },
-        { status: response.status }
-      )
-    }
-
-    const data = await response.json()
-    console.log(`Fetched ${data.deployments?.length || 0} deployments`)
-
-    // Extract unique branches with their latest deployment info
-    const branchesMap = new Map<
-      string,
-      {
-        name: string
-        lastDeployment: {
-          url: string
-          createdAt: number
-          state: string
-          readyState: string
-        }
-      }
-    >()
-
-    for (const deployment of data.deployments || []) {
-      const branch = deployment.meta?.githubCommitRef || deployment.gitSource?.ref || "main"
-
-      // Only include deployments that are ready
-      if (deployment.readyState !== "READY") {
-        continue
-      }
-
-      // Only include the latest deployment per branch
-      if (!branchesMap.has(branch)) {
-        branchesMap.set(branch, {
-          name: branch,
-          lastDeployment: {
-            url: deployment.url,
-            createdAt: deployment.createdAt,
-            state: deployment.state,
-            readyState: deployment.readyState
-          }
-        })
-      }
-    }
-
-    // Convert to array and sort by most recent deployment
-    const branches = Array.from(branchesMap.values()).sort(
-      (a, b) => b.lastDeployment.createdAt - a.lastDeployment.createdAt
-    )
-
-    console.log(
-      `Found ${branches.length} unique branches with ready deployments:`,
-      branches.map((b) => b.name)
-    )
-
-    return Response.json({
-      success: true,
-      branches
-    })
-  } catch (error) {
-    console.error("Error fetching branches:", error)
-    return Response.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      },
-      { status: 500 }
-    )
-  }
-}

package/mcp-server/app/api/projects/check-protection/route.ts

@@ -1,33 +0,0 @@
-export async function POST(request: Request) {
-  try {
-    const { url } = await request.json()
-
-    if (!url) {
-      return Response.json({ error: "URL is required" }, { status: 400 })
-    }
-
-    // Make HEAD request to check if deployment is protected
-    const response = await fetch(url, {
-      method: "HEAD",
-      // Don't follow redirects
-      redirect: "manual"
-    })
-
-    // If we get 401, deployment is protected
-    const isProtected = response.status === 401
-
-    return Response.json({
-      isProtected,
-      status: response.status
-    })
-  } catch (error) {
-    console.error("Error checking deployment protection:", error)
-    return Response.json(
-      {
-        error: error instanceof Error ? error.message : String(error),
-        isProtected: false
-      },
-      { status: 500 }
-    )
-  }
-}

package/mcp-server/app/api/projects/route.ts

@@ -1,97 +0,0 @@
-import { cookies } from "next/headers"
-
-/**
- * API Route to fetch Vercel projects for a team/account
- *
- * Query params:
- * - teamId: Team ID or username (optional - if omitted, fetches personal projects)
- */
-export async function GET(request: Request) {
-  try {
-    const cookieStore = await cookies()
-    const accessToken = cookieStore.get("access_token")?.value
-
-    if (!accessToken) {
-      return Response.json({ error: "Not authenticated" }, { status: 401 })
-    }
-
-    const url = new URL(request.url)
-    const teamId = url.searchParams.get("teamId")
-
-    // Build the API URL with optional teamId parameter
-    const apiUrl = new URL("https://api.vercel.com/v9/projects")
-    if (teamId) {
-      apiUrl.searchParams.set("teamId", teamId)
-    }
-
-    // Fetch projects from Vercel API
-    console.log("Fetching projects from Vercel API:", apiUrl.toString())
-    const response = await fetch(apiUrl.toString(), {
-      headers: {
-        Authorization: `Bearer ${accessToken}`
-      }
-    })
-
-    if (!response.ok) {
-      const errorText = await response.text()
-      console.error("Failed to fetch projects:", response.status, errorText)
-      return Response.json(
-        { error: `Failed to fetch projects: ${response.status} ${errorText}` },
-        { status: response.status }
-      )
-    }
-
-    const data = await response.json()
-    console.log("Projects API response:", JSON.stringify(data, null, 2))
-    console.log(`Fetched ${data.projects?.length || 0} projects from Vercel API`)
-
-    // Handle case where no projects exist
-    if (!data.projects || data.projects.length === 0) {
-      return Response.json({
-        success: true,
-        projects: []
-      })
-    }
-
-    // Format projects data
-    // biome-ignore lint/suspicious/noExplicitAny: Vercel API response shape is external
-    const projects = data.projects.map((project: any) => ({
-      id: project.id,
-      name: project.name,
-      framework: project.framework,
-      link: project.link,
-      latestDeployments:
-        // biome-ignore lint/suspicious/noExplicitAny: Vercel API response shape is external
-        project.latestDeployments?.map((deployment: any) => ({
-          id: deployment.id,
-          url: deployment.url,
-          state: deployment.state,
-          readyState: deployment.readyState,
-          createdAt: deployment.createdAt,
-          gitSource: deployment.gitSource
-            ? {
-                type: deployment.gitSource.type,
-                repoId: deployment.gitSource.repoId,
-                ref: deployment.gitSource.ref,
-                sha: deployment.gitSource.sha,
-                message: deployment.gitSource.message
-              }
-            : null
-        })) || []
-    }))
-
-    return Response.json({
-      success: true,
-      projects
-    })
-  } catch (error) {
-    console.error("Error fetching projects:", error)
-    return Response.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      },
-      { status: 500 }
-    )
-  }
-}

package/mcp-server/app/api/workflows/route.ts

@@ -1,105 +0,0 @@
-import { deleteWorkflowRuns, listWorkflowRuns } from "@/lib/workflow-storage"
-
-// CORS headers - allowing credentials from localhost
-const corsHeaders = {
-  "Access-Control-Allow-Origin": "http://localhost:3000",
-  "Access-Control-Allow-Methods": "GET, DELETE, OPTIONS",
-  "Access-Control-Allow-Headers": "Content-Type, Authorization",
-  "Access-Control-Allow-Credentials": "true"
-}
-
-// Handle OPTIONS preflight request
-export async function OPTIONS() {
-  return new Response(null, {
-    status: 204,
-    headers: corsHeaders
-  })
-}
-
-/**
- * GET /api/workflows
- * Fetches all workflow runs for a user
- *
- * Query params:
- * - userId: Required. The user ID to fetch runs for
- */
-export async function GET(request: Request) {
-  try {
-    const { searchParams } = new URL(request.url)
-    const userId = searchParams.get("userId")
-
-    if (!userId) {
-      return Response.json({ error: "userId is required" }, { status: 400, headers: corsHeaders })
-    }
-
-    console.log(`[Workflows API] Fetching runs for user: ${userId}`)
-
-    const runs = await listWorkflowRuns(userId)
-
-    console.log(`[Workflows API] Found ${runs.length} runs`)
-
-    return Response.json(
-      {
-        success: true,
-        runs
-      },
-      { headers: corsHeaders }
-    )
-  } catch (error) {
-    console.error("[Workflows API] Error fetching workflow runs:", error)
-    return Response.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      },
-      { status: 500, headers: corsHeaders }
-    )
-  }
-}
-
-/**
- * DELETE /api/workflows
- * Deletes workflow runs and their associated blobs
- *
- * Body:
- * - userId: Required. The user ID
- * - runIds: Required. Array of run IDs to delete
- */
-export async function DELETE(request: Request) {
-  try {
-    const body = await request.json()
-    const { userId, runIds } = body
-
-    if (!userId) {
-      return Response.json({ error: "userId is required" }, { status: 400, headers: corsHeaders })
-    }
-
-    if (!runIds || !Array.isArray(runIds) || runIds.length === 0) {
-      return Response.json({ error: "runIds array is required" }, { status: 400, headers: corsHeaders })
-    }
-
-    console.log(`[Workflows API] Deleting ${runIds.length} runs for user: ${userId}`)
-
-    const result = await deleteWorkflowRuns(userId, runIds)
-
-    console.log(`[Workflows API] Deleted ${result.deleted} runs, ${result.errors.length} errors`)
-
-    return Response.json(
-      {
-        success: true,
-        deleted: result.deleted,
-        errors: result.errors
-      },
-      { headers: corsHeaders }
-    )
-  } catch (error) {
-    console.error("[Workflows API] Error deleting workflow runs:", error)
-    return Response.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      },
-      { status: 500, headers: corsHeaders }
-    )
-  }
-}