How to Integrate Bolt.new with Time Doctor

1// lib/time-doctor.ts
2// Time Doctor API v2 authentication
3// For OAuth 2.0 multi-user flow, tokens come from cookies set in /api/time-doctor/auth/callback
4// For single-account use, set TIMEDOCTOR_ACCESS_TOKEN in .env
5const TIMEDOCTOR_BASE_URL = 'https://api2.timedoctor.com/api/1.0';
6
7function getToken(cookieToken?: string): string {
8  const token = cookieToken || process.env.TIMEDOCTOR_ACCESS_TOKEN;
9  if (!token) {
10    throw new Error(
11      'Time Doctor access token not found. ' +
12      'Set TIMEDOCTOR_ACCESS_TOKEN in .env for single-account use, ' +
13      'or complete the OAuth 2.0 flow at /api/time-doctor/auth/start.'
14    );
15  }
16  return token;
17}
18
19export async function timeDoctorFetch<T = unknown>(
20  path: string,
21  params?: Record<string, string | number>,
22  token?: string
23): Promise<T> {
24  const accessToken = getToken(token);
25  const url = new URL(`${TIMEDOCTOR_BASE_URL}${path}`);
26  if (params) {
27    Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, String(v)));
28  }
29
30  const response = await fetch(url.toString(), {
31    headers: {
32      Authorization: `Bearer ${accessToken}`,
33      'Content-Type': 'application/json',
34    },
35  });
36
37  if (response.status === 401) {
38    throw new Error('Time Doctor token expired or invalid. Re-authorize via /api/time-doctor/auth/start.');
39  }
40
41  if (!response.ok) {
42    const err = await response.json().catch(() => ({ message: response.statusText })) as { message?: string; error?: string };
43    throw new Error(err.message || err.error || `Time Doctor API error: ${response.status}`);
44  }
45
46  return response.json() as Promise<T>;
47}

1// app/api/time-doctor/worklogs/route.ts
2import { NextResponse } from 'next/server';
3import { timeDoctorFetch } from '@/lib/time-doctor';
4
5interface WorklogEntry {
6  userId: string;
7  userName?: string;
8  taskId?: string;
9  projectId?: string;
10  projectName?: string;
11  startTime: string;
12  endTime: string;
13  length: number; // seconds
14  keyboard: number; // 0-100 activity %
15  mouse: number;
16  mobile: boolean;
17}
18
19interface WorklogsResponse {
20  data?: { worklogs?: { items?: WorklogEntry[] } };
21}
22
23const cache = new Map<string, { data: unknown; expiresAt: number }>();
24
25export async function GET(request: Request) {
26  const { searchParams } = new URL(request.url);
27  const from = searchParams.get('from');
28  const to = searchParams.get('to');
29  const userId = searchParams.get('userId');
30  const companyId = process.env.TIMEDOCTOR_COMPANY_ID;
31
32  if (!from || !to) {
33    return NextResponse.json({ error: 'from and to are required' }, { status: 400 });
34  }
35  if (!companyId) {
36    return NextResponse.json({ error: 'TIMEDOCTOR_COMPANY_ID is not configured' }, { status: 500 });
37  }
38
39  const cacheKey = `${from}-${to}-${userId}`;
40  const cached = cache.get(cacheKey);
41  if (cached && Date.now() < cached.expiresAt) {
42    return NextResponse.json(cached.data);
43  }
44
45  try {
46    const params: Record<string, string | number> = {
47      company_id: companyId,
48      start_date: from,
49      end_date: to,
50      'show-tasks': 1,
51      'show-project-ids': 1,
52    };
53    if (userId) params.user_ids = userId;
54
55    const data = await timeDoctorFetch<WorklogsResponse>('/activity/worklog', params);
56    const worklogs = data?.data?.worklogs?.items || [];
57
58    // Aggregate by user with weighted activity average
59    const byUser: Record<string, { name: string; totalSeconds: number; weightedKeyboard: number; totalIntervals: number }> = {};
60    const byProject: Record<string, { name: string; totalSeconds: number }> = {};
61    let totalCompanySeconds = 0;
62
63    for (const log of worklogs) {
64      // By user
65      if (!byUser[log.userId]) {
66        byUser[log.userId] = { name: log.userName || log.userId, totalSeconds: 0, weightedKeyboard: 0, totalIntervals: 0 };
67      }
68      byUser[log.userId].totalSeconds += log.length;
69      byUser[log.userId].weightedKeyboard += log.keyboard * log.length;
70      byUser[log.userId].totalIntervals += 1;
71
72      // By project
73      if (log.projectId) {
74        if (!byProject[log.projectId]) byProject[log.projectId] = { name: log.projectName || log.projectId, totalSeconds: 0 };
75        byProject[log.projectId].totalSeconds += log.length;
76      }
77
78      totalCompanySeconds += log.length;
79    }
80
81    const result = {
82      byUser: Object.entries(byUser).map(([id, v]) => ({
83        id,
84        name: v.name,
85        totalHours: Math.round((v.totalSeconds / 3600) * 100) / 100,
86        avgActivityPercent: v.totalSeconds > 0 ? Math.round(v.weightedKeyboard / v.totalSeconds) : 0,
87        totalIntervals: v.totalIntervals,
88      })).sort((a, b) => b.totalHours - a.totalHours),
89      byProject: Object.entries(byProject).map(([id, v]) => ({
90        id,
91        name: v.name,
92        totalHours: Math.round((v.totalSeconds / 3600) * 100) / 100,
93      })).sort((a, b) => b.totalHours - a.totalHours),
94      totalCompanyHours: Math.round((totalCompanySeconds / 3600) * 100) / 100,
95    };
96
97    cache.set(cacheKey, { data: result, expiresAt: Date.now() + 60_000 });
98    return NextResponse.json(result);
99  } catch (err) {
100    const message = err instanceof Error ? err.message : 'Failed to fetch worklogs';
101    return NextResponse.json({ error: message }, { status: 500 });
102  }
103}

