How to Integrate Bolt.new with Keap

1// lib/keap/config.ts
2export const KEAP_OAUTH_BASE = 'https://accounts.infusionsoft.com/app/oauth/authorize';
3export const KEAP_TOKEN_URL = 'https://api.infusionsoft.com/token';
4export const KEAP_API_BASE = 'https://api.infusionsoft.com/crm/rest/v2';
5
6export interface KeapTokenResponse {
7  access_token: string;
8  refresh_token: string;
9  token_type: string;
10  expires_in: number;
11  scope: string;
12}
13
14export interface StoredKeapToken {
15  accessToken: string;
16  refreshToken: string;
17  expiresAt: number; // Unix timestamp in milliseconds
18  scope: string;
19}
20
21export function buildAuthorizationUrl(state: string): string {
22  const params = new URLSearchParams({
23    client_id: process.env.KEAP_CLIENT_ID ?? '',
24    redirect_uri: process.env.KEAP_REDIRECT_URI ?? '',
25    response_type: 'code',
26    scope: 'full',
27    state,
28  });
29  return `${KEAP_OAUTH_BASE}?${params.toString()}`;
30}
31
32export function isTokenExpired(token: StoredKeapToken): boolean {
33  // Consider expired 5 minutes before actual expiry
34  return Date.now() >= token.expiresAt - 5 * 60 * 1000;
35}

1// app/api/auth/keap/callback/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { KEAP_TOKEN_URL, type KeapTokenResponse } from '@/lib/keap/config';
4
5export async function GET(request: NextRequest) {
6  const { searchParams } = new URL(request.url);
7  const code = searchParams.get('code');
8  const state = searchParams.get('state');
9  const stateCookie = request.cookies.get('keap_oauth_state')?.value;
10
11  // Validate CSRF state
12  if (!state || state !== stateCookie) {
13    return NextResponse.redirect(new URL('/auth/error?reason=invalid_state', request.url));
14  }
15  if (!code) {
16    return NextResponse.redirect(new URL('/auth/error?reason=no_code', request.url));
17  }
18
19  try {
20    // Exchange authorization code for tokens
21    const credentials = Buffer.from(
22      `${process.env.KEAP_CLIENT_ID}:${process.env.KEAP_CLIENT_SECRET}`
23    ).toString('base64');
24
25    const tokenResponse = await fetch(KEAP_TOKEN_URL, {
26      method: 'POST',
27      headers: {
28        'Authorization': `Basic ${credentials}`,
29        'Content-Type': 'application/x-www-form-urlencoded',
30      },
31      body: new URLSearchParams({
32        grant_type: 'authorization_code',
33        code,
34        redirect_uri: process.env.KEAP_REDIRECT_URI ?? '',
35      }),
36    });
37
38    if (!tokenResponse.ok) {
39      const error = await tokenResponse.text();
40      console.error('Keap token exchange failed:', error);
41      return NextResponse.redirect(new URL('/auth/error?reason=token_exchange', request.url));
42    }
43
44    const tokens: KeapTokenResponse = await tokenResponse.json();
45
46    // In production: save tokens to your database associated with the user session
47    // For now, log for development reference:
48    console.log('Keap OAuth successful. Access token received. Expires in:', tokens.expires_in, 's');
49
50    // Set access token in a secure HTTP-only cookie (simple single-user approach)
51    const response = NextResponse.redirect(new URL('/dashboard', request.url));
52    response.cookies.set('keap_access_token', tokens.access_token, {
53      httpOnly: true,
54      secure: process.env.NODE_ENV === 'production',
55      maxAge: tokens.expires_in,
56      sameSite: 'lax',
57    });
58    response.cookies.set('keap_refresh_token', tokens.refresh_token, {
59      httpOnly: true,
60      secure: process.env.NODE_ENV === 'production',
61      maxAge: 60 * 60 * 24 * 30, // 30 days
62      sameSite: 'lax',
63    });
64    response.cookies.delete('keap_oauth_state');
65
66    return response;
67  } catch (error) {
68    console.error('OAuth callback error:', error);
69    return NextResponse.redirect(new URL('/auth/error?reason=server_error', request.url));
70  }
71}

