giving up on botid

app/api/categories/[categoryId]/route.ts

···
 import { getOrganizationRole } from '@/lib/repositories/user-repository';
 import { Category } from '@/lib/types';
 import { z } from 'zod';
-import { verifyBotId } from '@/lib/botid-verification';
+
 
 export const runtime = 'nodejs';
 
···
   { params }: { params: Promise<{ categoryId: string }> }
 ) {
   try {
-    // Check for bot before proceeding
-    const botVerification = await verifyBotId();
-    if (botVerification) {
-      return botVerification;
-    }
-
+    
     const { categoryId } = await params;
     const session = await auth();
     if (!session?.user?.id) {
···
   { params }: { params: Promise<{ categoryId: string }> }
 ) {
   try {
-    // Check for bot before proceeding
-    const botVerification = await verifyBotId();
-    if (botVerification) {
-      return botVerification;
-    }
-
+    
     const { categoryId } = await params;
     const session = await auth();
     if (!session?.user?.id) {

app/api/dashboard/data/route.ts

···
 import { NextRequest, NextResponse } from 'next/server';
 import { getUserWithOrganizations } from '@/lib/auth-context';
-import { verifyBotId } from '@/lib/botid-verification';
+
 
 export const runtime = 'nodejs';
 
 export async function GET(request: NextRequest) {
   try {
-    // Check for bot before proceeding
-    const botVerification = await verifyBotId();
-    if (botVerification) {
-      return botVerification;
-    }
-
+    
     const { searchParams } = new URL(request.url);
     const include = searchParams.get('include')?.split(',') || [];
     

app/api/github-app/installations/[installationId]/route.ts

···
 import { auth } from '@/auth'
 import { getService } from '@/lib/core/container/di-container'
 import { IGitHubAppService } from '@/lib/core/ports'
-import { verifyBotId } from '@/lib/botid-verification'
+
 
 export const runtime = 'nodejs'
 
···
   { params }: { params: Promise<{ installationId: string }> }
 ) {
   try {
-    // Check for bot before proceeding
-    const botVerification = await verifyBotId();
-    if (botVerification) {
-      return botVerification;
-    }
+
 
     const { installationId } = await params
     const session = await auth()
···
   { params }: { params: Promise<{ installationId: string }> }
 ) {
   try {
-    // Check for bot before proceeding
-    const botVerification = await verifyBotId();
-    if (botVerification) {
-      return botVerification;
-    }
+
 
     const { installationId } = await params
     const session = await auth()
···
   { params }: { params: Promise<{ installationId: string }> }
 ) {
   try {
-    // Check for bot before proceeding
-    const botVerification = await verifyBotId();
-    if (botVerification) {
-      return botVerification;
-    }
+
 
     const { installationId } = await params
     const session = await auth()

app/api/github-app/installations/route.ts

···
 import { auth } from '@/auth'
 import { getService } from '@/lib/core/container/di-container'
 import { IGitHubAppService } from '@/lib/core/ports'
-import { verifyBotId } from '@/lib/botid-verification'
+
 
 export const runtime = 'nodejs'
 
···
  */
 export async function GET() {
   try {
-    // Check for bot before proceeding
-    const botVerification = await verifyBotId();
-    if (botVerification) {
-      return botVerification;
-    }
+
 
     const session = await auth()
     
···
  */
 export async function POST() {
   try {
-    // Check for bot before proceeding
-    const botVerification = await verifyBotId();
-    if (botVerification) {
-      return botVerification;
-    }
+
 
     const session = await auth()
     

app/api/github/organizations/[orgName]/repositories/route.ts

···
 import { auth } from '@/auth';
 import { getService } from '@/lib/core/container/di-container';
 import { IGitHubService } from '@/lib/core/ports';
-import { verifyBotId } from '@/lib/botid-verification';
+
 
 // Use the context object directly with proper typing for Next.js route handler
 export async function GET(
   request: NextRequest,
   { params }: { params: Promise<{ orgName: string }> }
 ) {
-  // Check for bot before proceeding
-  const botVerification = await verifyBotId();
-  if (botVerification) {
-    return botVerification;
-  }
-
   const { orgName } = await params;
   
   const session = await auth();

app/api/github/organizations/route.ts

···
 import { auth } from '@/auth';
 import { getService } from '@/lib/core/container/di-container';
 import { IGitHubService } from '@/lib/core/ports';
-import { verifyBotId } from '@/lib/botid-verification';
 
-export async function GET() {
-  // Check for bot before proceeding
-  const botVerification = await verifyBotId();
-  if (botVerification) {
-    return botVerification;
-  }
 
+export async function GET() {
   const session = await auth();
   
   if (!session || !session.user) {

app/api/github/repositories/sync/route.ts

···
 import { auth } from '@/auth';
 import { GitHubService } from '@/lib/services';
 import { findUserById, findUserByEmail } from '@/lib/repositories';
-import { verifyBotId } from '@/lib/botid-verification';
+
 
 export const runtime = 'nodejs';
 
 export async function POST() {
-  // Check for bot before proceeding
-  const botVerification = await verifyBotId();
-  if (botVerification) {
-    return botVerification;
-  }
-
   const session = await auth();
   
   if (!session || !session.user) {

app/api/github/user/route.ts

···
 import { auth } from '@/auth';
 import { getService } from '@/lib/core/container/di-container';
 import { IGitHubService } from '@/lib/core/ports';
-import { verifyBotId } from '@/lib/botid-verification';
-
 export async function GET() {
-  // Check for bot before proceeding
-  const botVerification = await verifyBotId();
-  if (botVerification) {
-    return botVerification;
-  }
-
   const session = await auth();
   
   if (!session || !session.user) {

app/api/organizations/[orgId]/ai-settings/route.ts

···
 import { AiSettingsService } from '@/lib/services/ai-settings-service';
 import { z } from 'zod';
 import { unauthorized, badRequest, errorResponse } from '@/lib/api-errors';
-import { verifyBotId } from '@/lib/botid-verification';
+
 
 const updateAiSettingsSchema = z.object({
   provider: z.enum(['openai', 'google', 'anthropic']).nullable().optional(),
···
   { params }: { params: Promise<{ orgId: string }> }
 ) {
   try {
-    // Check for bot before proceeding
-    const botVerification = await verifyBotId();
-    if (botVerification) {
-      return botVerification;
-    }
 
     const { orgId } = await params;
     const session = await auth();
···
   { params }: { params: Promise<{ orgId: string }> }
 ) {
   try {
-    // Check for bot before proceeding
-    const botVerification = await verifyBotId();
-    if (botVerification) {
-      return botVerification;
-    }
 
     const { orgId } = await params;
     const session = await auth();

app/api/organizations/[orgId]/members/route.ts

···
 import { auth } from '@/auth';
 import { getOrganizationMembers, searchUsers } from '@/lib/repositories/team-repository';
 import { getOrganizationRole } from '@/lib/repositories/user-repository';
-import { verifyBotId } from '@/lib/botid-verification';
+
 
 export const runtime = 'nodejs';
 
···
   { params }: { params: Promise<{ orgId: string }> }
 ) {
   try {
-    // Check for bot before proceeding
-    const botVerification = await verifyBotId();
-    if (botVerification) {
-      return botVerification;
-    }
-
-    const { orgId } = await params;
+      const { orgId } = await params;
     const session = await auth();
     if (!session?.user?.id) {
       return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });

instrumentation-client.ts

···
-import { initBotId } from 'botid/client/core';
- 
-initBotId({
-  protect: [
-    // Only protect actual mutations (POST, PUT, DELETE) - not GET requests
-    // Team management mutations
-    {
-      path: '/api/organizations/*/teams',
-      method: 'POST',
-    },
-    {
-      path: '/api/organizations/*/teams/*',
-      method: 'PUT',
-    },
-    {
-      path: '/api/organizations/*/teams/*',
-      method: 'DELETE',
-    },
-    {
-      path: '/api/organizations/*/teams/*/members',
-      method: 'POST',
-    },
-    {
-      path: '/api/organizations/*/teams/*/members',
-      method: 'PUT',
-    },
-    {
-      path: '/api/organizations/*/teams/*/members',
-      method: 'DELETE',
-    },
-    // Settings mutations
-    {
-      path: '/api/organizations/*/ai-settings',
-      method: 'PUT',
-    },
-    {
-      path: '/api/organizations/*/categories',
-      method: 'POST',
-    },
-    {
-      path: '/api/categories/*',
-      method: 'PUT',
-    },
-    {
-      path: '/api/categories/*',
-      method: 'DELETE',
-    },
-    // GitHub sync mutations
-    {
-      path: '/api/github/repositories/sync',
-      method: 'POST',
-    },
-    {
-      path: '/api/github-app/installations',
-      method: 'POST',
-    },
-    {
-      path: '/api/github-app/installations/*',
-      method: 'POST',
-    },
-    // Webhook management
-    {
-      path: '/api/github/repositories/*/webhook',
-      method: 'POST',
-    },
-    {
-      path: '/api/github/repositories/*/webhook',
-      method: 'DELETE',
-    },
-  ],
-});

lib/botid-verification.ts

···
-import { checkBotId } from 'botid/server';
-import { NextRequest, NextResponse } from 'next/server';
-
-/**
- * Utility function to verify botid and return 403 if request is from a bot
- * @returns Promise<NextResponse | null> - Returns 403 response if bot detected, null if verification passes
- */
-export async function verifyBotId(): Promise<NextResponse | null> {
-  try {
-    // Check if the request is from a bot
-    const verification = await checkBotId();
-    
-    if (verification.isBot) {
-      return NextResponse.json({ error: 'Access denied' }, { status: 403 });
-    }
-    
-    return null; // Verification passed
-  } catch (error) {
-    console.error('BotId verification error:', error);
-    // In case of verification error, allow request to proceed to avoid blocking legitimate users
-    return null;
-  }
-}
-
-/**
- * Higher-order function to wrap API route handlers with botid verification
- */
-export function withBotIdVerification<T extends (...args: any[]) => Promise<NextResponse>>(
-  handler: T
-): T {
-  return (async (...args: any[]) => {
-    // Check for bot before executing the handler
-    const botVerification = await verifyBotId();
-    if (botVerification) {
-      return botVerification;
-    }
-    
-    // If verification passes, execute the original handler
-    return await handler(...args);
-  }) as T;
-}

lib/core/application/auth-middleware.ts

···
   createAnonymousContext,
   UserPermissions
 } from './context'
-import { verifyBotId } from '../../botid-verification'
+
 
 export type AuthenticatedHandler<TRequest = NextRequest, TResponse = NextResponse> = 
   (context: ApplicationContext, request: TRequest) => Promise<TResponse>
···
 ): (request: TRequest) => Promise<TResponse | NextResponse> {
   return async (request: TRequest) => {
     try {
-      // Check for bot before proceeding
-      const botVerification = await verifyBotId();
-      if (botVerification) {
-        return botVerification;
-      }
-
       const context = await createAuthenticatedContext(request)
       
       if (!context) {
···
 ): (request: TRequest) => Promise<TResponse> {
   return async (request: TRequest) => {
     try {
-      // Check for bot before proceeding
-      const botVerification = await verifyBotId();
-      if (botVerification) {
-        return botVerification as TResponse;
-      }
-
       const context = await createRequestContext(request)
       return await handler(context, request)
     } catch (error) {

next.config.ts

···
 import type { NextConfig } from "next";
-import { withBotId } from 'botid/next/config';
+
 
 const nextConfig: NextConfig = {
   /* config options here */
···
   },
 };
 
-export default withBotId(nextConfig);
+export default nextConfig;