How to Integrate Bolt.new with Basecamp

1// lib/basecamp/config.ts
2export const BASECAMP_AUTH_URL = 'https://launchpad.37signals.com/authorization/new';
3export const BASECAMP_TOKEN_URL = 'https://launchpad.37signals.com/authorization/token';
4export const BASECAMP_API_BASE = 'https://3.basecampapi.com';
5
6// CRITICAL: 37signals REQUIRES a descriptive User-Agent on every request
7// Format: 'App Name (contact@youremail.com)'
8// Without this header, requests return 403 Forbidden
9const USER_AGENT = process.env.BASECAMP_APP_USER_AGENT ?? 'MyApp (contact@example.com)';
10
11export interface BasecampTokenResponse {
12  access_token: string;
13  refresh_token?: string;
14  expires_in: number;
15  token_type: string;
16}
17
18export interface BasecampAccount {
19  id: number;
20  name: string;
21  product: string;
22  href: string;
23  app_href: string;
24}
25
26export interface BasecampAuthorizationResponse {
27  expires_at: string;
28  identity: {
29    id: number;
30    first_name: string;
31    last_name: string;
32    email_address: string;
33  };
34  accounts: BasecampAccount[];
35}
36
37export function buildAuthUrl(state: string): string {
38  const params = new URLSearchParams({
39    client_id: process.env.BASECAMP_CLIENT_ID ?? '',
40    redirect_uri: process.env.BASECAMP_REDIRECT_URI ?? '',
41    response_type: 'code',
42    type: 'web_server',
43    state,
44  });
45  return `${BASECAMP_AUTH_URL}?${params.toString()}`;
46}
47
48export function getBasecampHeaders(token: string): Record<string, string> {
49  return {
50    Authorization: `Bearer ${token}`,
51    'User-Agent': USER_AGENT,
52    'Content-Type': 'application/json',
53  };
54}

1// app/api/auth/basecamp/callback/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import {
4  BASECAMP_TOKEN_URL,
5  getBasecampHeaders,
6  type BasecampTokenResponse,
7  type BasecampAuthorizationResponse,
8} from '@/lib/basecamp/config';
9
10export async function GET(request: NextRequest) {
11  const { searchParams } = new URL(request.url);
12  const code = searchParams.get('code');
13  const state = searchParams.get('state');
14  const stateCookie = request.cookies.get('bc_state')?.value;
15
16  // CSRF validation
17  if (!state || state !== stateCookie) {
18    return NextResponse.redirect(new URL('/auth/error?reason=invalid_state', request.url));
19  }
20  if (!code) {
21    return NextResponse.redirect(new URL('/auth/error?reason=no_code', request.url));
22  }
23
24  try {
25    // Exchange authorization code for access token
26    const tokenResponse = await fetch(BASECAMP_TOKEN_URL, {
27      method: 'POST',
28      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
29      body: new URLSearchParams({
30        type: 'web_server',
31        client_id: process.env.BASECAMP_CLIENT_ID ?? '',
32        redirect_uri: process.env.BASECAMP_REDIRECT_URI ?? '',
33        client_secret: process.env.BASECAMP_CLIENT_SECRET ?? '',
34        code,
35      }),
36    });
37
38    if (!tokenResponse.ok) {
39      console.error('Token exchange failed:', await tokenResponse.text());
40      return NextResponse.redirect(new URL('/auth/error?reason=token_exchange', request.url));
41    }
42
43    const tokens: BasecampTokenResponse = await tokenResponse.json();
44
45    // Get user's Basecamp accounts
46    const authResponse = await fetch('https://launchpad.37signals.com/authorization.json', {
47      headers: getBasecampHeaders(tokens.access_token),
48    });
49    const authData: BasecampAuthorizationResponse = await authResponse.json();
50
51    // Find the first Basecamp 4 account
52    const basecampAccount = authData.accounts.find((a) => a.product === 'bc4');
53    if (!basecampAccount) {
54      return NextResponse.redirect(new URL('/auth/error?reason=no_basecamp_account', request.url));
55    }
56
57    const response = NextResponse.redirect(new URL('/dashboard', request.url));
58
59    response.cookies.set('bc_token', tokens.access_token, {
60      httpOnly: true,
61      secure: process.env.NODE_ENV === 'production',
62      maxAge: 60 * 60 * 24 * 365, // Basecamp tokens do not expire — 1 year expiry for cookie
63      sameSite: 'lax',
64    });
65    response.cookies.set('bc_account_id', String(basecampAccount.id), {
66      httpOnly: true,
67      secure: process.env.NODE_ENV === 'production',
68      maxAge: 60 * 60 * 24 * 365,
69      sameSite: 'lax',
70    });
71    response.cookies.delete('bc_state');
72
73    return response;
74  } catch (error) {
75    console.error('Basecamp OAuth error:', error);
76    return NextResponse.redirect(new URL('/auth/error?reason=server_error', request.url));
77  }
78}