1// app/api/keap/contacts/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { KEAP_API_BASE } from '@/lib/keap/config';
4
5interface KeapContact {
6  id: number;
7  given_name: string;
8  family_name: string;
9  company_name?: string;
10  email_addresses: Array<{ email_address: string; field: string }>;
11  phone_numbers: Array<{ number: string; field: string }>;
12  date_created: string;
13  last_updated: string;
14}
15
16interface KeapContactsResponse {
17  contacts: KeapContact[];
18  count: number;
19}
20
21export async function GET(request: NextRequest) {
22  const token = request.cookies.get('keap_access_token')?.value;
23
24  if (!token) {
25    return NextResponse.json({ error: 'Not authenticated with Keap' }, { status: 401 });
26  }
27
28  const { searchParams } = new URL(request.url);
29  const searchEmail = searchParams.get('email');
30  const searchName = searchParams.get('given_name');
31  const limit = searchParams.get('limit') ?? '25';
32  const offset = searchParams.get('offset') ?? '0';
33
34  const params = new URLSearchParams({
35    limit,
36    offset,
37    order: 'date_created',
38    order_direction: 'descending',
39  });
40  if (searchEmail) params.set('email', searchEmail);
41  if (searchName) params.set('given_name', searchName);
42
43  try {
44    const response = await fetch(`${KEAP_API_BASE}/contacts?${params}`, {
45      headers: {
46        Authorization: `Bearer ${token}`,
47        'Content-Type': 'application/json',
48      },
49    });
50
51    if (response.status === 401) {
52      return NextResponse.json({ error: 'Keap token expired — re-authorize' }, { status: 401 });
53    }
54
55    if (!response.ok) {
56      return NextResponse.json(
57        { error: `Keap API error: ${response.status}` },
58        { status: response.status }
59      );
60    }
61
62    const data: KeapContactsResponse = await response.json();
63
64    const contacts = data.contacts.map((c) => ({
65      id: c.id,
66      name: [c.given_name, c.family_name].filter(Boolean).join(' ') || 'Unnamed',
67      email: c.email_addresses.find((e) => e.field === 'EMAIL1')?.email_address ?? '',
68      phone: c.phone_numbers.find((p) => p.field === 'PHONE1')?.number ?? '',
69      company: c.company_name ?? '',
70      dateAdded: new Date(c.date_created).toLocaleDateString(),
71    }));
72
73    return NextResponse.json({ contacts, total: data.count });
74  } catch (error) {
75    const message = error instanceof Error ? error.message : 'Request failed';
76    return NextResponse.json({ error: message }, { status: 500 });
77  }
78}

1// app/actions/keap.ts
2'use server';
3import { cookies } from 'next/headers';
4import { KEAP_API_BASE } from '@/lib/keap/config';
5
6interface CreateContactInput {
7  firstName: string;
8  lastName: string;
9  email: string;
10  phone?: string;
11  company?: string;
12}
13
14export async function createKeapContact(input: CreateContactInput) {
15  const cookieStore = await cookies();
16  const token = cookieStore.get('keap_access_token')?.value;
17
18  // For server-to-server integrations, use a service account token
19  const accessToken = token ?? process.env.KEAP_SERVICE_ACCOUNT_TOKEN;
20
21  if (!accessToken) {
22    return { error: 'Keap not configured' };
23  }
24
25  const contactBody: Record<string, unknown> = {
26    given_name: input.firstName,
27    family_name: input.lastName,
28    email_addresses: [{ email_address: input.email, field: 'EMAIL1' }],
29  };
30
31  if (input.phone) {
32    contactBody.phone_numbers = [{ number: input.phone, field: 'PHONE1', type: 'Work' }];
33  }
34  if (input.company) {
35    contactBody.company_name = input.company;
36  }
37
38  try {
39    const createResponse = await fetch(`${KEAP_API_BASE}/contacts`, {
40      method: 'POST',
41      headers: {
42        Authorization: `Bearer ${accessToken}`,
43        'Content-Type': 'application/json',
44      },
45      body: JSON.stringify(contactBody),
46    });
47
48    if (createResponse.status === 422) {
49      // Contact with this email already exists
50      return { success: true, alreadyExists: true };
51    }
52
53    if (!createResponse.ok) {
54      return { error: `Failed to create contact: ${createResponse.status}` };
55    }
56
57    const newContact = await createResponse.json();
58    const contactId: number = newContact.id;
59
60    // Apply lead tag if configured
61    const tagId = process.env.KEAP_LEAD_TAG_ID;
62    if (tagId && contactId) {
63      await fetch(`${KEAP_API_BASE}/contacts/${contactId}/tags`, {
64        method: 'POST',
65        headers: {
66          Authorization: `Bearer ${accessToken}`,
67          'Content-Type': 'application/json',
68        },
69        body: JSON.stringify({ tagIds: [parseInt(tagId)] }),
70      });
71    }
72
73    return { success: true, contactId };
74  } catch (error) {
75    const message = error instanceof Error ? error.message : 'Request failed';
76    return { error: message };
77  }
78}