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 = '12345-67890';
await client.get(`/threads/${threadPlatformId}`);  // 404!

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

// Or use lookup with platform ID
const { data } = await client.get('/threads/lookup', {
  params: {
    prospectPlatformId: '987654321',
    accountLinkId: 'acc_abc123'
  }
});

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

if (!data.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 } = await client.get('/account-links');
console.log('Valid account link IDs:');
data.accountLinks.forEach((a: any) => {
  console.log(`  ${a.platformUsername}: ${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 = [];
  let cursor = undefined;

  do {
    const { data } = await client.get('/threads', {
      params: {
        limit: 100,
        ...(cursor && {
          'cursor[id]': cursor.id,
          'cursor[timestamp]': cursor.timestamp
        })
      }
    });

    threads.push(...data.threads);
    cursor = data.nextCursor;
  } while (cursor);

  return threads;
}

// Correct cursor encoding
const { data } = await client.get('/threads', {
  params: {
    'cursor[id]': nextCursor.id,
    'cursor[timestamp]': 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 (bracket notation)
const { data } = await client.get('/threads', {
  params: {
    'filter[tagIds][0]': 'tag_abc',
    'filter[tagIds][1]': 'tag_xyz'
  }
});

// Wrong: passing array directly
const { data } = await client.get('/threads', {
  params: {
    'filter[tagIds]': ['tag_abc', 'tag_xyz']  // Won't work!
  }
});

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

for (const view of views) {
  const { data } = await client.get('/threads', {
    params: { inboxView: 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: accounts } = await client.get('/account-links');
  console.log(`   ✓ ${accounts.accountLinks.length} account(s) connected`);
  accounts.accountLinks.forEach((a: any) => {
    console.log(`     - @${a.platformUsername} (${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);