@tellescope/sdk 1.256.13 → 1.256.14

package/src/tests/api_tests/security/F-0196-add-to-journey-foreign-enduserid.test.ts

@@ -0,0 +1,208 @@
+require('source-map-support').install();
+
+import {
+  assert_checks,
+  Check,
+  setup_isolated_tenant,
+} from "../../setup_isolated"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+// far enough out that a locally running worker never claims the rows we inspect
+const FUTURE_START = () => new Date(Date.now() + 60 * 60 * 1000)
+
+/**
+ * Regression test for F-0196
+ * (security-audit/findings/F-0196-add-to-journey-plants-foreign-enduserid.md).
+ *
+ * `endusers.add_to_journey` inserted an `automated_actions` row for EACH caller-supplied `enduserId`
+ * with only mongoId-shape validation and no tenant-membership check. The preceding
+ * `DB.endusers.updateMany` is scoped but its result was discarded, and
+ * `DB.automated_actions.insertMany` is a direct write that bypasses the `ensureValidDependentKeys`
+ * foreign-key check the generic CRUD route gets. The resulting row is stamped
+ * `businessId: <caller's tenant>` while carrying `enduserId: <a victim in another tenant>`.
+ *
+ * The worker then dereferences that enduser with the raw driver and no `businessId`
+ * (worker/modules/automations.ts, the F-0074/F-0111/F-0159 family), so the victim's record loads
+ * under the attacker's automation: `pushFormsToPortal` copies the victim's PHI into the attacker's
+ * `form_responses` (readable by their staff) and `iterableCustomEvent` writes an attacker-authored
+ * note into the victim's chart. F-0196 is the reachability that made those three exploitable.
+ *
+ * There are TWO independent plant sites and a fix to only one is a half fix:
+ *   - inline branch, taken when `automationStepId` is supplied (api.ts add_to_journey handler)
+ *   - module branch, taken when it is not: `handle_automation_event`'s
+ *     `validEnduserIds = conditionsQuery ? <scoped find> : event.enduserIds` passes caller ids
+ *     straight through for a step with NO conditions.
+ * Both are covered below (A1/A2).
+ *
+ * Design notes:
+ *   - Two provisioned tenants, so the victim is a real foreign enduser and we can also assert their
+ *     record was not mutated. Both must come from provisioning: `add_to_journey` is
+ *     `requiresSubscription: true`, and a `create_and_join` org is born with an expired subscription.
+ *   - The steps use `setEnduserStatus` — no vendor, no Bedrock — and `startAt` is an hour out so a
+ *     running worker cannot process the rows before we read them.
+ *   - `throttle` is deliberately omitted: it is the only way add_to_journey's per-pair rate limit can
+ *     throw.
+ *   - Everything is observable through `automated_actions` reads, so the worker is never needed.
+ *
+ * RED (pre-fix): A1, A2 and B2 fail — the victim's id appears in the attacker tenant's
+ * automated_actions. GREEN (post-fix): the foreign id is silently dropped and the caller's own
+ * endusers still enroll normally.
+ */
+export const add_to_journey_foreign_enduserid_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  let attacker: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
+  let victimTenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
+
+  try {
+    /* ================= fixtures: two isolated tenants ================= */
+
+    ;[attacker, victimTenant] = await Promise.all([
+      setup_isolated_tenant({ name: `F0196 attacker ${RAND()}`, users: [{ isAdmin: true }], apiKeys: 0 }),
+      setup_isolated_tenant({ name: `F0196 victim ${RAND()}`, users: [{ isAdmin: true }], apiKeys: 0 }),
+    ])
+
+    const victim = await victimTenant.sdk.api.endusers.createOne({ fname: 'F0196', lname: 'Victim' })
+    const own = await attacker.sdk.api.endusers.createOne({ fname: 'F0196', lname: 'OwnPatient' })
+
+    record(
+      'setup: two separate tenants, victim belongs to the other one',
+      attacker.businessId !== victimTenant.businessId && !!victim.id && !!own.id,
+      `attacker=${attacker.businessId} victim tenant=${victimTenant.businessId} victimEnduser=${victim.id}`,
+    )
+
+    // one journey + onJourneyStart step per branch, so the per-(enduser,journey) throttle bucket and
+    // the row sets stay independent
+    const makeJourney = async (title: string) => {
+      const journey = await attacker!.sdk.api.journeys.createOne({ title: `${title} ${RAND()}` })
+      const step = await attacker!.sdk.api.automation_steps.createOne({
+        journeyId: journey.id,
+        // benign and worker-local: no vendor, no Bedrock. NO `conditions`, which is precisely the
+        // vulnerable branch in handle_automation_event.
+        action: { type: 'setEnduserStatus', info: { status: 'F0196' } },
+        events: [{ type: 'onJourneyStart', info: {} }],
+      } as any)
+      return { journey, step }
+    }
+
+    const inline = await makeJourney('F0196 inline')
+    const modulePath = await makeJourney('F0196 module')
+    const mixed = await makeJourney('F0196 mixed')
+
+    /** every automated_actions row the attacker tenant can see for a journey */
+    const rowsFor = async (journeyId: string) => (
+      await attacker!.sdk.api.automated_actions.getSome({ filter: { journeyId } } as any)
+    )
+    const enduserIdsFor = async (journeyId: string) => (await rowsFor(journeyId)).map((r: any) => r.enduserId)
+
+    /* ===== A: the foreign id must never be planted, on EITHER branch ===== */
+
+    // A1 — inline branch: automationStepId supplied
+    const inlineResult = await attacker.sdk.api.endusers.add_to_journey({
+      enduserIds: [victim.id],
+      journeyId: inline.journey.id,
+      automationStepId: inline.step.id,
+      startAt: FUTURE_START(),
+    } as any).then(() => 'resolved').catch((e: any) => `rejected: ${e?.message || e}`)
+
+    const inlineIds = await enduserIdsFor(inline.journey.id)
+    record(
+      'A1: inline branch (automationStepId) does not plant a foreign enduserId',
+      !inlineIds.includes(victim.id),
+      `call=${inlineResult}; automated_actions enduserIds=${JSON.stringify(inlineIds)} (must not contain ${victim.id})`,
+    )
+
+    // A2 — module branch: no automationStepId, so it routes through handle_automation_event
+    const moduleResult = await attacker.sdk.api.endusers.add_to_journey({
+      enduserIds: [victim.id],
+      journeyId: modulePath.journey.id,
+      startAt: FUTURE_START(),
+    } as any).then(() => 'resolved').catch((e: any) => `rejected: ${e?.message || e}`)
+
+    const moduleIds = await enduserIdsFor(modulePath.journey.id)
+    record(
+      'A2: module branch (no automationStepId) does not plant a foreign enduserId',
+      !moduleIds.includes(victim.id),
+      `call=${moduleResult}; automated_actions enduserIds=${JSON.stringify(moduleIds)} (must not contain ${victim.id})`,
+    )
+
+    // A3 — the victim's own record must be untouched (the scoped updateMany should already ensure it)
+    const victimAfter = await victimTenant.sdk.api.endusers.getOne(victim.id)
+    const victimJourneys = (victimAfter as any)?.journeys ?? {}
+    record(
+      'A3: the victim enduser was not enrolled in the attacker\'s journey',
+      !victimJourneys[inline.journey.id] && !victimJourneys[modulePath.journey.id],
+      `victim journeys=${JSON.stringify(victimJourneys)}`,
+    )
+
+    /* ===== B: legitimate use must keep working ===== */
+
+    // B1 — positive control on both branches, so a blanket failure can't masquerade as a fix
+    await attacker.sdk.api.endusers.add_to_journey({
+      enduserIds: [own.id],
+      journeyId: inline.journey.id,
+      automationStepId: inline.step.id,
+      startAt: FUTURE_START(),
+    } as any)
+    await attacker.sdk.api.endusers.add_to_journey({
+      enduserIds: [own.id],
+      journeyId: modulePath.journey.id,
+      startAt: FUTURE_START(),
+    } as any)
+
+    const inlineOwn = await enduserIdsFor(inline.journey.id)
+    const moduleOwn = await enduserIdsFor(modulePath.journey.id)
+    record(
+      'B1: the caller\'s OWN enduser still enrolls on both branches',
+      inlineOwn.includes(own.id) && moduleOwn.includes(own.id),
+      `inline=${JSON.stringify(inlineOwn)} module=${JSON.stringify(moduleOwn)} (both must contain ${own.id})`,
+    )
+
+    // B2 — a mixed list must enroll the visible id and drop only the foreign one: proves an
+    // intersect, not an all-or-nothing rejection
+    const mixedResult = await attacker.sdk.api.endusers.add_to_journey({
+      enduserIds: [own.id, victim.id],
+      journeyId: mixed.journey.id,
+      automationStepId: mixed.step.id,
+      startAt: FUTURE_START(),
+    } as any).then(() => 'resolved').catch((e: any) => `rejected: ${e?.message || e}`)
+
+    const mixedIds = await enduserIdsFor(mixed.journey.id)
+    record(
+      'B2: a mixed list enrolls the visible enduser and drops only the foreign one',
+      mixedIds.includes(own.id) && !mixedIds.includes(victim.id),
+      `call=${mixedResult}; enduserIds=${JSON.stringify(mixedIds)} (want ${own.id}, not ${victim.id})`,
+    )
+  } finally {
+    // Teardown happens here, BEFORE anything asserts — assert calls process.exit and would otherwise
+    // strand these tenants permanently (nothing can delete an organization record).
+    for (const t of [attacker, victimTenant]) {
+      if (t) { try { await t.teardown() } catch (e) { console.error('teardown failed', e) } }
+    }
+  }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export const add_to_journey_foreign_enduserid_tests = async () => {
+  assert_checks('F-0196 add_to_journey foreign enduserId', await add_to_journey_foreign_enduserid_checks())
+}
+
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  add_to_journey_foreign_enduserid_tests()
+    .then(() => {
+      console.log("✅ F-0196 add_to_journey foreign enduserId test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ F-0196 add_to_journey foreign enduserId test suite failed:", error)
+      process.exit(1)
+    })
+}

