@open-mercato/ai-assistant 0.5.1-develop.3036.f02c281f23 → 0.5.1-develop.3045.b4b3320cc2

package/src/modules/ai_assistant/api/ai/actions/[id]/route.ts

@@ -0,0 +1,142 @@
+import { NextResponse, type NextRequest } from 'next/server'
+import { z } from 'zod'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import type { RbacService } from '@open-mercato/core/modules/auth/services/rbacService'
+import { AiPendingActionRepository } from '../../../../data/repositories/AiPendingActionRepository'
+import { hasRequiredFeatures } from '../../../../lib/auth'
+import { serializePendingActionForClient } from '../../../../lib/pending-action-client'
+
+/**
+ * GET `/api/ai/actions/:id` — reconnect/polling endpoint for the Phase 3 WS-C
+ * mutation approval gate (spec §9, Step 5.7).
+ *
+ * When the chat UI bounces (reload, tab switch, SSE reconnect) it carries a
+ * `pendingActionId` from an earlier `mutation-preview-card` UI part and needs
+ * to re-hydrate the pending row's current state. This route is the authoritative
+ * read-side; the confirm/cancel routes (Steps 5.8 / 5.9) use the same
+ * whitelist serializer so the UI always sees the same shape.
+ */
+
+const REQUIRED_FEATURE = 'ai_assistant.view'
+
+const idParamSchema = z.object({
+  id: z
+    .string()
+    .trim()
+    .min(1, 'id must be a non-empty string')
+    .max(128, 'id exceeds the maximum length of 128 characters'),
+})
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'AI Assistant',
+  summary: 'Pending action (mutation approval gate) read-side',
+  methods: {
+    GET: {
+      operationId: 'aiAssistantGetPendingAction',
+      summary: 'Fetch the current state of an AI pending action by id.',
+      description:
+        'Returns the tenant-scoped {@link AiPendingAction} addressed by `:id`. Powers the ' +
+        'chat UI reconnect/polling path: after a page reload or SSE reconnect the client ' +
+        'carries the `pendingActionId` from an earlier `mutation-preview-card` UI part and ' +
+        'calls this route to re-hydrate the card. Server-internal fields (`normalizedInput`, ' +
+        '`createdByUserId`, `idempotencyKey`) are stripped by a whitelist serializer. ' +
+        'Enforces tenant/org scoping via the repository.',
+      responses: [
+        {
+          status: 200,
+          description:
+            'Serialized pending action. Never includes normalizedInput, createdByUserId, or idempotencyKey.',
+          mediaType: 'application/json',
+        },
+      ],
+      errors: [
+        { status: 401, description: 'Unauthenticated caller.' },
+        { status: 403, description: 'Caller lacks the `ai_assistant.view` feature.' },
+        { status: 404, description: 'No pending action with the given id is accessible to the caller.' },
+        { status: 500, description: 'Internal runtime failure.' },
+      ],
+    },
+  },
+}
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: [REQUIRED_FEATURE] },
+}
+
+interface RouteContext {
+  params: Promise<{ id: string }>
+}
+
+function jsonError(
+  status: number,
+  message: string,
+  code: string,
+  extra?: Record<string, unknown>,
+): NextResponse {
+  return NextResponse.json({ error: message, code, ...(extra ?? {}) }, { status })
+}
+
+export async function GET(req: NextRequest, context: RouteContext): Promise<Response> {
+  const auth = await getAuthFromRequest(req)
+  if (!auth) {
+    return jsonError(401, 'Unauthorized', 'unauthenticated')
+  }
+
+  const rawParams = await context.params
+  const paramResult = idParamSchema.safeParse(rawParams)
+  if (!paramResult.success) {
+    return jsonError(400, 'Invalid pending action id.', 'validation_error', {
+      issues: paramResult.error.issues,
+    })
+  }
+  const pendingActionId = paramResult.data.id
+
+  try {
+    const container = await createRequestContainer()
+    const rbacService = container.resolve<RbacService>('rbacService')
+    const acl = await rbacService.loadAcl(auth.sub, {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId,
+    })
+
+    if (!hasRequiredFeatures([REQUIRED_FEATURE], acl.features, acl.isSuperAdmin, rbacService)) {
+      return jsonError(403, `Caller lacks required feature "${REQUIRED_FEATURE}".`, 'forbidden')
+    }
+
+    if (!auth.tenantId) {
+      return jsonError(
+        404,
+        `No pending action "${pendingActionId}" accessible to the caller.`,
+        'pending_action_not_found',
+      )
+    }
+
+    const em = container.resolve<EntityManager>('em')
+    const repo = new AiPendingActionRepository(em)
+    const row = await repo.getById(pendingActionId, {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId ?? null,
+      userId: auth.sub,
+    })
+
+    if (!row) {
+      return jsonError(
+        404,
+        `No pending action "${pendingActionId}" accessible to the caller.`,
+        'pending_action_not_found',
+      )
+    }
+
+    return NextResponse.json(serializePendingActionForClient(row))
+  } catch (error) {
+    console.error('[AI Pending Action GET] Failure:', error)
+    return jsonError(
+      500,
+      error instanceof Error ? error.message : 'Failed to load pending action.',
+      'internal_error',
+    )
+  }
+}

