@coldiq/mcp 0.2.8 → 0.3.0

package/tests/tools/extract-post-engagement.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { extractPostEngagementHandler } from '../../src/tools/extract-post-engagement.js'
+
+const POST_URL = 'https://www.linkedin.com/feed/update/urn:li:activity:7234567890123456789'
+
+function res(body: unknown, status = 200, headers?: Record<string, string>) {
+  return new Response(JSON.stringify(body), { status, headers })
+}
+
+describe('extract_post_engagement handler', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+    vi.stubEnv('COLDIQ_ENGAGEMENT_POLL_MS', '1')
+    vi.stubEnv('COLDIQ_ENGAGEMENT_TIMEOUT_MS', '5000')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    vi.unstubAllEnvs()
+  })
+
+  it('runs create → poll → fetch contacts and returns the people', async () => {
+    const people = [{ name: 'Alex Vacca', profile_url: 'https://www.linkedin.com/in/alexvacca' }]
+    globalThis.fetch = vi.fn(async (url: string | URL) => {
+      const u = url.toString()
+      if (u.includes('/jungler/workbooks/wb_1/contacts')) return res(people)
+      if (u.includes('/jungler/tasks/task_1/status')) return res({ task_id: 'task_1', status: 'success', workbook_id: 'wb_1' })
+      if (u.includes('/jungler/workbooks')) return res({ task_id: 'task_1', status: 'PENDING' }, 200, { 'x-coldiq-credits-charged': '10', 'x-coldiq-credits-remaining': '90' })
+      throw new Error(`unexpected url ${u}`)
+    }) as typeof fetch
+
+    const result = await extractPostEngagementHandler({ post_url: POST_URL, type: 'both' })
+    const parsed = JSON.parse(result.content[0].text)
+    expect(result.isError).toBeUndefined()
+    expect(parsed.data.people).toEqual(people)
+    expect(parsed.data.type).toBe('both')
+    expect(parsed._meta.credits_charged).toBe(10)
+  })
+
+  it('passes activity_filter=commenters when type=comments', async () => {
+    let contactsUrl = ''
+    globalThis.fetch = vi.fn(async (url: string | URL) => {
+      const u = url.toString()
+      if (u.includes('/jungler/workbooks/wb_1/contacts')) { contactsUrl = u; return res([]) }
+      if (u.includes('/jungler/tasks/task_1/status')) return res({ task_id: 'task_1', status: 'success', workbook_id: 'wb_1' })
+      if (u.includes('/jungler/workbooks')) return res({ task_id: 'task_1', status: 'PENDING' })
+      throw new Error(`unexpected url ${u}`)
+    }) as typeof fetch
+
+    await extractPostEngagementHandler({ post_url: POST_URL, type: 'comments' })
+    expect(contactsUrl).toContain('activity_filter=commenters')
+  })
+
+  it('returns an error when the task fails upstream', async () => {
+    globalThis.fetch = vi.fn(async (url: string | URL) => {
+      const u = url.toString()
+      if (u.includes('/jungler/tasks/task_1/status')) return res({ task_id: 'task_1', status: 'failure' })
+      if (u.includes('/jungler/workbooks')) return res({ task_id: 'task_1', status: 'PENDING' })
+      throw new Error(`unexpected url ${u}`)
+    }) as typeof fetch
+
+    const result = await extractPostEngagementHandler({ post_url: POST_URL, type: 'both' })
+    expect(result.isError).toBe(true)
+    expect(JSON.parse(result.content[0].text).error).toMatch(/extraction failed/i)
+  })
+
+  it('surfaces the create error when the job cannot start', async () => {
+    globalThis.fetch = vi.fn(async () => res({ error: 'Invalid LinkedIn post URL' }, 400)) as typeof fetch
+    const result = await extractPostEngagementHandler({ post_url: POST_URL, type: 'both' })
+    expect(result.isError).toBe(true)
+    expect(JSON.parse(result.content[0].text).error).toMatch(/Invalid LinkedIn post URL/)
+  })
+})

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

