@open-mercato/ai-assistant 0.6.5-develop.4516.1.88e6ab71a9 → 0.6.5-develop.4534.1.b459babe6d

package/src/modules/ai_assistant/__integration__/TC-AI-PARTICIPANTS-002-add-remove-participants.spec.ts

@@ -0,0 +1,184 @@
+import { test, expect } from '@playwright/test';
+import { randomUUID } from 'node:crypto';
+import { apiRequest, getAuthToken } from '@open-mercato/core/helpers/integration/api';
+import {
+  createRoleFixture,
+  deleteRoleIfExists,
+  createUserFixture,
+  deleteUserIfExists,
+  setUserAclVisibility,
+} from '@open-mercato/core/helpers/integration/authFixtures';
+import {
+  createOrganizationInDb,
+  deleteOrganizationInDb,
+  deleteUserAclInDb,
+} from '@open-mercato/core/helpers/integration/dbFixtures';
+import { getTokenScope, readJsonSafe } from '@open-mercato/core/helpers/integration/generalFixtures';
+import { deleteConversationCascadeInDb } from './helpers/aiAssistantFixtures';
+
+/**
+ * TC-AI-PARTICIPANTS-002 — Conversation participants (add / list / remove).
+ * Source: GitHub issue #2495.
+ *
+ * Surfaces under test:
+ *   - /api/ai_assistant/ai/conversations/{id}/participants            (POST, GET)
+ *   - /api/ai_assistant/ai/conversations/{id}/participants/{userId}    (DELETE)
+ *
+ * Contract notes verified against the route handlers:
+ *   - add requires `ai_assistant.conversations.share`; only the owner may add.
+ *   - the only wire role is `viewer` (the owner row is implicit).
+ *   - add returns 201 `{ participant: { userId, role, lastReadAt, addedAt } }`.
+ *   - removing a participant returns 204; removing the OWNER is 403; a missing
+ *     participant is 404 `participant_not_found`.
+ *   - self-add is 400 `self_share_not_allowed`; a duplicate is 409
+ *     `duplicate_participant`; a target in another org is 400 `user_not_found`.
+ */
+
+const CONVERSATIONS = '/api/ai_assistant/ai/conversations';
+
+interface ParticipantRow {
+  userId: string;
+  role: string;
+  lastReadAt: string | null;
+  addedAt: string;
+}
+
+test.describe('TC-AI-PARTICIPANTS-002: Conversation participants', () => {
+  test('add -> list -> remove lifecycle plus owner/duplicate/self/cross-org/RBAC guards', async ({ request }) => {
+    test.slow();
+    const adminToken = await getAuthToken(request, 'admin');
+    const { tenantId, organizationId: orgAId, userId: ownerId } = getTokenScope(adminToken);
+    const stamp = randomUUID().slice(0, 8);
+    const password = 'Secret123!';
+    const agentId = `it_part.agent_${stamp}`;
+    const conversationId = `it-part-${randomUUID()}`;
+
+    let roleId: string | null = null;
+    let memberId: string | null = null;
+    let foreignOrgId: string | null = null;
+    let foreignUserId: string | null = null;
+    try {
+      roleId = await createRoleFixture(request, adminToken, { name: `IT Part Role ${stamp}` });
+      // Member lives in the SAME org as the owner and carries only view -> valid
+      // share target AND a deterministic "lacks conversations.share" caller.
+      memberId = await createUserFixture(request, adminToken, {
+        email: `it-part-member-${stamp}@example.com`,
+        password,
+        organizationId: orgAId,
+        roles: [roleId],
+      });
+      await setUserAclVisibility(request, adminToken, {
+        userId: memberId,
+        features: ['ai_assistant.view'],
+        organizations: [orgAId],
+      });
+      // Foreign user lives in another org -> cannot be shared into this conversation.
+      foreignOrgId = await createOrganizationInDb({ name: `IT Part OrgB ${stamp}`, tenantId });
+      foreignUserId = await createUserFixture(request, adminToken, {
+        email: `it-part-foreign-${stamp}@example.com`,
+        password,
+        organizationId: foreignOrgId,
+        roles: [roleId],
+      });
+
+      const createRes = await apiRequest(request, 'POST', CONVERSATIONS, {
+        token: adminToken,
+        data: { agentId, conversationId, title: 'Shareable conversation' },
+      });
+      expect(createRes.status()).toBe(201);
+
+      const participantsPath = `${CONVERSATIONS}/${encodeURIComponent(conversationId)}/participants`;
+
+      // Add member -> 201 viewer
+      const addRes = await apiRequest(request, 'POST', participantsPath, {
+        token: adminToken,
+        data: { userId: memberId },
+      });
+      expect(addRes.status(), 'add participant returns 201').toBe(201);
+      const added = await readJsonSafe<{ participant: ParticipantRow }>(addRes);
+      expect(added?.participant.userId).toBe(memberId);
+      expect(added?.participant.role).toBe('viewer');
+
+      // List -> owner + member
+      const listRes = await apiRequest(request, 'GET', participantsPath, { token: adminToken });
+      expect(listRes.status()).toBe(200);
+      const list = await readJsonSafe<{ ownerUserId: string; participants: ParticipantRow[] }>(listRes);
+      expect(list?.ownerUserId).toBe(ownerId);
+      expect(list?.participants.some((p) => p.userId === ownerId && p.role === 'owner')).toBe(true);
+      expect(list?.participants.some((p) => p.userId === memberId && p.role === 'viewer')).toBe(true);
+
+      // Self-add -> 400 self_share_not_allowed
+      const selfAdd = await apiRequest(request, 'POST', participantsPath, {
+        token: adminToken,
+        data: { userId: ownerId },
+      });
+      expect(selfAdd.status()).toBe(400);
+      expect((await readJsonSafe<{ code?: string }>(selfAdd))?.code).toBe('self_share_not_allowed');
+
+      // Duplicate -> 409 duplicate_participant
+      const dup = await apiRequest(request, 'POST', participantsPath, {
+        token: adminToken,
+        data: { userId: memberId },
+      });
+      expect(dup.status()).toBe(409);
+      expect((await readJsonSafe<{ code?: string }>(dup))?.code).toBe('duplicate_participant');
+
+      // Foreign-org target -> 400 user_not_found
+      const foreign = await apiRequest(request, 'POST', participantsPath, {
+        token: adminToken,
+        data: { userId: foreignUserId },
+      });
+      expect(foreign.status()).toBe(400);
+      expect((await readJsonSafe<{ code?: string }>(foreign))?.code).toBe('user_not_found');
+
+      // Caller lacking conversations.share -> 403 (feature gate fires first)
+      const memberToken = await getAuthToken(request, `it-part-member-${stamp}@example.com`, password);
+      const denied = await apiRequest(request, 'POST', participantsPath, {
+        token: memberToken,
+        data: { userId: randomUUID() },
+      });
+      expect(denied.status(), 'caller without conversations.share is 403').toBe(403);
+
+      // Remove the OWNER -> 403
+      const removeOwner = await apiRequest(
+        request,
+        'DELETE',
+        `${participantsPath}/${encodeURIComponent(ownerId)}`,
+        { token: adminToken },
+      );
+      expect(removeOwner.status(), 'cannot revoke the owner').toBe(403);
+
+      // Remove the member -> 204
+      const removeMember = await apiRequest(
+        request,
+        'DELETE',
+        `${participantsPath}/${encodeURIComponent(memberId)}`,
+        { token: adminToken },
+      );
+      expect(removeMember.status(), 'revoke participant returns 204').toBe(204);
+
+      // List -> member gone
+      const listAfter = await apiRequest(request, 'GET', participantsPath, { token: adminToken });
+      expect(listAfter.status()).toBe(200);
+      const after = await readJsonSafe<{ participants: ParticipantRow[] }>(listAfter);
+      expect(after?.participants.some((p) => p.userId === memberId)).toBe(false);
+
+      // Remove again -> 404 participant_not_found
+      const removeAgain = await apiRequest(
+        request,
+        'DELETE',
+        `${participantsPath}/${encodeURIComponent(memberId)}`,
+        { token: adminToken },
+      );
+      expect(removeAgain.status()).toBe(404);
+      expect((await readJsonSafe<{ code?: string }>(removeAgain))?.code).toBe('participant_not_found');
+    } finally {
+      await deleteConversationCascadeInDb({ tenantId, conversationId }).catch(() => undefined);
+      await deleteUserAclInDb(memberId ?? '').catch(() => undefined);
+      await deleteUserIfExists(request, adminToken, memberId);
+      await deleteUserIfExists(request, adminToken, foreignUserId);
+      await deleteRoleIfExists(request, adminToken, roleId);
+      await deleteOrganizationInDb(foreignOrgId).catch(() => undefined);
+    }
+  });
+});