package/src/modules/ai_assistant/api/ai/agents/[agentId]/mutation-policy/__tests__/route.test.ts

@@ -0,0 +1,367 @@
+import type { AiAgentDefinition } from '../../../../../../lib/ai-agent-definition'
+import {
+  resetAgentRegistryForTests,
+  seedAgentRegistryForTests,
+} from '../../../../../../lib/agent-registry'
+
+const authMock = jest.fn()
+const loadAclMock = jest.fn()
+const createRequestContainerMock = jest.fn()
+const repoGetMock = jest.fn()
+const repoSetMock = jest.fn()
+const repoClearMock = jest.fn()
+
+jest.mock('@open-mercato/shared/lib/auth/server', () => ({
+  getAuthFromRequest: (...args: unknown[]) => authMock(...args),
+}))
+
+jest.mock('@open-mercato/shared/lib/di/container', () => ({
+  createRequestContainer: (...args: unknown[]) => createRequestContainerMock(...args),
+}))
+
+jest.mock('../../../../../../data/repositories/AiAgentMutationPolicyOverrideRepository', () => ({
+  AiAgentMutationPolicyOverrideRepository: jest.fn().mockImplementation(() => ({
+    get: repoGetMock,
+    set: repoSetMock,
+    clear: repoClearMock,
+  })),
+}))
+
+import { DELETE, GET, POST } from '../route'
+
+function makeAgent(
+  overrides: Partial<AiAgentDefinition> & Pick<AiAgentDefinition, 'id' | 'moduleId'>,
+): AiAgentDefinition {
+  return {
+    label: `${overrides.id} label`,
+    description: `${overrides.id} description`,
+    systemPrompt: 'You are a test agent.',
+    allowedTools: [],
+    ...overrides,
+  }
+}
+
+function buildRequest(body: unknown, method: 'GET' | 'POST' | 'DELETE' = 'POST'): Request {
+  return new Request(
+    'http://localhost/api/ai_assistant/ai/agents/catalog.assistant/mutation-policy',
+    {
+      method,
+      headers: { 'content-type': 'application/json' },
+      body: method === 'POST' ? JSON.stringify(body) : undefined,
+    },
+  )
+}
+
+function buildParams(agentId: string) {
+  return { params: Promise.resolve({ agentId }) }
+}
+
+describe('mutation-policy route (Step 5.4)', () => {
+  let consoleErrorSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    resetAgentRegistryForTests()
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+    authMock.mockResolvedValue({
+      sub: 'user-1',
+      tenantId: 'tenant-1',
+      orgId: 'org-1',
+    })
+    loadAclMock.mockResolvedValue({
+      features: ['ai_assistant.view', 'ai_assistant.settings.manage'],
+      isSuperAdmin: false,
+    })
+    createRequestContainerMock.mockResolvedValue({
+      resolve: (name: string) => {
+        if (name === 'rbacService') {
+          return {
+            loadAcl: loadAclMock,
+            hasAllFeatures: (required: string[], granted: string[]) =>
+              required.every((feature) => granted.includes(feature)),
+          }
+        }
+        if (name === 'em') {
+          return {}
+        }
+        return null
+      },
+    })
+    repoGetMock.mockResolvedValue(null)
+    repoSetMock.mockImplementation(async (input: any) => ({
+      id: 'row-1',
+      agentId: input.agentId,
+      mutationPolicy: input.mutationPolicy,
+      notes: input.notes ?? null,
+      createdByUserId: null,
+      createdAt: new Date('2026-04-18T00:00:00Z'),
+      updatedAt: new Date('2026-04-18T00:00:01Z'),
+    }))
+    repoClearMock.mockResolvedValue(true)
+  })
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore()
+  })
+
+  afterAll(() => {
+    resetAgentRegistryForTests()
+  })
+
+  describe('GET', () => {
+    it('returns 401 when unauthenticated', async () => {
+      authMock.mockResolvedValueOnce(null)
+      const response = await GET(
+        buildRequest(null, 'GET') as any,
+        buildParams('catalog.assistant'),
+      )
+      expect(response.status).toBe(401)
+    })
+
+    it('returns 404 for an unknown agent id', async () => {
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'catalog.assistant', moduleId: 'catalog' }),
+      ])
+      const response = await GET(
+        buildRequest(null, 'GET') as any,
+        buildParams('catalog.missing'),
+      )
+      expect(response.status).toBe(404)
+      const json = await response.json()
+      expect(json.code).toBe('agent_unknown')
+    })
+
+    it('returns { codeDeclared, override: null } when no override exists', async () => {
+      seedAgentRegistryForTests([
+        makeAgent({
+          id: 'catalog.assistant',
+          moduleId: 'catalog',
+          mutationPolicy: 'confirm-required',
+        }),
+      ])
+      repoGetMock.mockResolvedValueOnce(null)
+
+      const response = await GET(
+        buildRequest(null, 'GET') as any,
+        buildParams('catalog.assistant'),
+      )
+      expect(response.status).toBe(200)
+      const json = await response.json()
+      expect(json.agentId).toBe('catalog.assistant')
+      expect(json.codeDeclared).toBe('confirm-required')
+      expect(json.override).toBeNull()
+    })
+
+    it('returns serialized override when one exists', async () => {
+      seedAgentRegistryForTests([
+        makeAgent({
+          id: 'catalog.assistant',
+          moduleId: 'catalog',
+          mutationPolicy: 'confirm-required',
+        }),
+      ])
+      repoGetMock.mockResolvedValueOnce({
+        id: 'row-1',
+        agentId: 'catalog.assistant',
+        mutationPolicy: 'read-only',
+        notes: 'lock it',
+        createdByUserId: 'user-1',
+        createdAt: new Date('2026-04-17T00:00:00Z'),
+        updatedAt: new Date('2026-04-18T00:00:00Z'),
+      })
+
+      const response = await GET(
+        buildRequest(null, 'GET') as any,
+        buildParams('catalog.assistant'),
+      )
+      expect(response.status).toBe(200)
+      const json = await response.json()
+      expect(json.codeDeclared).toBe('confirm-required')
+      expect(json.override.mutationPolicy).toBe('read-only')
+    })
+  })
+
+  describe('POST', () => {
+    it('returns 401 when unauthenticated', async () => {
+      authMock.mockResolvedValueOnce(null)
+      const response = await POST(
+        buildRequest({ mutationPolicy: 'read-only' }) as any,
+        buildParams('catalog.assistant'),
+      )
+      expect(response.status).toBe(401)
+    })
+
+    it('returns 403 when the caller lacks ai_assistant.settings.manage', async () => {
+      loadAclMock.mockResolvedValueOnce({
+        features: ['ai_assistant.view'],
+        isSuperAdmin: false,
+      })
+      seedAgentRegistryForTests([
+        makeAgent({
+          id: 'catalog.assistant',
+          moduleId: 'catalog',
+          mutationPolicy: 'confirm-required',
+        }),
+      ])
+
+      const response = await POST(
+        buildRequest({ mutationPolicy: 'read-only' }) as any,
+        buildParams('catalog.assistant'),
+      )
+      expect(response.status).toBe(403)
+      const json = await response.json()
+      expect(json.code).toBe('forbidden')
+    })
+
+    it('returns 404 for an unknown agent id', async () => {
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'catalog.assistant', moduleId: 'catalog' }),
+      ])
+      const response = await POST(
+        buildRequest({ mutationPolicy: 'read-only' }) as any,
+        buildParams('catalog.missing'),
+      )
+      expect(response.status).toBe(404)
+    })
+
+    it('returns 400 with validation_error when body is malformed', async () => {
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'catalog.assistant', moduleId: 'catalog' }),
+      ])
+      const response = await POST(
+        buildRequest({ mutationPolicy: 'not-a-valid-policy' }) as any,
+        buildParams('catalog.assistant'),
+      )
+      expect(response.status).toBe(400)
+      const json = await response.json()
+      expect(json.code).toBe('validation_error')
+    })
+
+    it('rejects escalation (read-only agent → confirm-required override) with escalation_not_allowed', async () => {
+      seedAgentRegistryForTests([
+        makeAgent({
+          id: 'catalog.assistant',
+          moduleId: 'catalog',
+          mutationPolicy: 'read-only',
+        }),
+      ])
+      const response = await POST(
+        buildRequest({ mutationPolicy: 'confirm-required' }) as any,
+        buildParams('catalog.assistant'),
+      )
+      expect(response.status).toBe(400)
+      const json = await response.json()
+      expect(json.code).toBe('escalation_not_allowed')
+      expect(json.codeDeclared).toBe('read-only')
+      expect(json.requested).toBe('confirm-required')
+      expect(repoSetMock).not.toHaveBeenCalled()
+    })
+
+    it('rejects escalation (destructive-confirm-required agent → confirm-required override)', async () => {
+      seedAgentRegistryForTests([
+        makeAgent({
+          id: 'catalog.assistant',
+          moduleId: 'catalog',
+          mutationPolicy: 'destructive-confirm-required',
+        }),
+      ])
+      const response = await POST(
+        buildRequest({ mutationPolicy: 'confirm-required' }) as any,
+        buildParams('catalog.assistant'),
+      )
+      expect(response.status).toBe(400)
+      const json = await response.json()
+      expect(json.code).toBe('escalation_not_allowed')
+    })
+
+    it('accepts a downgrade (confirm-required → read-only) with 200', async () => {
+      seedAgentRegistryForTests([
+        makeAgent({
+          id: 'catalog.assistant',
+          moduleId: 'catalog',
+          mutationPolicy: 'confirm-required',
+        }),
+      ])
+      const response = await POST(
+        buildRequest({ mutationPolicy: 'read-only' }) as any,
+        buildParams('catalog.assistant'),
+      )
+      expect(response.status).toBe(200)
+      const json = await response.json()
+      expect(json.ok).toBe(true)
+      expect(json.override.mutationPolicy).toBe('read-only')
+      expect(json.codeDeclared).toBe('confirm-required')
+      expect(repoSetMock).toHaveBeenCalledTimes(1)
+    })
+
+    it('accepts a same-level save (confirm-required → confirm-required) as a no-op override', async () => {
+      seedAgentRegistryForTests([
+        makeAgent({
+          id: 'catalog.assistant',
+          moduleId: 'catalog',
+          mutationPolicy: 'confirm-required',
+        }),
+      ])
+      const response = await POST(
+        buildRequest({ mutationPolicy: 'confirm-required' }) as any,
+        buildParams('catalog.assistant'),
+      )
+      expect(response.status).toBe(200)
+    })
+  })
+
+  describe('DELETE', () => {
+    it('returns 401 when unauthenticated', async () => {
+      authMock.mockResolvedValueOnce(null)
+      const response = await DELETE(
+        buildRequest(null, 'DELETE') as any,
+        buildParams('catalog.assistant'),
+      )
+      expect(response.status).toBe(401)
+    })
+
+    it('returns 403 when the caller lacks ai_assistant.settings.manage', async () => {
+      loadAclMock.mockResolvedValueOnce({
+        features: ['ai_assistant.view'],
+        isSuperAdmin: false,
+      })
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'catalog.assistant', moduleId: 'catalog' }),
+      ])
+      const response = await DELETE(
+        buildRequest(null, 'DELETE') as any,
+        buildParams('catalog.assistant'),
+      )
+      expect(response.status).toBe(403)
+    })
+
+    it('clears the override and subsequent GET returns override: null', async () => {
+      seedAgentRegistryForTests([
+        makeAgent({
+          id: 'catalog.assistant',
+          moduleId: 'catalog',
+          mutationPolicy: 'confirm-required',
+        }),
+      ])
+      repoClearMock.mockResolvedValueOnce(true)
+
+      const delResponse = await DELETE(
+        buildRequest(null, 'DELETE') as any,
+        buildParams('catalog.assistant'),
+      )
+      expect(delResponse.status).toBe(200)
+      const delJson = await delResponse.json()
+      expect(delJson.ok).toBe(true)
+      expect(delJson.cleared).toBe(true)
+      expect(delJson.override).toBeNull()
+
+      repoGetMock.mockResolvedValueOnce(null)
+      const getResponse = await GET(
+        buildRequest(null, 'GET') as any,
+        buildParams('catalog.assistant'),
+      )
+      const getJson = await getResponse.json()
+      expect(getJson.override).toBeNull()
+    })
+  })
+})