@@ -139,14 +139,17 @@ describe('find_signals handler — hiring industries post-filter', () => {
     expect(body.data.data.map((r: { id: string }) => r.id)).toEqual(['a', 'c'])
   })
 
-  it('returns empty array when no row matches any industry', async () => {
+  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)
-    expect(body.data.data).toEqual([])
+    // 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 () => {

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

@@ -0,0 +1,73 @@
+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-reddit.test.ts

@@ -122,4 +122,73 @@ describe('search_reddit handler', () => {
       reddit.async!.pollIntervalMs = orig.i
     }
   })
+
+  it('rewrites a bare subreddit URL + query into an in-subreddit search URL', async () => {
+    let capturedBody: Record<string, unknown> | null = null
+    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
+      const u = url.toString()
+      if (u.includes('/reddit/scrape') && !u.includes('/scrape/')) {
+        capturedBody = JSON.parse((opts?.body as string) ?? '{}')
+        return new Response(JSON.stringify({ jobId: 'r-4' }), { status: 200 })
+      }
+      if (u.includes('/reddit/scrape/r-4')) {
+        return new Response(JSON.stringify({ jobId: 'r-4', status: 'done', items: [{ title: 'lemlist review' }] }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const { getProviders } = await import('../../src/registry.js')
+    const reddit = getProviders('search_reddit').find((p) => p.id === 'reddit')!
+    const orig = { t: reddit.async!.timeoutMs, i: reddit.async!.pollIntervalMs }
+    try {
+      reddit.async!.timeoutMs = 500
+      reddit.async!.pollIntervalMs = 20
+      await searchRedditHandler({
+        start_urls: ['https://www.reddit.com/r/coldemail/'],
+        query: 'lemlist',
+        time: 'month',
+        limit: 5,
+      })
+      const urls = (capturedBody!.startUrls as Array<{ url: string }>).map((s) => s.url)
+      expect(urls[0]).toContain('/r/coldemail/search/')
+      expect(urls[0]).toContain('q=lemlist')
+      expect(urls[0]).toContain('restrict_sr=1')
+      expect(urls[0]).toContain('t=month')
+      // Query now lives in the URL — top-level searchQueries is dropped to avoid a global search.
+      expect(capturedBody!.searchQueries).toBeUndefined()
+    } finally {
+      reddit.async!.timeoutMs = orig.t
+      reddit.async!.pollIntervalMs = orig.i
+    }
+  })
+
+  it('leaves an existing search URL untouched and keeps it as the start url', async () => {
+    let capturedBody: Record<string, unknown> | null = null
+    const searchUrl = 'https://www.reddit.com/search/?q=lemlist&sort=new'
+    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
+      const u = url.toString()
+      if (u.includes('/reddit/scrape') && !u.includes('/scrape/')) {
+        capturedBody = JSON.parse((opts?.body as string) ?? '{}')
+        return new Response(JSON.stringify({ jobId: 'r-5' }), { status: 200 })
+      }
+      if (u.includes('/reddit/scrape/r-5')) {
+        return new Response(JSON.stringify({ jobId: 'r-5', status: 'done', items: [{ title: 'x' }] }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const { getProviders } = await import('../../src/registry.js')
+    const reddit = getProviders('search_reddit').find((p) => p.id === 'reddit')!
+    const orig = { t: reddit.async!.timeoutMs, i: reddit.async!.pollIntervalMs }
+    try {
+      reddit.async!.timeoutMs = 500
+      reddit.async!.pollIntervalMs = 20
+      await searchRedditHandler({ start_urls: [searchUrl], query: 'lemlist', limit: 5 })
+      const urls = (capturedBody!.startUrls as Array<{ url: string }>).map((s) => s.url)
+      expect(urls[0]).toBe(searchUrl)
+    } finally {
+      reddit.async!.timeoutMs = orig.t
+      reddit.async!.pollIntervalMs = orig.i
+    }
+  })
 })