package/src/tests/api_tests/tickets_bulk_assign_from_queue.test.ts

@@ -0,0 +1,279 @@
+require('source-map-support').install();
+
+import { Session } from "../../sdk"
+import {
+  assert_checks,
+  Check,
+  setup_isolated_tenant,
+} from "../setup_isolated"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * Coverage for `tickets.bulk_assign` when a `queueId` is supplied — the bulk equivalent of
+ * `tickets.assign_from_queue`, added so a Ticket Queue's tickets can be checkbox-selected and handed
+ * to one user in a single call instead of one `assign_from_queue` round trip per ticket.
+ *
+ * Without `queueId` the endpoint only does `$set: { owner }`. That is insufficient for a QUEUED
+ * ticket: it would stay in the queue (still pullable by someone else), carry no dequeue provenance,
+ * and leave `ticket_queues.count` drifting upward forever. The queue branch therefore also unsets
+ * `queueId`, sets `dequeuedAt`/`dequeuedFrom`, and decrements the queue's count — the same
+ * bookkeeping `assign_from_queue` does for a single ticket. A/B/C below pin each of those.
+ *
+ * D is the check that actually justifies the handler's shape. The tickets model declares
+ * `constraints.access: [{ type: 'filter', field: 'owner' }]`, which the DB layer turns into
+ * `owner === self OR creator === self` for any non-`All` access. A queued ticket has no owner, and
+ * was typically created by someone else, so a non-admin queue manager's `DB.tickets.updateMany`
+ * matches NOTHING — the call would return 200 having assigned zero tickets, silently. The handler
+ * uses `buildOrganizationWideQueries` to get past that, exactly as `assign_from_queue` does, and
+ * re-adds the queue-membership check that those queries bypass. D1 proves the escape hatch works for
+ * a legitimate queue member; D2 proves it is still gated, and is the check that fails if someone
+ * later drops the membership check while keeping the organization-wide queries.
+ *
+ * A provisioned non-admin gets `tickets: ASSIGNED_AND_DEFAULT_ACCESS` (read/update = 'Assigned'),
+ * which is what makes D meaningful. The D tickets deliberately have NO enduserId, so the 'Assigned'
+ * role filter's other branch (enduserId in assignedEnduserIds) cannot match either — the ONLY way
+ * they can be assigned is through the organization-wide path.
+ *
+ * E is the regression guard on the pre-existing no-`queueId` behavior, which must be unchanged.
+ *
+ * Cross-tenant (F) is covered because `buildOrganizationWideQueries` is bound to the caller's
+ * businessId: another tenant's queue is invisible even to an admin, who skips the membership check.
+ *
+ * `ticket_queues.count` is maintained by asynchronous side effects (increment on ticket create) and
+ * the decrement here is deliberately fire-and-forget, so every count read polls.
+ */
+
+// count is maintained by async side effects; give it a moment to settle before reading
+const poll_for = async <T,>(get: () => Promise<T>, done: (v: T) => boolean, attempts=20): Promise<T> => {
+  let value = await get()
+  for (let i = 0; i < attempts && !done(value); i++) {
+    await new Promise(resolve => setTimeout(resolve, 250))
+    value = await get()
+  }
+  return value
+}
+
+export const tickets_bulk_assign_from_queue_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
+  let otherTenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
+
+  try {
+    /* ================= fixtures ================= */
+
+    // users[1] joins the queue, users[2] deliberately does not (D2)
+    ;[tenant, otherTenant] = await Promise.all([
+      setup_isolated_tenant({
+        name: `BulkAssignQueue ${RAND()}`,
+        users: [{ isAdmin: true }, { roles: ['Non-Admin'] }, { roles: ['Non-Admin'] }],
+        apiKeys: 0,
+      }),
+      setup_isolated_tenant({
+        name: `BulkAssignQueue other ${RAND()}`,
+        users: [{ isAdmin: true }],
+        apiKeys: 0,
+      }),
+    ])
+
+    const { sdk, sdkNonAdmin } = tenant
+    const queueMember = tenant.users[1]
+    const outsider = tenant.users[2]
+
+    // a session for users[2] — setup_isolated_tenant only builds sessions for users[0] and users[1]
+    const sdkOutsider = new Session({ host, authToken: outsider.authToken })
+    await sdkOutsider.refresh_session()
+
+    const owner = await sdk.api.users.createOne({
+      email: `dontsend-bulk-assign-queue-${RAND()}@tellescope.com`,
+      fname: 'BulkAssign', lname: 'QueueOwner',
+      verifiedEmail: true,
+    })
+
+    const queue = await sdk.api.ticket_queues.createOne({
+      title: `Bulk Assign Queue ${RAND()}`,
+      userIds: [owner.id, queueMember.id], // outsider is NOT a member
+    })
+
+    const enduser = await sdk.api.endusers.createOne({ fname: 'BulkAssign', lname: 'QueuePatient' })
+
+    // A/B/C fixtures — one carries an enduser so care team behavior is exercised alongside dequeue
+    const queued1 = await sdk.api.tickets.createOne({ title: 'BAQ 1', enduserId: enduser.id, queueId: queue.id })
+    const queued2 = await sdk.api.tickets.createOne({ title: 'BAQ 2', queueId: queue.id })
+
+    const countBefore = await poll_for(
+      () => sdk.api.ticket_queues.getOne(queue.id).then(q => q.count ?? 0),
+      c => c === 2,
+    )
+    record(
+      'setup: queue count reflects both queued tickets',
+      countBefore === 2,
+      `count=${countBefore} (want 2); queue=${queue.id}`,
+    )
+
+    /* ===== A: the dequeue bookkeeping ===== */
+
+    const assignResult = await sdk.api.tickets.bulk_assign({
+      ids: [queued1.id, queued2.id], userId: owner.id, queueId: queue.id, addToCareTeam: true,
+    })
+    record(
+      'A1: reports both tickets assigned and none skipped',
+      assignResult.assigned === 2 && assignResult.skipped === 0,
+      `assigned=${assignResult.assigned} skipped=${assignResult.skipped} (want 2 / 0)`,
+    )
+
+    const after1 = await sdk.api.tickets.getOne(queued1.id)
+    record(
+      'A2: ticket left the queue with owner and dequeue provenance set',
+      !after1.queueId && after1.owner === owner.id && !!after1.dequeuedAt && after1.dequeuedFrom === queue.id,
+      `queueId=${JSON.stringify(after1.queueId)} owner=${after1.owner} dequeuedAt=${JSON.stringify(after1.dequeuedAt)} dequeuedFrom=${after1.dequeuedFrom}`,
+    )
+
+    const countAfter = await poll_for(
+      () => sdk.api.ticket_queues.getOne(queue.id).then(q => q.count ?? 0),
+      c => c === 0,
+    )
+    record(
+      'A3: queue count decremented by the number assigned',
+      countAfter === 0,
+      `count=${countAfter} (want 0, was ${countBefore})`,
+    )
+
+    record(
+      'A4: addToCareTeam adds the new owner to the ticket enduser\'s care team',
+      !!(await sdk.api.endusers.getOne(enduser.id)).assignedTo?.includes(owner.id),
+      `assignedTo must contain ${owner.id}`,
+    )
+
+    /* ===== B: ids no longer in the queue are skipped, not re-assigned ===== */
+
+    const replayResult = await sdk.api.tickets.bulk_assign({
+      ids: [queued1.id, queued2.id], userId: owner.id, queueId: queue.id,
+    })
+    record(
+      'B1: already-dequeued ids are reported as skipped',
+      replayResult.assigned === 0 && replayResult.skipped === 2,
+      `assigned=${replayResult.assigned} skipped=${replayResult.skipped} (want 0 / 2)`,
+    )
+
+    const countAfterReplay = await sdk.api.ticket_queues.getOne(queue.id).then(q => q.count ?? 0)
+    record(
+      'B2: queue count is not decremented again when nothing was assigned',
+      countAfterReplay === 0,
+      `count=${countAfterReplay} (want 0 — a decrement here would drive it negative)`,
+    )
+
+    /* ===== C: the queue scope is honored ===== */
+
+    const otherQueue = await sdk.api.ticket_queues.createOne({
+      title: `Bulk Assign Other Queue ${RAND()}`,
+      userIds: [owner.id],
+    })
+    const inOtherQueue = await sdk.api.tickets.createOne({ title: 'BAQ other queue', queueId: otherQueue.id })
+
+    const wrongQueueResult = await sdk.api.tickets.bulk_assign({
+      ids: [inOtherQueue.id], userId: owner.id, queueId: queue.id,
+    })
+    const stillInOther = await sdk.api.tickets.getOne(inOtherQueue.id)
+    record(
+      'C1: a ticket in a different queue is not assigned when the wrong queueId is passed',
+      wrongQueueResult.assigned === 0 && stillInOther.queueId === otherQueue.id && !stillInOther.owner,
+      `assigned=${wrongQueueResult.assigned} (want 0); ticket queueId=${stillInOther.queueId} owner=${JSON.stringify(stillInOther.owner)}`,
+    )
+
+    /* ===== D: the organization-wide path, and its gate ===== */
+
+    // NO enduserId: the 'Assigned' role filter cannot match these by owner, creator, or enduser,
+    // so they are assignable only through the organization-wide queries
+    const forMember1 = await sdk.api.tickets.createOne({ title: 'BAQ member 1', queueId: queue.id })
+    const forMember2 = await sdk.api.tickets.createOne({ title: 'BAQ member 2', queueId: queue.id })
+
+    const memberResult = await sdkNonAdmin.api.tickets.bulk_assign({
+      ids: [forMember1.id, forMember2.id], userId: owner.id, queueId: queue.id,
+    }).then(r => r).catch((e: any) => ({ error: e?.message || String(e) } as any))
+
+    const memberAfter = await sdk.api.tickets.getOne(forMember1.id)
+    record(
+      'D1: a non-admin queue member can bulk assign queued tickets they do not own',
+      memberResult?.assigned === 2 && !memberAfter.queueId && memberAfter.owner === owner.id,
+      `result=${JSON.stringify(memberResult)}; ticket queueId=${JSON.stringify(memberAfter.queueId)} owner=${memberAfter.owner}`
+      + ` — 0 assigned here means the handler fell back to the owner-filtered DB`,
+    )
+
+    const forOutsider = await sdk.api.tickets.createOne({ title: 'BAQ outsider', queueId: queue.id })
+    const outsiderResult = await sdkOutsider.api.tickets.bulk_assign({
+      ids: [forOutsider.id], userId: outsider.id, queueId: queue.id,
+    }).then((r: any) => ({ resolved: r })).catch((e: any) => ({ rejected: e?.message || String(e) }))
+
+    const outsiderAfter = await sdk.api.tickets.getOne(forOutsider.id)
+    record(
+      'D2: a non-admin who is not a member of the queue is rejected',
+      !!(outsiderResult as any).rejected && outsiderAfter.queueId === queue.id && !outsiderAfter.owner,
+      `result=${JSON.stringify(outsiderResult)}; ticket queueId=${outsiderAfter.queueId} owner=${JSON.stringify(outsiderAfter.owner)}`,
+    )
+
+    /* ===== E: regression guard — the no-queueId path is unchanged ===== */
+
+    const stayQueued = await sdk.api.tickets.createOne({ title: 'BAQ not dequeued', queueId: queue.id })
+    const legacyResult = await sdk.api.tickets.bulk_assign({ ids: [stayQueued.id], userId: owner.id })
+    const stayedAfter = await sdk.api.tickets.getOne(stayQueued.id)
+    record(
+      'E1: without queueId the ticket is assigned but NOT dequeued',
+      legacyResult.assigned === 1 && stayedAfter.owner === owner.id
+        && stayedAfter.queueId === queue.id && !stayedAfter.dequeuedAt,
+      `assigned=${legacyResult.assigned}; owner=${stayedAfter.owner} queueId=${stayedAfter.queueId} dequeuedAt=${JSON.stringify(stayedAfter.dequeuedAt)}`,
+    )
+
+    // a ticket already owned by the target user is still "assigned", not counted as skipped
+    const repeatResult = await sdk.api.tickets.bulk_assign({ ids: [stayQueued.id], userId: owner.id })
+    record(
+      'E2: re-assigning to the same owner is not reported as skipped',
+      repeatResult.assigned === 1 && repeatResult.skipped === 0,
+      `assigned=${repeatResult.assigned} skipped=${repeatResult.skipped} (want 1 / 0 — matchedCount, not modifiedCount)`,
+    )
+
+    /* ===== F: another tenant's queue is invisible, even to an admin ===== */
+
+    const foreignResult = await otherTenant.sdk.api.tickets.bulk_assign({
+      ids: [forOutsider.id], userId: otherTenant.users[0].id, queueId: queue.id,
+    }).then((r: any) => ({ resolved: r })).catch((e: any) => ({ rejected: e?.message || String(e) }))
+
+    const foreignAfter = await sdk.api.tickets.getOne(forOutsider.id)
+    record(
+      'F1: another tenant cannot assign tickets out of this tenant\'s queue',
+      (foreignAfter.queueId === queue.id && !foreignAfter.owner)
+        && ((foreignResult as any).rejected || (foreignResult as any).resolved?.assigned === 0),
+      `result=${JSON.stringify(foreignResult)}; ticket queueId=${foreignAfter.queueId} owner=${JSON.stringify(foreignAfter.owner)}`,
+    )
+  } finally {
+    // Teardown BEFORE anything asserts — assert calls process.exit, which would strand these tenants.
+    for (const t of [tenant, otherTenant]) {
+      if (t) { try { await t.teardown() } catch (e) { console.error('teardown failed', e) } }
+    }
+  }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export const tickets_bulk_assign_from_queue_tests = async () => {
+  assert_checks('Tickets bulk assign from queue', await tickets_bulk_assign_from_queue_checks())
+}
+
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  tickets_bulk_assign_from_queue_tests()
+    .then(() => {
+      console.log("✅ Tickets bulk assign from queue test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ Tickets bulk assign from queue test suite failed:", error)
+      process.exit(1)
+    })
+}