package/src/modules/ai_assistant/__integration__/TC-AI-SESSION-KEY-006-create-session-token.spec.ts

@@ -0,0 +1,95 @@
+import { test, expect, request as playwrightRequest } from '@playwright/test';
+import { randomUUID } from 'node:crypto';
+import { apiRequest, getAuthToken } from '@open-mercato/core/helpers/integration/api';
+import {
+  createRoleFixture,
+  deleteRoleIfExists,
+  createUserFixture,
+  deleteUserIfExists,
+  setUserAclVisibility,
+} from '@open-mercato/core/helpers/integration/authFixtures';
+import { deleteUserAclInDb } from '@open-mercato/core/helpers/integration/dbFixtures';
+import { getTokenScope, readJsonSafe } from '@open-mercato/core/helpers/integration/generalFixtures';
+
+/**
+ * TC-AI-SESSION-KEY-006 — Session key generation.
+ * Source: GitHub issue #2495.
+ *
+ * Surface under test:
+ *   - /api/ai_assistant/session-key   (POST)
+ *
+ * Contract notes verified against the route handler (the issue's guesses were wrong):
+ *   - the response body is EXACTLY `{ sessionToken, expiresAt }` — it does NOT
+ *     include userId / tenantId / organizationId.
+ *   - token format is `sess_` + 32 lowercase hex chars; TTL is 120 minutes.
+ *   - requires `ai_assistant.view`; unauthenticated -> 401; missing feature -> 403.
+ *
+ * NOTE: the returned `sess_...` token is consumed only as the MCP `_sessionToken`
+ * tool-call argument — it is NOT accepted by the Next.js HTTP auth resolver as a
+ * Bearer/header, so the issue's "use the token to call /tools" step is invalid
+ * and intentionally omitted here.
+ */
+
+const SESSION_KEY = '/api/ai_assistant/session-key';
+const SESSION_TOKEN_RE = /^sess_[0-9a-f]{32}$/;
+const TTL_MINUTES = 120;
+
+test.describe('TC-AI-SESSION-KEY-006: Session key generation', () => {
+  test('POST mints a unique sess_ token with a ~120 minute TTL', async ({ request }) => {
+    const adminToken = await getAuthToken(request, 'admin');
+
+    const first = await apiRequest(request, 'POST', SESSION_KEY, { token: adminToken, data: {} });
+    expect(first.status(), 'session-key POST returns 200').toBe(200);
+    const body = await readJsonSafe<{ sessionToken: string; expiresAt: string }>(first);
+    expect(body?.sessionToken).toMatch(SESSION_TOKEN_RE);
+
+    const now = Date.now();
+    const expiresAt = Date.parse(body!.expiresAt);
+    expect(Number.isNaN(expiresAt)).toBe(false);
+    // Allow generous slop for clock + request latency around the 120-minute TTL.
+    expect(expiresAt).toBeGreaterThan(now + (TTL_MINUTES - 5) * 60 * 1000);
+    expect(expiresAt).toBeLessThan(now + (TTL_MINUTES + 5) * 60 * 1000);
+
+    const second = await apiRequest(request, 'POST', SESSION_KEY, { token: adminToken, data: {} });
+    expect(second.status()).toBe(200);
+    const secondBody = await readJsonSafe<{ sessionToken: string }>(second);
+    expect(secondBody?.sessionToken).toMatch(SESSION_TOKEN_RE);
+    expect(secondBody?.sessionToken, 'each call mints a distinct token').not.toBe(body?.sessionToken);
+  });
+
+  test('auth gates: unauthenticated 401 and missing ai_assistant.view 403', async ({ request, baseURL }) => {
+    test.slow();
+    const adminToken = await getAuthToken(request, 'admin');
+    const { organizationId } = getTokenScope(adminToken);
+    const stamp = randomUUID().slice(0, 8);
+    const password = 'Secret123!';
+
+    const anon = await playwrightRequest.newContext({ baseURL });
+    try {
+      const res = await anon.fetch(SESSION_KEY, { method: 'POST', data: '{}' });
+      expect(res.status(), 'unauthenticated POST is 401').toBe(401);
+    } finally {
+      await anon.dispose();
+    }
+
+    let roleId: string | null = null;
+    let userId: string | null = null;
+    try {
+      roleId = await createRoleFixture(request, adminToken, { name: `IT Session Role ${stamp}` });
+      userId = await createUserFixture(request, adminToken, {
+        email: `it-session-${stamp}@example.com`,
+        password,
+        organizationId,
+        roles: [roleId],
+      });
+      await setUserAclVisibility(request, adminToken, { userId, features: [], organizations: null });
+      const viewlessToken = await getAuthToken(request, `it-session-${stamp}@example.com`, password);
+      const denied = await apiRequest(request, 'POST', SESSION_KEY, { token: viewlessToken, data: {} });
+      expect(denied.status(), 'caller without ai_assistant.view is 403').toBe(403);
+    } finally {
+      await deleteUserAclInDb(userId ?? '').catch(() => undefined);
+      await deleteUserIfExists(request, adminToken, userId);
+      await deleteRoleIfExists(request, adminToken, roleId);
+    }
+  });
+});

