Troubleshooting

// Check your header format
const headers = {
  'Authorization': `Bearer ${process.env.INBOX_API_TOKEN}`,  // Note the space after Bearer
  'Content-Type': 'application/json'
};

// Verify token is loaded
if (!process.env.INBOX_API_TOKEN) {
  throw new Error('INBOX_API_TOKEN environment variable not set');
}

// Test with a simple request
const response = await fetch('https://inboxapp.com/api/v1/team', { headers });
console.log('Status:', response.status);

// Wrong: Using platform ID
const threadPlatformId = '1566123362161725440:1876543210987654321';
await client.get(`/threads/${threadPlatformId}`);  // 404!

// Correct: Use Inbox ID (CUID2 format)
const threadInboxId = 'l44e15irdq4db30i77cgphhx';
await client.get(`/threads/${threadInboxId}`);  // Works

// Or use lookup with platform ID
const { data: thread } = await client.get('/threads/lookup', {
  params: {
    externalPlatformId: '1876543210987654321',
    accountLinkId: 'df6jbw4h36qm5d9iu2sgn7kx'
  }
});

// Verify prospect exists before operations
const { data: prospect } = await client.get('/prospects/lookup', {
  params: { platformId: '1876543210987654321' }
});

if (!prospect) {
  console.log('Prospect not in system. They need to message you first,');
  console.log('or you need to start a conversation via /threads endpoint.');
}

// List your account links to get valid IDs
const { data: accountLinks } = await client.get('/account-links');
console.log('Valid account link IDs:');
accountLinks.forEach((a: any) => {
  console.log(`  @${a.username}: ${a.id}`);
});

// Implement retry with backoff
async function sendWithRetry(threadId: string, text: string) {
  let retries = 0;
  const maxRetries = 5;

  while (retries < maxRetries) {
    try {
      return await client.post(`/threads/${threadId}/messages`, { text });
    } catch (error) {
      if (axios.isAxiosError(error) && error.response?.status === 429) {
        const retryAfter = parseInt(
          error.response.headers['retry-after'] || '60',
          10
        );
        console.log(`Rate limited. Waiting ${retryAfter}s...`);
        await new Promise(r => setTimeout(r, retryAfter * 1000));
        retries++;
      } else {
        throw error;
      }
    }
  }
  throw new Error('Max retries exceeded');
}

// Add delays between bulk operations
for (const message of messages) {
  await sendMessage(message);
  await new Promise(r => setTimeout(r, 6000));  // 6 seconds between sends
}

// Always paginate through all results
async function getAllThreads() {
  const threads: any[] = [];
  let cursorId: string | undefined;
  let cursorTimestamp: string | undefined;

  do {
    const { data } = await client.get('/threads', {
      params: {
        limit: 100,
        ...(cursorId && { cursorId, cursorTimestamp })
      }
    });

    threads.push(...data.threads);
    cursorId = data.nextCursor?.id;
    cursorTimestamp = data.nextCursor?.timestamp;
  } while (cursorId);

  return threads;
}

// Correct: use flat cursor parameters
const { data } = await client.get('/threads', {
  params: {
    cursorId: nextCursor.id,
    cursorTimestamp: nextCursor.timestamp
  }
});

function validateMessage(text: string) {
  if (!text?.trim()) {
    throw new Error('Message cannot be empty');
  }
  if (text.length > 10000) {
    throw new Error('Message exceeds 10,000 character limit');
  }
}

// Always validate before sending
validateMessage(messageText);
await client.post(`/threads/${threadId}/messages`, { text: messageText });

// Correct filter format (nested bracket notation)
const { data } = await client.get('/threads', {
  params: {
    'filters[tags][selectedIds][0]': 't8rvk2m5j0xn4wq7ybftcael',
    'filters[tags][selectedIds][1]': 'u9swl3n6k1yo5xr8zcgudbfm'
  }
});

// Wrong: using incorrect key structure
const { data } = await client.get('/threads', {
  params: {
    'filter[tagIds][0]': 't8rvk2m5j0xn4wq7ybftcael'  // Wrong key!
  }
});

// Check all inbox views
const views = ['default', 'no-reply', 'requests', 'archived'];

for (const view of views) {
  const { data } = await client.get('/threads', {
    params: { inbox: view, limit: 1 }
  });
  console.log(`${view}: ${data.threads.length} threads`);
}

async function diagnose() {
  console.log('=== Inbox API Diagnostic ===\n');

  // 1. Check authentication
  console.log('1. Testing authentication...');
  try {
    const { data: team } = await client.get('/team');
    console.log(`   ✓ Connected to team: ${team.name}`);
  } catch (error) {
    console.log(`   ✗ Auth failed: ${error.message}`);
    return;
  }

  // 2. Check account links
  console.log('\n2. Checking account links...');
  const { data: accountLinks } = await client.get('/account-links');
  console.log(`   ✓ ${accountLinks.length} account(s) connected`);
  accountLinks.forEach((a: any) => {
    console.log(`     - @${a.username} (${a.id})`);
  });

  // 3. Check threads
  console.log('\n3. Checking threads...');
  const { data: threads } = await client.get('/threads', {
    params: { limit: 5 }
  });
  console.log(`   ✓ ${threads.threads.length} recent threads`);

  // 4. Check rate limit status
  console.log('\n4. Rate limit status...');
  // Make a request and check headers
  const response = await client.get('/team');
  const remaining = response.headers['x-ratelimit-remaining'];
  const limit = response.headers['x-ratelimit-limit'];
  console.log(`   ✓ ${remaining}/${limit} requests remaining`);

  console.log('\n=== Diagnostic Complete ===');
}

diagnose().catch(console.error);