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()
     
     if (!session || !session.user) {
···
  */
 export async function POST() {
   try {
+    // Check for bot before proceeding
+    const botVerification = await verifyBotId();
+    if (botVerification) {
+      return botVerification;
+    }
+
     const session = await auth()
     
     if (!session || !session.user) {

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;
+  }
+
   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();
     if (!session?.user?.id) throw unauthorized();
···
   { 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();
     if (!session?.user?.id) throw unauthorized();

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 session = await auth();
     if (!session?.user?.id) {

app/dashboard/lifecycle/page.tsx

···
 "use client";
 
 import { useState, useEffect } from "react";
-import { DateRange } from "react-day-picker";
 import { AppSidebar } from "@/components/app-sidebar"
 import { ChartAreaEngineering } from "@/components/chart-area-engineering"
-import { DateRangePickerWithPresets } from "@/components/date-range-picker"
+import { SimpleTimeRangePicker, type TimeRangeValue } from "@/components/simple-time-range-picker"
 import { PRQualityDetails } from "@/components/pr-quality-details"
 import { RepositoryFilter } from "@/components/repository-filter"
 import { SiteHeader } from "@/components/site-header"
···
 
 export default function LifecyclePage() {
   const [selectedRepository, setSelectedRepository] = useState<string>("all");
-  const [dateRange, setDateRange] = useState<DateRange | undefined>();
+  const [timeRange, setTimeRange] = useState<TimeRangeValue>("30d");
   const [chartData, setChartData] = useState<TimeSeriesDataPoint[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
···
           params.append("repositoryId", selectedRepository);
         }
         
-        if (dateRange?.from) {
-          params.append("startDate", dateRange.from.toISOString());
-        }
-        
-        if (dateRange?.to) {
-          params.append("endDate", dateRange.to.toISOString());
-        }
+        // Use timeRange instead of specific dates
+        params.append("timeRange", timeRange);
         
         const url = `/api/metrics/time-series${params.toString() ? `?${params.toString()}` : ''}`;
         const response = await fetch(url);
···
     };
 
     fetchChartData();
-  }, [selectedRepository, dateRange]);
+  }, [selectedRepository, timeRange]);
 
   const handleRepositoryChange = (repositoryId: string) => {
     setSelectedRepository(repositoryId);
   };
 
-  const handleDateRangeChange = (range: DateRange | undefined) => {
-    setDateRange(range);
+  const handleTimeRangeChange = (range: TimeRangeValue) => {
+    setTimeRange(range);
   };
 
   return (
···
                     onRepositoryChange={handleRepositoryChange}
                     selectedRepository={selectedRepository}
                   />
-                  <DateRangePickerWithPresets 
-                    onDateRangeChange={handleDateRangeChange}
-                    selectedRange={dateRange}
+                  <SimpleTimeRangePicker 
+                    value={timeRange}
+                    onValueChange={handleTimeRangeChange}
                   />
                 </div>
               </div>

components/simple-time-range-picker.tsx

···
+"use client"
+
+import { CalendarIcon } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select"
+
+export type TimeRangeValue = "7d" | "14d" | "30d" | "90d"
+
+interface TimeRangeOption {
+  value: TimeRangeValue;
+  label: string;
+  description: string;
+}
+
+interface SimpleTimeRangePickerProps {
+  value?: TimeRangeValue;
+  onValueChange: (value: TimeRangeValue) => void;
+  className?: string;
+}
+
+const timeRangeOptions: TimeRangeOption[] = [
+  { value: "7d", label: "Last 7 days", description: "Past week" },
+  { value: "14d", label: "Last 14 days", description: "Past 2 weeks" },
+  { value: "30d", label: "Last 30 days", description: "Past month" },
+  { value: "90d", label: "Last 90 days", description: "Past quarter" },
+];
+
+export function SimpleTimeRangePicker({
+  value = "30d",
+  onValueChange,
+  className = ""
+}: SimpleTimeRangePickerProps) {
+  const selectedOption = timeRangeOptions.find(option => option.value === value);
+
+  return (
+    <Select value={value} onValueChange={onValueChange}>
+      <SelectTrigger className={`w-[200px] ${className}`}>
+        <CalendarIcon className="mr-2 h-4 w-4" />
+        <SelectValue>
+          {selectedOption?.label || "Select time range"}
+        </SelectValue>
+      </SelectTrigger>
+      <SelectContent>
+        {timeRangeOptions.map((option) => (
+          <SelectItem key={option.value} value={option.value}>
+            <div className="flex flex-col">
+              <span className="font-medium">{option.label}</span>
+              <span className="text-xs text-muted-foreground">{option.description}</span>
+            </div>
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  )
+}

components/ui/calendar.tsx

···
         ...classNames,
       }}
       components={{
-        IconLeft: ({ className, ...props }) => (
-          <ChevronLeft className={cn("size-4", className)} {...props} />
-        ),
-        IconRight: ({ className, ...props }) => (
-          <ChevronRight className={cn("size-4", className)} {...props} />
-        ),
+        Chevron: ({ orientation, className, ...props }: { orientation?: 'up' | 'right' | 'left' | 'down'; className?: string; size?: number; disabled?: boolean }) => {
+          const Icon = orientation === 'left' ? ChevronLeft : ChevronRight
+          return <Icon className={cn("size-4", className)} {...props} />
+        },
       }}
       {...props}
     />

instrumentation-client.ts

···
+import { initBotId } from 'botid/client/core';
+ 
+initBotId({
+  protect: [
+    {
+      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',
+    },
+    {
+      path: '/api/organizations/*/ai-settings',
+      method: 'PUT',
+    },
+    {
+      path: '/api/organizations/*/categories',
+      method: 'POST',
+    },
+    {
+      path: '/api/categories/*',
+      method: 'PUT',
+    },
+    {
+      path: '/api/categories/*',
+      method: 'DELETE',
+    },
+    {
+      path: '/api/github/organizations/sync',
+      method: 'POST',
+    },
+    {
+      path: '/api/github/organizations/*/sync',
+      method: 'POST',
+    },
+    {
+      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 nextConfig;
+export default withBotId(nextConfig);

package.json

···
     "@tanstack/react-table": "^8.21.3",
     "@types/jsonwebtoken": "^9.0.9",
     "ai": "^4.3.15",
+    "botid": "^1.5.3",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
···
     "next-auth": "5.0.0-beta.29",
     "next-themes": "^0.4.6",
     "react": "19.1.1",
-    "react-day-picker": "8.10.1",
+    "react-day-picker": "9.9.0",
     "react-dom": "19.1.1",
     "recharts": "^2.15.3",
     "sonner": "^2.0.3",

pnpm-lock.yaml

···
       ai:
         specifier: ^4.3.15
         version: 4.3.15(react@19.1.1)(zod@3.24.3)
+      botid:
+        specifier: ^1.5.3
+        version: 1.5.3(next@15.4.6(@babel/core@7.28.0)(@opentelemetry/api@1.9.0)(react-dom@19.1.1(react@19.1.1))(react@19.1.1))(react@19.1.1)
       class-variance-authority:
         specifier: ^0.7.1
         version: 0.7.1
···
         specifier: 19.1.1
         version: 19.1.1
       react-day-picker:
-        specifier: 8.10.1
-        version: 8.10.1(date-fns@4.1.0)(react@19.1.1)
+        specifier: 9.9.0
+        version: 9.9.0(react@19.1.1)
       react-dom:
         specifier: 19.1.1
         version: 19.1.1(react@19.1.1)
···
   '@csstools/css-tokenizer@3.0.4':
     resolution: {integrity: sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==}
     engines: {node: '>=18'}
+
+  '@date-fns/tz@1.4.1':
+    resolution: {integrity: sha512-P5LUNhtbj6YfI3iJjw5EL9eUAG6OitD0W3fWQcpQjDRc/QIsL0tRNuO1PcDvPccWL1fSTXXdE1ds+l95DV/OFA==}
 
   '@dnd-kit/accessibility@3.1.1':
     resolution: {integrity: sha512-2P+YgaXF+gRsIihwwY1gCsQSYnu9Zyj2py8kY5fFvUM1qm2WA2u639R6YNVfU4GWr+ZM5mqEsfHZZLoRONbemw==}
···
   before-after-hook@3.0.2:
     resolution: {integrity: sha512-Nik3Sc0ncrMK4UUdXQmAnRtzmNQTAAXmXIopizwZ1W1t8QmfJj+zL4OA2I7XPTPW5z5TDqv4hRo/JzouDJnX3A==}
 
+  botid@1.5.3:
+    resolution: {integrity: sha512-QMU3icRKLEjJIUxtCuMkzAzVc32lg97qTNN66VJnjPMBUB79YT0N7bA5RFdvxsw+iUMAh+uNnB/2KBneVwkxEA==}
+    peerDependencies:
+      next: '*'
+      react: ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      next:
+        optional: true
+      react:
+        optional: true
+
   brace-expansion@1.1.11:
     resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
 
···
     resolution: {integrity: sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==}
     engines: {node: '>= 0.4'}
 
+  date-fns-jalali@4.1.0-0:
+    resolution: {integrity: sha512-hTIP/z+t+qKwBDcmmsnmjWTduxCg+5KfdqWQvb2X/8C9+knYY6epN/pfxdDuyVlSVeFz0sM5eEfwIUQ70U4ckg==}
+
   date-fns@4.1.0:
     resolution: {integrity: sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg==}
 
···
   queue-microtask@1.2.3:
     resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
 
-  react-day-picker@8.10.1:
-    resolution: {integrity: sha512-TMx7fNbhLk15eqcMt+7Z7S2KF7mfTId/XJDjKE8f+IUcFn0l08/kI4FiYTL/0yuOLmEcbR4Fwe3GJf/NiiMnPA==}
+  react-day-picker@9.9.0:
+    resolution: {integrity: sha512-NtkJbuX6cl/VaGNb3sVVhmMA6LSMnL5G3xNL+61IyoZj0mUZFWTg4hmj7PHjIQ8MXN9dHWhUHFoJWG6y60DKSg==}
+    engines: {node: '>=18'}
     peerDependencies:
-      date-fns: ^2.28.0 || ^3.0.0
-      react: ^16.8.0 || ^17.0.0 || ^18.0.0
+      react: '>=16.8.0'
 
   react-dom@19.1.1:
     resolution: {integrity: sha512-Dlq/5LAZgF0Gaz6yiqZCf6VCcZs1ghAJyrsu84Q/GT0gV+mCxbfmKNoGRKBYMJ8IEdGPqu49YWXD02GCknEDkw==}
···
       '@csstools/css-tokenizer': 3.0.4
 
   '@csstools/css-tokenizer@3.0.4': {}
+
+  '@date-fns/tz@1.4.1': {}
 
   '@dnd-kit/accessibility@3.1.1(react@19.1.1)':
     dependencies:
···
 
   before-after-hook@3.0.2: {}
 
+  botid@1.5.3(next@15.4.6(@babel/core@7.28.0)(@opentelemetry/api@1.9.0)(react-dom@19.1.1(react@19.1.1))(react@19.1.1))(react@19.1.1):
+    optionalDependencies:
+      next: 15.4.6(@babel/core@7.28.0)(@opentelemetry/api@1.9.0)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)
+      react: 19.1.1
+
   brace-expansion@1.1.11:
     dependencies:
       balanced-match: 1.0.2
···
       call-bound: 1.0.4
       es-errors: 1.3.0
       is-data-view: 1.0.2
+
+  date-fns-jalali@4.1.0-0: {}
 
   date-fns@4.1.0: {}
 
···
 
   queue-microtask@1.2.3: {}
 
-  react-day-picker@8.10.1(date-fns@4.1.0)(react@19.1.1):
+  react-day-picker@9.9.0(react@19.1.1):
     dependencies:
+      '@date-fns/tz': 1.4.1
       date-fns: 4.1.0
+      date-fns-jalali: 4.1.0-0
       react: 19.1.1
 
   react-dom@19.1.1(react@19.1.1):