@coldiq/mcp 0.3.12 → 0.3.13

package/tests/tools/find-phone.test.ts

@@ -1,100 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { initClient } from '../../src/client.js'
-import { findPhoneHandler } from '../../src/tools/find-phone.js'
-
-describe('find_phone handler', () => {
-  const originalFetch = globalThis.fetch
-
-  beforeEach(() => {
-    initClient('http://test-api.local', 'test-key')
-  })
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch
-  })
-
-  it('returns phone from FindyMail', async () => {
-    globalThis.fetch = vi.fn(async () =>
-      new Response(JSON.stringify({ phone: '+33612345678' }), { status: 200 })
-    ) as typeof fetch
-
-    const result = await findPhoneHandler({ linkedin_url: 'https://linkedin.com/in/michel-lieben' })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed._meta.provider).toBe('findymail')
-    expect(parsed.data.phone).toBe('+33612345678')
-  })
-
-  it('falls through to LimaData when Findymail misses', async () => {
-    let callCount = 0
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      callCount++
-      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.href : url.url
-      if (urlStr.includes('findymail')) return new Response(JSON.stringify({}), { status: 200 })
-      if (urlStr.includes('coldiq/find/phone')) return new Response(JSON.stringify({ phone: '+33698765432' }), { status: 200 })
-      return new Response(JSON.stringify({}), { status: 200 })
-    }) as typeof fetch
-
-    const result = await findPhoneHandler({ linkedin_url: 'https://linkedin.com/in/michel-lieben' })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(result.isError).toBeFalsy()
-    expect(parsed._meta.provider).toBe('limadata')
-    expect(parsed.data.phone).toBe('+33698765432')
-  })
-
-  it('uses AI Ark when Findymail and LimaData both miss', async () => {
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.href : url.url
-      if (urlStr.includes('findymail')) return new Response(JSON.stringify({}), { status: 200 })
-      if (urlStr.includes('coldiq/find/phone')) return new Response(JSON.stringify({}), { status: 200 })
-      if (urlStr.includes('mobile-phone-finder')) return new Response(JSON.stringify({ data: [['+33611223344']] }), { status: 200 })
-      return new Response(JSON.stringify({}), { status: 200 })
-    }) as typeof fetch
-
-    const result = await findPhoneHandler({ linkedin_url: 'https://linkedin.com/in/michel-lieben' })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(result.isError).toBeFalsy()
-    expect(parsed._meta.provider).toBe('ai-ark')
-    expect(parsed.data.data).toEqual([['+33611223344']])
-  })
-
-  it('uses LimaData and AI Ark when linkedin_url absent (name+domain path)', async () => {
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.href : url.url
-      if (urlStr.includes('coldiq/find/phone')) return new Response(JSON.stringify({}), { status: 200 })
-      if (urlStr.includes('mobile-phone-finder')) return new Response(JSON.stringify({ data: [['+33611223344']] }), { status: 200 })
-      return new Response(JSON.stringify({}), { status: 200 })
-    }) as typeof fetch
-
-    const result = await findPhoneHandler({
-      first_name: 'Michel',
-      last_name: 'Lieben',
-      company_domain: 'coldiq.com',
-    })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(result.isError).toBeFalsy()
-    expect(parsed._meta.provider).toBe('ai-ark')
-  })
-
-  it('returns error with clear message when no valid input combo provided', async () => {
-    const result = await findPhoneHandler({ company_name: 'ColdIQ' })
-
-    expect(result.isError).toBe(true)
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.error).toContain('linkedin_url')
-    expect(parsed.error).toContain('first_name')
-  })
-
-  it('returns error when no provider finds a phone', async () => {
-    globalThis.fetch = vi.fn(async () =>
-      new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
-    ) as typeof fetch
-
-    const result = await findPhoneHandler({ linkedin_url: 'https://linkedin.com/in/unknown' })
-
-    expect(result.isError).toBe(true)
-  })
-})

package/tests/tools/find-signals.test.ts