package/src/modules/ai_assistant/__integration__/TC-AI-SETTINGS-ALLOWLIST-003-put-delete-allowlist.spec.ts

@@ -0,0 +1,115 @@
+import { test, expect, request as playwrightRequest } from '@playwright/test';
+import { apiRequest, getAuthToken } from '@open-mercato/core/helpers/integration/api';
+import { getTokenScope, readJsonSafe } from '@open-mercato/core/helpers/integration/generalFixtures';
+import { deleteTenantAllowlistInDb } from './helpers/aiAssistantFixtures';
+
+/**
+ * TC-AI-SETTINGS-ALLOWLIST-003 — Tenant model allowlist (PUT/DELETE) + settings reflection.
+ * Source: GitHub issue #2495.
+ *
+ * Surfaces under test:
+ *   - /api/ai_assistant/settings/allowlist   (PUT, DELETE)
+ *   - /api/ai_assistant/settings             (GET — reflects the snapshot)
+ *
+ * Contract notes verified against the route handlers:
+ *   - PUT body fields are `allowedProviders` / `allowedModelsByProvider`
+ *     (NOT `providers` / `models`); success is 200 returning the saved snapshot.
+ *   - DELETE returns 200 `{ cleared: boolean }` and is idempotent
+ *     (`cleared: false` when no active row exists).
+ *   - GET /settings exposes `tenantAllowlist` (null when unset) + `effectiveAllowlist`.
+ *   - PUT/DELETE require `ai_assistant.settings.manage`.
+ *
+ * Out of scope (documented): the `provider_not_in_env_allowlist` 400 branch only
+ * fires when the APP process has `OM_AI_AVAILABLE_PROVIDERS` set to exclude the
+ * provider. The deterministic harness does not control the app's env, so that
+ * branch is covered by the module's unit tests; here we assert the env-agnostic
+ * Zod validation (wrong type -> 400 validation_error) instead.
+ */
+
+const ALLOWLIST = '/api/ai_assistant/settings/allowlist';
+const SETTINGS = '/api/ai_assistant/settings';
+
+interface TenantAllowlistSnapshot {
+  allowedProviders: string[] | null;
+  allowedModelsByProvider: Record<string, string[]>;
+}
+
+test.describe('TC-AI-SETTINGS-ALLOWLIST-003: Tenant model allowlist', () => {
+  test('PUT persists, GET reflects, DELETE clears + is idempotent', async ({ request }) => {
+    test.slow();
+    const adminToken = await getAuthToken(request, 'admin');
+    const { tenantId } = getTokenScope(adminToken);
+    try {
+      // Start from a known-clean state.
+      const reset = await apiRequest(request, 'DELETE', ALLOWLIST, { token: adminToken });
+      expect(reset.status()).toBe(200);
+
+      const settingsBefore = await apiRequest(request, 'GET', SETTINGS, { token: adminToken });
+      expect(settingsBefore.status()).toBe(200);
+      const before = await readJsonSafe<{ tenantAllowlist: TenantAllowlistSnapshot | null; effectiveAllowlist: unknown }>(
+        settingsBefore,
+      );
+      expect(before?.tenantAllowlist).toBeNull();
+      expect(before?.effectiveAllowlist).toBeTruthy();
+
+      const put = await apiRequest(request, 'PUT', ALLOWLIST, {
+        token: adminToken,
+        data: { allowedProviders: ['openai'], allowedModelsByProvider: { openai: ['gpt-5-mini'] } },
+      });
+      expect(put.status(), 'PUT allowlist returns 200').toBe(200);
+      const saved = await readJsonSafe<TenantAllowlistSnapshot>(put);
+      expect(saved?.allowedProviders).toContain('openai');
+      expect(saved?.allowedModelsByProvider?.openai).toContain('gpt-5-mini');
+
+      const settingsAfter = await apiRequest(request, 'GET', SETTINGS, { token: adminToken });
+      expect(settingsAfter.status()).toBe(200);
+      const after = await readJsonSafe<{ tenantAllowlist: TenantAllowlistSnapshot | null }>(settingsAfter);
+      expect(after?.tenantAllowlist?.allowedProviders).toContain('openai');
+
+      const del = await apiRequest(request, 'DELETE', ALLOWLIST, { token: adminToken });
+      expect(del.status()).toBe(200);
+      expect((await readJsonSafe<{ cleared: boolean }>(del))?.cleared).toBe(true);
+
+      const settingsCleared = await apiRequest(request, 'GET', SETTINGS, { token: adminToken });
+      const cleared = await readJsonSafe<{ tenantAllowlist: TenantAllowlistSnapshot | null }>(settingsCleared);
+      expect(cleared?.tenantAllowlist).toBeNull();
+
+      const delAgain = await apiRequest(request, 'DELETE', ALLOWLIST, { token: adminToken });
+      expect(delAgain.status()).toBe(200);
+      expect((await readJsonSafe<{ cleared: boolean }>(delAgain))?.cleared, 'DELETE is idempotent').toBe(false);
+    } finally {
+      await deleteTenantAllowlistInDb(tenantId).catch(() => undefined);
+    }
+  });
+
+  test('validation + RBAC gates: bad body 400, employee 403, unauthenticated 401', async ({ request, baseURL }) => {
+    const adminToken = await getAuthToken(request, 'admin');
+
+    const badType = await apiRequest(request, 'PUT', ALLOWLIST, {
+      token: adminToken,
+      data: { allowedProviders: 123 },
+    });
+    expect(badType.status()).toBe(400);
+    expect((await readJsonSafe<{ code?: string }>(badType))?.code).toBe('validation_error');
+
+    // Employee carries ai_assistant.view but NOT ai_assistant.settings.manage.
+    const employeeToken = await getAuthToken(request, 'employee');
+    const denied = await apiRequest(request, 'PUT', ALLOWLIST, {
+      token: employeeToken,
+      data: { allowedProviders: ['openai'] },
+    });
+    expect(denied.status(), 'employee lacks settings.manage -> 403').toBe(403);
+
+    const anon = await playwrightRequest.newContext({ baseURL });
+    try {
+      const res = await anon.fetch(ALLOWLIST, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        data: JSON.stringify({ allowedProviders: ['openai'] }),
+      });
+      expect(res.status(), 'unauthenticated PUT is 401').toBe(401);
+    } finally {
+      await anon.dispose();
+    }
+  });
+});