package/src/tests/setup_isolated.ts

@@ -0,0 +1,170 @@
+import axios from "axios"
+
+import { assert, log_header } from "@tellescope/testing"
+
+import { Session } from "../sdk"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+/**
+ * Provisions a throwaway tenant for a test, via the API's /test-support endpoints.
+ *
+ * Why this exists alongside setup.ts: setup_tests authenticates two hand-seeded users named by
+ * TEST_EMAIL / NON_ADMIN_EMAIL against a hardcoded businessId, so running the suite requires a copy
+ * of someone's local database, and every test shares one tenant. This helper needs **no environment
+ * configuration at all** against a local API — clone, empty Mongo, run.
+ *
+ * setup.ts is deliberately untouched; existing tests keep the shared org. Use this for new tests.
+ *
+ * Isolated tests must NOT call sdk.reset_db(): it clears six global throttle namespaces, so it
+ * disturbs the rate-limit state of any concurrently running suite even though record data is
+ * tenant-scoped.
+ */
+
+const TEST_SUPPORT_HEADER = 'x-tellescope-test-support'
+
+export type IsolatedUser = {
+  id: string,
+  email: string,
+  password: string,
+  authToken: string,
+  roles: string[],
+}
+
+export type IsolatedTenant = {
+  businessId: string,
+  subdomain: string,
+  users: IsolatedUser[],
+  apiKeys: string[],
+  roles: string[],
+  /** Admin session (users[0]) */
+  sdk: Session,
+  /** Non-admin session (users[1]), when the spec provisioned one */
+  sdkNonAdmin: Session,
+  teardown: () => Promise<void>,
+}
+
+export type IsolatedTenantSpec = {
+  name?: string,
+  users?: { roles?: string[], isAdmin?: boolean }[],
+  apiKeys?: number,
+  roles?: { role: string, permissions?: any }[],
+}
+
+const post = async (path: string, body: object) => {
+  const r = await axios.request({
+    method: 'post',
+    url: `${host}/test-support${path}`,
+    // forwarded only if present — required on staging, unnecessary (and unset) locally
+    data: { ...body, ...(process.env.SERVICES_SECRET ? { servicesSecret: process.env.SERVICES_SECRET } : {}) },
+    headers: { [TEST_SUPPORT_HEADER]: '1' },
+    validateStatus: () => true,
+  })
+
+  if (r.status !== 200) {
+    // Surface the server's reason. setup.ts's bare process.exit() on missing credentials turns a
+    // misconfiguration into a silent green pass; a provisioning failure must be loud.
+    throw new Error(
+      `test-support ${path} failed (${r.status}): ${JSON.stringify(r.data)}`
+      + (r.status === 404
+        ? `\nThe route is not mounted — LOCAL is probably not "true" in the API's environment.`
+        : '')
+    )
+  }
+  return r.data
+}
+
+export const setup_isolated_tenant = async (spec: IsolatedTenantSpec = {}): Promise<IsolatedTenant> => {
+  const tenant = await post('/provision-tenant', spec)
+
+  const sessionFor = async (user?: IsolatedUser) => {
+    if (!user) return new Session({ host })
+    const session = new Session({ host, authToken: user.authToken })
+    await session.refresh_session()
+    return session
+  }
+
+  const [sdk, sdkNonAdmin] = await Promise.all([
+    sessionFor(tenant.users[0]),
+    sessionFor(tenant.users[1]),
+  ])
+
+  return {
+    ...tenant,
+    sdk,
+    sdkNonAdmin,
+    teardown: async () => { await post('/teardown-tenant', { businessId: tenant.businessId }) },
+  }
+}
+
+/** Sets the pending email-verification code for an unverified user, so a test can drive the real
+ *  submit_email_verification endpoint. The address must be a `dontsend...@tellescope.com` one. */
+export const set_email_verification_code = async (email: string, code: string) => (
+  post('/set-email-verification-code', { email, code })
+)
+
+/** Raw access, for tests that need to assert on the response of a rejected call. */
+export const test_support_request = async (path: string, body: object) => {
+  const r = await axios.request({
+    method: 'post',
+    url: `${host}/test-support${path}`,
+    data: { ...body, ...(process.env.SERVICES_SECRET ? { servicesSecret: process.env.SERVICES_SECRET } : {}) },
+    headers: { [TEST_SUPPORT_HEADER]: '1' },
+    validateStatus: () => true,
+  })
+  return { status: r.status, body: r.data }
+}
+
+/* ============================ isolated-test result plumbing ============================ */
+
+export type Check = { label: string, pass: boolean, detail: string }
+
+/** Prints a suite's evidence table, then asserts. Split out so the assert phase can be deferred until
+ *  after every concurrent suite has torn down — see run_isolated_in_parallel. */
+export const assert_checks = (name: string, checks: Check[]) => {
+  console.log(`\n  ${name} check summary:`)
+  for (const c of checks) {
+    console.log(`    ${c.pass ? 'PASS' : 'FAIL'}  ${c.label}  —  ${c.detail}`)
+  }
+  console.log('')
+
+  for (const c of checks) {
+    assert(c.pass, `${c.label} — ${c.detail}`, c.label)
+  }
+}
+
+/**
+ * Runs isolated test bodies CONCURRENTLY.
+ *
+ * Why this exists rather than a bare Promise.all: the harness's `assert` calls process.exit(1) on
+ * failure, and process.exit does not run pending `finally` blocks. So if one suite asserted while
+ * another was still in flight, the other's teardown would never run and its provisioned tenants would
+ * be stranded permanently (nothing in the system can delete an organization record). `assert` also
+ * exits rather than throwing, so Promise.allSettled cannot recover it either.
+ *
+ * The contract that makes concurrency safe: each `run` collects Check[] and tears down its OWN tenants
+ * in a finally, and never asserts. Nothing here asserts until every suite has settled.
+ *
+ * Each suite's table prints as one non-yielding burst, so concurrent output stays readable.
+ */
+export const run_isolated_in_parallel = async (
+  suites: { name: string, run: () => Promise<Check[]> }[],
+) => {
+  log_header(`Isolated (parallel): ${suites.map(s => s.name).join(' | ')}`)
+
+  const settled = await Promise.allSettled(suites.map(s => s.run()))
+
+  // Surface an infrastructure failure (a throw, not a failed check) before asserting anything, so the
+  // reason isn't buried under another suite's table.
+  const rejected = settled.flatMap((r, i) => r.status === 'rejected' ? [{ name: suites[i].name, reason: r.reason }] : [])
+  for (const { name, reason } of rejected) {
+    console.error(`  ${name} threw before producing checks:`, reason)
+  }
+  if (rejected.length) throw rejected[0].reason
+
+  for (let i = 0; i < settled.length; i++) {
+    const r = settled[i]
+    if (r.status !== 'fulfilled') continue
+    assert_checks(suites[i].name, r.value)
+  }
+}