@@ -1,175 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-
-// Mock executeWithFallback so handler tests never hit real providers
-vi.mock('../../src/executor.js', () => ({
-  executeWithFallback: vi.fn().mockResolvedValue({ data: [], _meta: { provider: 'mock' } }),
-  isExecutionError: vi.fn().mockReturnValue(false),
-}))
-
-import { findSignalsHandler } from '../../src/tools/find-signals.js'
-
-beforeEach(() => {
-  vi.clearAllMocks()
-})
-
-// ---------------------------------------------------------------------------
-// intent pre-check: requires companies or domains
-// ---------------------------------------------------------------------------
-
-describe('find_signals handler — intent guard', () => {
-  it('rejects intent with no companies or domains', async () => {
-    const result = await findSignalsHandler({ signal_type: 'intent', limit: 10 })
-    expect(result.isError).toBe(true)
-    const body = JSON.parse(result.content[0].text)
-    expect(body.error).toMatch(/intent signal_type requires/)
-  })
-
-  it('rejects intent with empty companies array', async () => {
-    const result = await findSignalsHandler({ signal_type: 'intent', companies: [], limit: 10 })
-    expect(result.isError).toBe(true)
-  })
-
-  it('rejects intent with empty domains array', async () => {
-    const result = await findSignalsHandler({ signal_type: 'intent', domains: [], limit: 10 })
-    expect(result.isError).toBe(true)
-  })
-
-  it('allows intent with companies present', async () => {
-    const result = await findSignalsHandler({ signal_type: 'intent', companies: ['ColdIQ'], limit: 10 })
-    expect(result.isError).toBeUndefined()
-  })
-
-  it('allows intent with domains present', async () => {
-    const result = await findSignalsHandler({ signal_type: 'intent', domains: ['coldiq.com'], limit: 10 })
-    expect(result.isError).toBeUndefined()
-  })
-})
-
-// ---------------------------------------------------------------------------
-// feed-style pre-check: news and startup_post reject company filters
-// ---------------------------------------------------------------------------
-
-describe('find_signals handler — feed-style guard (news)', () => {
-  it('rejects news with companies filter', async () => {
-    const result = await findSignalsHandler({ signal_type: 'news', companies: ['ColdIQ'] })
-    expect(result.isError).toBe(true)
-    const body = JSON.parse(result.content[0].text)
-    expect(body.error).toMatch(/news and startup_post/)
-  })
-
-  it('rejects news with domains filter', async () => {
-    const result = await findSignalsHandler({ signal_type: 'news', domains: ['coldiq.com'] })
-    expect(result.isError).toBe(true)
-  })
-
-  it('allows news with countries only', async () => {
-    const result = await findSignalsHandler({ signal_type: 'news', countries: ['US'], limit: 10 })
-    expect(result.isError).toBeUndefined()
-  })
-
-  it('allows news with since and limit only', async () => {
-    const result = await findSignalsHandler({ signal_type: 'news', since: '2026-01-01', limit: 5 })
-    expect(result.isError).toBeUndefined()
-  })
-})
-
-describe('find_signals handler — feed-style guard (startup_post)', () => {
-  it('rejects startup_post with companies filter', async () => {
-    const result = await findSignalsHandler({ signal_type: 'startup_post', companies: ['ColdIQ'] })
-    expect(result.isError).toBe(true)
-    const body = JSON.parse(result.content[0].text)
-    expect(body.error).toMatch(/news and startup_post/)
-  })
-
-  it('rejects startup_post with domains filter', async () => {
-    const result = await findSignalsHandler({ signal_type: 'startup_post', domains: ['coldiq.com'] })
-    expect(result.isError).toBe(true)
-  })
-
-  it('allows startup_post with since filter only', async () => {
-    const result = await findSignalsHandler({ signal_type: 'startup_post', since: '2026-01-01', limit: 25 })
-    expect(result.isError).toBeUndefined()
-  })
-})
-
-// ---------------------------------------------------------------------------
-// company-targeted types: no pre-check rejection
-// ---------------------------------------------------------------------------
-
-describe('find_signals handler — company-targeted types pass through', () => {
-  const types = ['funding', 'acquisition', 'hiring', 'job_change'] as const
-
-  for (const signal_type of types) {
-    it(`allows ${signal_type} with or without companies`, async () => {
-      const withCompanies = await findSignalsHandler({ signal_type, companies: ['ColdIQ'] })
-      const withoutCompanies = await findSignalsHandler({ signal_type, limit: 10 })
-      expect(withCompanies.isError).toBeUndefined()
-      expect(withoutCompanies.isError).toBeUndefined()
-    })
-  }
-})
-
-// ---------------------------------------------------------------------------
-// hiring industries client-side post-filter
-//
-// Signalbase /hiring-signals has no upstream `industry` query param, so the
-// handler filters the result rows by industries instead of silently dropping
-// the filter.
-// ---------------------------------------------------------------------------
-
-import { executeWithFallback as mockedExecute } from '../../src/executor.js'
-
-describe('find_signals handler — hiring industries post-filter', () => {
-  const hiringRows = [
-    { id: 'a', title: 'Sales Lead', companyName: 'CreatePay', industries: 'Financial Services' },
-    { id: 'b', title: 'Sales Assistant', companyName: 'AstraZeneca', industries: 'Pharmaceutical Manufacturing' },
-    { id: 'c', title: 'Account Executive', companyName: 'Monex Europe', industries: 'Financial Services and Foreign Exchange' },
-    { id: 'd', title: 'Legal Counsel', companyName: 'Eversheds', industries: 'Law Practice and Legal Services' },
-    { id: 'e', title: 'Engineer', companyName: 'NoIndustries', industries: '' },
-  ]
-
-  it('filters rows by case-insensitive industries substring match', async () => {
-    vi.mocked(mockedExecute).mockResolvedValueOnce({
-      data: { success: true, data: [...hiringRows] },
-      _meta: { provider: 'signalbase-hiring', latencyMs: 1 },
-    })
-    const result = await findSignalsHandler({ signal_type: 'hiring', industries: ['financial services'], limit: 25 })
-    const body = JSON.parse(result.content[0].text)
-    expect(body.data.data).toHaveLength(2)
-    expect(body.data.data.map((r: { id: string }) => r.id)).toEqual(['a', 'c'])
-  })
-
-  it('returns unfiltered rows with a note when no row matches any industry', async () => {
-    vi.mocked(mockedExecute).mockResolvedValueOnce({
-      data: { success: true, data: [...hiringRows] },
-      _meta: { provider: 'signalbase-hiring', latencyMs: 1 },
-    })
-    const result = await findSignalsHandler({ signal_type: 'hiring', industries: ['Aerospace'], limit: 25 })
-    const body = JSON.parse(result.content[0].text)
-    // Non-destructive: keep all rows rather than return a misleading empty set,
-    // and flag that the industry filter matched nothing.
-    expect(body.data.data).toHaveLength(5)
-    expect(body.data._industry_filter).toMatch(/UNFILTERED/)
-  })
-
-  it('leaves rows untouched when industries is absent', async () => {
-    vi.mocked(mockedExecute).mockResolvedValueOnce({
-      data: { success: true, data: [...hiringRows] },
-      _meta: { provider: 'signalbase-hiring', latencyMs: 1 },
-    })
-    const result = await findSignalsHandler({ signal_type: 'hiring', limit: 25 })
-    const body = JSON.parse(result.content[0].text)
-    expect(body.data.data).toHaveLength(5)
-  })
-
-  it('does not apply filter to non-hiring signal types', async () => {
-    vi.mocked(mockedExecute).mockResolvedValueOnce({
-      data: { success: true, data: [...hiringRows] },
-      _meta: { provider: 'signalbase-funding', latencyMs: 1 },
-    })
-    const result = await findSignalsHandler({ signal_type: 'funding', industries: ['Aerospace'], limit: 25 })
-    const body = JSON.parse(result.content[0].text)
-    // Untouched: industries is forwarded upstream for funding, not post-filtered here.
-    expect(body.data.data).toHaveLength(5)
-  })
-})