package/src/modules/ai_assistant/__integration__/TC-AI-TOOLS-EXECUTE-007-direct-tool-execution.spec.ts

@@ -0,0 +1,97 @@
+import { test, expect, request as playwrightRequest } from '@playwright/test';
+import { apiRequest, getAuthToken } from '@open-mercato/core/helpers/integration/api';
+import { readJsonSafe } from '@open-mercato/core/helpers/integration/generalFixtures';
+
+/**
+ * TC-AI-TOOLS-EXECUTE-007 — Direct tool execution + tool listing.
+ * Source: GitHub issue #2495.
+ *
+ * Surfaces under test:
+ *   - /api/ai_assistant/tools          (GET)
+ *   - /api/ai_assistant/tools/execute   (POST)
+ *
+ * Contract notes verified against the route handlers (the issue's guesses were wrong):
+ *   - execute body fields are `toolName` + `args` (NOT `name` / `input`);
+ *     success is 200 `{ success: true, result }`.
+ *   - a missing `toolName` -> 400 `{ error: 'toolName is required' }`.
+ *   - an unknown tool -> 400 `{ success: false, error: 'Tool "<n>" not found' }`
+ *     (NOT a typed `code`; the errorCode only selects 400 vs 403 internally).
+ *   - both routes require `ai_assistant.view`; the per-tool `requiredFeatures` are
+ *     enforced separately inside the executor.
+ */
+
+const TOOLS = '/api/ai_assistant/tools';
+const EXECUTE = '/api/ai_assistant/tools/execute';
+
+interface ToolSummary {
+  name: string;
+  description: string;
+  inputSchema: { required?: unknown } & Record<string, unknown>;
+  module: string;
+}
+
+test.describe('TC-AI-TOOLS-EXECUTE-007: Direct tool execution', () => {
+  test('list tools, validate + reject unknown tools, and exercise a no-arg tool', async ({ request }) => {
+    test.slow();
+    const adminToken = await getAuthToken(request, 'admin');
+
+    const listRes = await apiRequest(request, 'GET', TOOLS, { token: adminToken });
+    expect(listRes.status()).toBe(200);
+    const list = await readJsonSafe<{ tools: ToolSummary[] }>(listRes);
+    expect(Array.isArray(list?.tools)).toBe(true);
+    expect((list?.tools.length ?? 0) > 0, 'at least one tool is visible to admin').toBe(true);
+    const sample = list!.tools[0];
+    expect(typeof sample.name).toBe('string');
+    expect(typeof sample.inputSchema).toBe('object');
+
+    // Missing toolName -> 400 with the route-level message.
+    const missing = await apiRequest(request, 'POST', EXECUTE, { token: adminToken, data: {} });
+    expect(missing.status()).toBe(400);
+    expect((await readJsonSafe<{ error?: string }>(missing))?.error).toBe('toolName is required');
+
+    // Unknown tool -> 400 { success: false, error: '... not found' }.
+    const unknown = await apiRequest(request, 'POST', EXECUTE, {
+      token: adminToken,
+      data: { toolName: 'does.not_exist_tool', args: {} },
+    });
+    expect(unknown.status()).toBe(400);
+    const unknownBody = await readJsonSafe<{ success?: boolean; error?: string }>(unknown);
+    expect(unknownBody?.success).toBe(false);
+    expect(unknownBody?.error ?? '').toContain('not found');
+
+    // Best-effort happy path: a tool whose input schema has no required fields can
+    // be invoked with empty args. The execute route runs the handler and returns
+    // 200 `{ success }`; assert the envelope only when such a tool is available.
+    const noArgTool = list!.tools.find((tool) => {
+      const required = tool.inputSchema?.required;
+      return !Array.isArray(required) || required.length === 0;
+    });
+    if (noArgTool) {
+      const exec = await apiRequest(request, 'POST', EXECUTE, {
+        token: adminToken,
+        data: { toolName: noArgTool.name, args: {} },
+      });
+      // A 200 from the execute route always carries `success: true` (only a
+      // thrown handler yields 400 `{ success: false }`), so assert the real
+      // value rather than mere presence. A no-arg tool that rejects empty input
+      // legitimately returns 400, which this guard intentionally tolerates.
+      if (exec.status() === 200) {
+        expect((await readJsonSafe<{ success?: boolean }>(exec))?.success).toBe(true);
+      }
+    }
+  });
+
+  test('unauthenticated execute is rejected with 401', async ({ baseURL }) => {
+    const anon = await playwrightRequest.newContext({ baseURL });
+    try {
+      const res = await anon.fetch(EXECUTE, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        data: JSON.stringify({ toolName: 'does.not_exist_tool', args: {} }),
+      });
+      expect(res.status()).toBe(401);
+    } finally {
+      await anon.dispose();
+    }
+  });
+});