1// app/api/basecamp/projects/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { BASECAMP_API_BASE, getBasecampHeaders } from '@/lib/basecamp/config';
4
5interface BasecampDockItem {
6  id: number;
7  title: string;
8  name: string;
9  enabled: boolean;
10  url: string;
11  app_url: string;
12}
13
14interface BasecampProject {
15  id: number;
16  name: string;
17  description: string;
18  status: 'active' | 'archived' | 'trashed';
19  created_at: string;
20  updated_at: string;
21  dock: BasecampDockItem[];
22  bookmark_url: string;
23  url: string;
24  app_url: string;
25}
26
27export async function GET(request: NextRequest) {
28  const token = request.cookies.get('bc_token')?.value;
29  const accountId = request.cookies.get('bc_account_id')?.value;
30
31  if (!token || !accountId) {
32    return NextResponse.json({ error: 'Not authenticated with Basecamp' }, { status: 401 });
33  }
34
35  try {
36    const response = await fetch(
37      `${BASECAMP_API_BASE}/${accountId}/projects.json`,
38      { headers: getBasecampHeaders(token) }
39    );
40
41    if (response.status === 401) {
42      return NextResponse.json({ error: 'Basecamp token invalid — re-authorize' }, { status: 401 });
43    }
44    if (!response.ok) {
45      return NextResponse.json(
46        { error: `Basecamp API error: ${response.status}` },
47        { status: response.status }
48      );
49    }
50
51    const projects: BasecampProject[] = await response.json();
52
53    const active = projects
54      .filter((p) => p.status === 'active')
55      .sort(
56        (a, b) => new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime()
57      )
58      .map((p) => ({
59        id: p.id,
60        name: p.name,
61        description: p.description,
62        updatedAt: p.updated_at,
63        toolCount: p.dock.filter((d) => d.enabled).length,
64        tools: p.dock.filter((d) => d.enabled).map((d) => d.name),
65        appUrl: p.app_url,
66      }));
67
68    return NextResponse.json({ projects: active, total: active.length });
69  } catch (error) {
70    const message = error instanceof Error ? error.message : 'Request failed';
71    return NextResponse.json({ error: message }, { status: 500 });
72  }
73}

1// app/api/basecamp/todos/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { BASECAMP_API_BASE, getBasecampHeaders } from '@/lib/basecamp/config';
4
5interface CreateTodoBody {
6  projectId: number;
7  listId: number;
8  title: string;
9  description?: string;
10  dueOn?: string;
11  assigneeIds?: number[];
12}
13
14export async function GET(request: NextRequest) {
15  const token = request.cookies.get('bc_token')?.value;
16  const accountId = request.cookies.get('bc_account_id')?.value;
17  const projectId = request.nextUrl.searchParams.get('projectId');
18
19  if (!token || !accountId || !projectId) {
20    return NextResponse.json({ error: 'Missing required params or auth' }, { status: 400 });
21  }
22
23  const response = await fetch(
24    `${BASECAMP_API_BASE}/${accountId}/buckets/${projectId}/todolists.json`,
25    { headers: getBasecampHeaders(token) }
26  );
27  const lists = await response.json();
28  return NextResponse.json({ lists });
29}
30
31export async function POST(request: NextRequest) {
32  const token = request.cookies.get('bc_token')?.value;
33  const accountId = request.cookies.get('bc_account_id')?.value;
34
35  if (!token || !accountId) {
36    return NextResponse.json({ error: 'Not authenticated' }, { status: 401 });
37  }
38
39  const body: CreateTodoBody = await request.json();
40
41  if (!body.title?.trim()) {
42    return NextResponse.json({ error: 'To-do title is required' }, { status: 400 });
43  }
44
45  const todoBody: Record<string, unknown> = { title: body.title };
46  if (body.description) todoBody.description = `<div>${body.description}</div>`;
47  if (body.dueOn) todoBody.due_on = body.dueOn;
48  if (body.assigneeIds?.length) todoBody.assignee_ids = body.assigneeIds;
49
50  const response = await fetch(
51    `${BASECAMP_API_BASE}/${accountId}/buckets/${body.projectId}/todolists/${body.listId}/todos.json`,
52    {
53      method: 'POST',
54      headers: getBasecampHeaders(token),
55      body: JSON.stringify(todoBody),
56    }
57  );
58
59  if (!response.ok) {
60    const error = await response.text();
61    return NextResponse.json({ error: `Failed to create to-do: ${error}` }, { status: response.status });
62  }
63
64  const newTodo = await response.json();
65  return NextResponse.json({ todo: newTodo }, { status: 201 });
66}