package/tests/tools/get-place-reviews.test.ts

@@ -1,73 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { initClient } from '../../src/client.js'
-import { getPlaceReviewsHandler } from '../../src/tools/get-place-reviews.js'
-import { getProviders } from '../../src/registry.js'
-
-const PLACE_URL = 'https://www.google.com/maps/place/ColdIQ'
-
-describe('get_place_reviews handler', () => {
-  const originalFetch = globalThis.fetch
-
-  beforeEach(() => {
-    initClient('http://test-api.local', 'test-key')
-  })
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch
-  })
-
-  function withFastPolling<T>(fn: () => Promise<T>): Promise<T> {
-    const p = getProviders('get_place_reviews').find((x) => x.id === 'google_maps_reviews')!
-    const orig = { t: p.async!.timeoutMs, i: p.async!.pollIntervalMs }
-    p.async!.timeoutMs = 500
-    p.async!.pollIntervalMs = 20
-    return fn().finally(() => {
-      p.async!.timeoutMs = orig.t
-      p.async!.pollIntervalMs = orig.i
-    })
-  }
-
-  it('submits the reviews job and returns reviews when done', async () => {
-    const reviews = [{ text: 'Great service', stars: 5 }]
-    globalThis.fetch = vi.fn(async (url: string | URL) => {
-      const u = url.toString()
-      if (u.includes('/google-maps/reviews/rev-1')) {
-        return new Response(JSON.stringify({ jobId: 'rev-1', status: 'done', reviews }), { status: 200 })
-      }
-      if (u.includes('/google-maps/reviews')) {
-        return new Response(JSON.stringify({ jobId: 'rev-1', status: 'processing' }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const result = await withFastPolling(() =>
-      getPlaceReviewsHandler({ place_urls: [PLACE_URL], max_reviews: 10, sort: 'lowestRanking' }),
-    )
-    expect(result.isError).toBeFalsy()
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed._meta.provider).toBe('google_maps_reviews')
-    expect(parsed.data.reviews).toEqual(reviews)
-  })
-
-  it('forwards place_urls, max_reviews and sort to the upstream body', async () => {
-    let submitBody: Record<string, unknown> = {}
-    globalThis.fetch = vi.fn(async (url: string | URL, init?: RequestInit) => {
-      const u = url.toString()
-      if (u.includes('/google-maps/reviews/rev-1')) {
-        return new Response(JSON.stringify({ jobId: 'rev-1', status: 'done', reviews: [] }), { status: 200 })
-      }
-      if (u.includes('/google-maps/reviews')) {
-        submitBody = JSON.parse(init!.body as string)
-        return new Response(JSON.stringify({ jobId: 'rev-1', status: 'processing' }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    await withFastPolling(() =>
-      getPlaceReviewsHandler({ place_urls: [PLACE_URL], max_reviews: 25, sort: 'newest' }),
-    )
-    expect(submitBody.startUrls).toEqual([{ url: PLACE_URL }])
-    expect(submitBody.maxReviews).toBe(25)
-    expect(submitBody.reviewsSort).toBe('newest')
-  })
-})

package/tests/tools/search-ads.test.ts

@@ -1,182 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { initClient } from '../../src/client.js'
-import { searchAdsHandler } from '../../src/tools/search-ads.js'
-
-describe('search_ads handler', () => {
-  const originalFetch = globalThis.fetch
-
-  beforeEach(() => {
-    initClient('http://test-api.local', 'test-key')
-  })
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch
-  })
-
-  it('domains filter — routes to google_ads only', async () => {
-    let metaCalled = false
-    let linkedinCalled = false
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/meta-ads/')) metaCalled = true
-      if (u.includes('/linkedin-ad-library/')) linkedinCalled = true
-      if (u.includes('/google-ads/search') && !u.includes('/search/')) {
-        return new Response(JSON.stringify({ jobId: 'ads-1' }), { status: 200 })
-      }
-      if (u.includes('/google-ads/search/ads-1')) {
-        return new Response(JSON.stringify({ jobId: 'ads-1', status: 'done', ads: [{ advertiser: 'Salesforce', headline: 'CRM Leader' }] }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('search_ads')
-    const ga = providers.find((p) => p.id === 'google_ads')!
-    const orig = { t: ga.async!.timeoutMs, i: ga.async!.pollIntervalMs }
-    ga.async!.timeoutMs = 500
-    ga.async!.pollIntervalMs = 20
-
-    try {
-      const result = await searchAdsHandler({ domains: ['salesforce.com'] })
-
-      expect(result.isError).toBeFalsy()
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('google_ads')
-      expect(metaCalled).toBe(false)
-      expect(linkedinCalled).toBe(false)
-    } finally {
-      ga.async!.timeoutMs = orig.t
-      ga.async!.pollIntervalMs = orig.i
-    }
-  })
-
-  it('search_urls filter — routes to linkedin_ad_library only', async () => {
-    let googleCalled = false
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/google-ads/')) googleCalled = true
-      if (u.includes('/linkedin-ad-library/search') && !u.includes('/search/')) {
-        return new Response(JSON.stringify({ jobId: 'li-1' }), { status: 200 })
-      }
-      if (u.includes('/linkedin-ad-library/search/li-1')) {
-        return new Response(JSON.stringify({ jobId: 'li-1', status: 'done', ads: [{ company: 'ColdIQ', creative: 'B2B ad' }] }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('search_ads')
-    const li = providers.find((p) => p.id === 'linkedin_ad_library')!
-    const orig = { t: li.async!.timeoutMs, i: li.async!.pollIntervalMs }
-    li.async!.timeoutMs = 500
-    li.async!.pollIntervalMs = 20
-
-    try {
-      const result = await searchAdsHandler({
-        search_urls: ['https://linkedin.com/ad-library/search?companyIds=123'],
-      })
-
-      expect(result.isError).toBeFalsy()
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('linkedin_ad_library')
-      expect(googleCalled).toBe(false)
-    } finally {
-      li.async!.timeoutMs = orig.t
-      li.async!.pollIntervalMs = orig.i
-    }
-  })
-
-  it('query only — falls through google_ads (no results) → meta_ads wins', async () => {
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      // google_ads: create returns jobId, poll returns no ads
-      if (u.includes('/google-ads/search') && !u.includes('/search/')) {
-        return new Response(JSON.stringify({ jobId: 'ga-2' }), { status: 200 })
-      }
-      if (u.includes('/google-ads/search/ga-2')) {
-        return new Response(JSON.stringify({ jobId: 'ga-2', status: 'done', ads: [] }), { status: 200 })
-      }
-      // meta_ads: returns results
-      if (u.includes('/meta-ads/search') && !u.includes('/search/')) {
-        return new Response(JSON.stringify({ jobId: 'meta-1' }), { status: 200 })
-      }
-      if (u.includes('/meta-ads/search/meta-1')) {
-        return new Response(JSON.stringify({ jobId: 'meta-1', status: 'done', ads: [{ page_name: 'ColdIQ', body: 'Outbound faster' }] }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('search_ads')
-    const ga = providers.find((p) => p.id === 'google_ads')!
-    const ma = providers.find((p) => p.id === 'meta_ads')!
-    const origGa = { t: ga.async!.timeoutMs, i: ga.async!.pollIntervalMs }
-    const origMa = { t: ma.async!.timeoutMs, i: ma.async!.pollIntervalMs }
-    ga.async!.timeoutMs = 500
-    ga.async!.pollIntervalMs = 20
-    ma.async!.timeoutMs = 500
-    ma.async!.pollIntervalMs = 20
-
-    try {
-      const result = await searchAdsHandler({ query: 'ColdIQ' })
-
-      expect(result.isError).toBeFalsy()
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('meta_ads')
-    } finally {
-      ga.async!.timeoutMs = origGa.t
-      ga.async!.pollIntervalMs = origGa.i
-      ma.async!.timeoutMs = origMa.t
-      ma.async!.pollIntervalMs = origMa.i
-    }
-  })
-
-  it('platform=meta pinned — only meta_ads fires', async () => {
-    let googleCalled = false
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/google-ads/')) googleCalled = true
-      if (u.includes('/meta-ads/search') && !u.includes('/search/')) {
-        return new Response(JSON.stringify({ jobId: 'meta-2' }), { status: 200 })
-      }
-      if (u.includes('/meta-ads/search/meta-2')) {
-        return new Response(JSON.stringify({ jobId: 'meta-2', status: 'done', ads: [{ page_name: 'ColdIQ' }] }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('search_ads')
-    const ma = providers.find((p) => p.id === 'meta_ads')!
-    const orig = { t: ma.async!.timeoutMs, i: ma.async!.pollIntervalMs }
-    ma.async!.timeoutMs = 500
-    ma.async!.pollIntervalMs = 20
-
-    try {
-      const result = await searchAdsHandler({ platform: 'meta', query: 'ColdIQ' })
-
-      expect(result.isError).toBeFalsy()
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('meta_ads')
-      expect(googleCalled).toBe(false)
-    } finally {
-      ma.async!.timeoutMs = orig.t
-      ma.async!.pollIntervalMs = orig.i
-    }
-  })
-
-  it('all providers fail — returns isError', async () => {
-    globalThis.fetch = vi.fn(async () => {
-      return new Response(JSON.stringify({ error: 'down' }), { status: 503 })
-    }) as typeof fetch
-
-    const result = await searchAdsHandler({ query: 'ColdIQ' })
-
-    expect(result.isError).toBe(true)
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.error).toBeTruthy()
-  })
-})