1// app/api/time-doctor/auth/callback/route.ts
2// IMPORTANT: This OAuth callback requires deployment to Netlify or Bolt Cloud.
3// Time Doctor cannot redirect to the Bolt WebContainer preview URL.
4// Set TIMEDOCTOR_CLIENT_ID, TIMEDOCTOR_CLIENT_SECRET, and TIMEDOCTOR_REDIRECT_URI in
5// your hosting platform's environment variables after deploying.
6import { NextResponse } from 'next/server';
7import { cookies } from 'next/headers';
8
9interface TokenResponse {
10  access_token: string;
11  refresh_token: string;
12  expires_in: number;
13  token_type: string;
14}
15
16export async function GET(request: Request) {
17  const { searchParams } = new URL(request.url);
18  const code = searchParams.get('code');
19  const state = searchParams.get('state');
20
21  const cookieStore = cookies();
22  const storedState = cookieStore.get('timedoctor_oauth_state')?.value;
23
24  // CSRF protection: verify state matches
25  if (!state || state !== storedState) {
26    return NextResponse.redirect(new URL('/auth-error?reason=state_mismatch', request.url));
27  }
28
29  if (!code) {
30    return NextResponse.redirect(new URL('/auth-error?reason=no_code', request.url));
31  }
32
33  try {
34    const tokenResponse = await fetch('https://accounts.timedoctor.com/oauth2/token', {
35      method: 'POST',
36      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
37      body: new URLSearchParams({
38        grant_type: 'authorization_code',
39        code,
40        client_id: process.env.TIMEDOCTOR_CLIENT_ID || '',
41        client_secret: process.env.TIMEDOCTOR_CLIENT_SECRET || '',
42        redirect_uri: process.env.TIMEDOCTOR_REDIRECT_URI || '',
43      }).toString(),
44    });
45
46    if (!tokenResponse.ok) {
47      throw new Error(`Token exchange failed: ${tokenResponse.status}`);
48    }
49
50    const tokens = await tokenResponse.json() as TokenResponse;
51
52    const response = NextResponse.redirect(new URL('/dashboard', request.url));
53
54    response.cookies.set('td_access_token', tokens.access_token, {
55      httpOnly: true,
56      secure: true,
57      sameSite: 'lax',
58      maxAge: tokens.expires_in,
59    });
60    response.cookies.set('td_refresh_token', tokens.refresh_token, {
61      httpOnly: true,
62      secure: true,
63      sameSite: 'lax',
64      maxAge: 30 * 24 * 60 * 60, // 30 days
65    });
66
67    return response;
68  } catch (err) {
69    console.error('[Time Doctor OAuth] Token exchange error:', err);
70    return NextResponse.redirect(new URL('/auth-error?reason=token_exchange_failed', request.url));
71  }
72}