@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]/confirm/__tests__/route.test.ts

@@ -0,0 +1,339 @@
+import { z } from 'zod'
+
+const authMock = jest.fn()
+const loadAclMock = jest.fn()
+const createRequestContainerMock = jest.fn()
+const repoGetByIdMock = jest.fn()
+const repoSetStatusMock = jest.fn()
+const policyOverrideGetMock = jest.fn()
+const loadAgentRegistryMock = jest.fn()
+const loadAllModuleToolsMock = jest.fn()
+const getAgentMock = jest.fn()
+const getToolMock = jest.fn()
+const attachmentFindMock = 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('@open-mercato/shared/lib/encryption/find', () => ({
+  findWithDecryption: (...args: unknown[]) => attachmentFindMock(...args),
+  findOneWithDecryption: jest.fn(),
+}))
+
+jest.mock('@open-mercato/core/modules/attachments/data/entities', () => ({
+  Attachment: class Attachment {},
+  AttachmentPartition: class AttachmentPartition {},
+}))
+
+jest.mock('../../../../../../data/repositories/AiPendingActionRepository', () => ({
+  AiPendingActionRepository: jest.fn().mockImplementation(() => ({
+    getById: repoGetByIdMock,
+    setStatus: repoSetStatusMock,
+  })),
+}))
+
+jest.mock('../../../../../../data/repositories/AiAgentMutationPolicyOverrideRepository', () => ({
+  AiAgentMutationPolicyOverrideRepository: jest.fn().mockImplementation(() => ({
+    get: policyOverrideGetMock,
+  })),
+}))
+
+jest.mock('../../../../../../lib/agent-registry', () => ({
+  getAgent: (...args: unknown[]) => getAgentMock(...args),
+  loadAgentRegistry: (...args: unknown[]) => loadAgentRegistryMock(...args),
+}))
+
+jest.mock('../../../../../../lib/tool-registry', () => ({
+  toolRegistry: {
+    getTool: (...args: unknown[]) => getToolMock(...args),
+  },
+}))
+
+jest.mock('../../../../../../lib/tool-loader', () => ({
+  loadAllModuleTools: (...args: unknown[]) => loadAllModuleToolsMock(...args),
+}))
+
+import { POST } from '../route'
+
+function buildRequest(): Request {
+  return new Request('http://localhost/api/ai_assistant/ai/actions/pa_123/confirm', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+  })
+}
+
+function buildContext(id: string) {
+  return { params: Promise.resolve({ id }) }
+}
+
+function makeRow(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'pa_123',
+    tenantId: 'tenant-1',
+    organizationId: 'org-1',
+    agentId: 'catalog.merchandising_assistant',
+    toolName: 'catalog.update_product',
+    status: 'pending',
+    fieldDiff: [{ field: 'title', before: 'Old', after: 'New' }],
+    records: null,
+    failedRecords: null,
+    sideEffectsSummary: null,
+    recordVersion: 'v-1',
+    attachmentIds: [],
+    normalizedInput: { productId: 'p-1', patch: { title: 'New' } },
+    queueMode: 'inline',
+    executionResult: null,
+    targetEntityType: 'product',
+    targetRecordId: 'p-1',
+    conversationId: null,
+    idempotencyKey: 'idem_1',
+    createdByUserId: 'user-1',
+    createdAt: new Date(Date.now() - 60_000),
+    expiresAt: new Date(Date.now() + 3_600_000),
+    resolvedAt: null,
+    resolvedByUserId: null,
+    ...overrides,
+  }
+}
+
+function makeAgent(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'catalog.merchandising_assistant',
+    moduleId: 'catalog',
+    label: 'Catalog',
+    description: '...',
+    systemPrompt: '...',
+    allowedTools: ['catalog.update_product'],
+    readOnly: false,
+    mutationPolicy: 'confirm-required',
+    ...overrides,
+  }
+}
+
+function makeTool(overrides: Record<string, unknown> = {}) {
+  return {
+    name: 'catalog.update_product',
+    description: 'Update product',
+    inputSchema: z.object({
+      productId: z.string(),
+      patch: z.object({ title: z.string() }).partial(),
+    }),
+    handler: jest.fn().mockResolvedValue({ recordId: 'p-1', commandName: 'catalog.product.update' }),
+    isMutation: true,
+    loadBeforeRecord: jest.fn().mockResolvedValue({
+      recordId: 'p-1',
+      entityType: 'catalog.product',
+      recordVersion: 'v-1',
+      before: { title: 'Old' },
+    }),
+    ...overrides,
+  }
+}
+
+describe('POST /api/ai/actions/:id/confirm route (Step 5.8)', () => {
+  let consoleErrorSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+
+    authMock.mockResolvedValue({
+      sub: 'user-1',
+      tenantId: 'tenant-1',
+      orgId: 'org-1',
+    })
+    loadAclMock.mockResolvedValue({
+      features: ['ai_assistant.view', 'catalog.view', 'catalog.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 {}
+        if (name === 'eventBus') return { emitEvent: jest.fn().mockResolvedValue(undefined) }
+        return null
+      },
+    })
+    policyOverrideGetMock.mockResolvedValue(null)
+    loadAgentRegistryMock.mockResolvedValue(undefined)
+    loadAllModuleToolsMock.mockResolvedValue(undefined)
+    getAgentMock.mockReturnValue(makeAgent())
+    getToolMock.mockReturnValue(makeTool())
+    attachmentFindMock.mockResolvedValue([])
+
+    repoSetStatusMock.mockImplementation(async (id: string, status: string, _scope: unknown, extra?: any) => {
+      return { ...makeRow({ id, status }), ...(extra?.executionResult ? { executionResult: extra.executionResult } : {}) }
+    })
+  })
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore()
+  })
+
+  it('returns 401 when unauthenticated', async () => {
+    authMock.mockResolvedValueOnce(null)
+    const response = await POST(buildRequest() as any, buildContext('pa_123'))
+    expect(response.status).toBe(401)
+  })
+
+  it('happy path: returns 200 with pendingAction.status === confirmed', async () => {
+    repoGetByIdMock.mockResolvedValueOnce(makeRow())
+
+    const response = await POST(buildRequest() as any, buildContext('pa_123'))
+    expect(response.status).toBe(200)
+    const body = await response.json()
+    expect(body.ok).toBe(true)
+    expect(body.pendingAction.status).toBe('confirmed')
+    expect(body.mutationResult).toEqual({ recordId: 'p-1', commandName: 'catalog.product.update' })
+  })
+
+  it('409 invalid_status: already cancelled', async () => {
+    repoGetByIdMock.mockResolvedValueOnce(makeRow({ status: 'cancelled' }))
+
+    const response = await POST(buildRequest() as any, buildContext('pa_123'))
+    expect(response.status).toBe(409)
+    const body = await response.json()
+    expect(body.code).toBe('invalid_status')
+  })
+
+  it('409 expired: expiresAt in the past', async () => {
+    repoGetByIdMock.mockResolvedValueOnce(
+      makeRow({ expiresAt: new Date('2020-01-01T00:00:00.000Z') }),
+    )
+
+    const response = await POST(buildRequest() as any, buildContext('pa_123'))
+    expect(response.status).toBe(409)
+    const body = await response.json()
+    expect(body.code).toBe('expired')
+  })
+
+  it('412 stale_version: record version drift on single-record action', async () => {
+    repoGetByIdMock.mockResolvedValueOnce(makeRow({ recordVersion: 'v-1' }))
+    getToolMock.mockReturnValueOnce(
+      makeTool({
+        loadBeforeRecord: jest.fn().mockResolvedValue({
+          recordId: 'p-1',
+          entityType: 'catalog.product',
+          recordVersion: 'v-2',
+          before: { title: 'x' },
+        }),
+      }),
+    )
+
+    const response = await POST(buildRequest() as any, buildContext('pa_123'))
+    expect(response.status).toBe(412)
+    const body = await response.json()
+    expect(body.code).toBe('stale_version')
+  })
+
+  it('403 read_only_agent when policy override downgrades to read-only', async () => {
+    repoGetByIdMock.mockResolvedValueOnce(makeRow())
+    policyOverrideGetMock.mockResolvedValueOnce({ mutationPolicy: 'read-only' })
+
+    const response = await POST(buildRequest() as any, buildContext('pa_123'))
+    expect(response.status).toBe(403)
+    const body = await response.json()
+    expect(body.code).toBe('read_only_agent')
+  })
+
+  it('403 tool_not_whitelisted when agent no longer whitelists the tool', async () => {
+    repoGetByIdMock.mockResolvedValueOnce(makeRow())
+    getAgentMock.mockReturnValueOnce(makeAgent({ allowedTools: [] }))
+
+    const response = await POST(buildRequest() as any, buildContext('pa_123'))
+    expect(response.status).toBe(403)
+    const body = await response.json()
+    expect(body.code).toBe('tool_not_whitelisted')
+  })
+
+  it('403 agent_features_denied when caller lacks agent features', async () => {
+    repoGetByIdMock.mockResolvedValueOnce(makeRow())
+    getAgentMock.mockReturnValueOnce(makeAgent({ requiredFeatures: ['catalog.restricted.manage'] }))
+
+    const response = await POST(buildRequest() as any, buildContext('pa_123'))
+    expect(response.status).toBe(403)
+    const body = await response.json()
+    expect(body.code).toBe('agent_features_denied')
+  })
+
+  it('403 attachment_cross_tenant when an attachment belongs to a different tenant', async () => {
+    repoGetByIdMock.mockResolvedValueOnce(makeRow({ attachmentIds: ['a-1'] }))
+    attachmentFindMock.mockResolvedValueOnce([
+      { id: 'a-1', tenantId: 'tenant-OTHER', organizationId: 'org-OTHER' },
+    ])
+
+    const response = await POST(buildRequest() as any, buildContext('pa_123'))
+    expect(response.status).toBe(403)
+    const body = await response.json()
+    expect(body.code).toBe('attachment_cross_tenant')
+  })
+
+  it('404 agent_unknown when agent has been removed from the registry', async () => {
+    repoGetByIdMock.mockResolvedValueOnce(makeRow())
+    getAgentMock.mockReturnValueOnce(undefined)
+
+    const response = await POST(buildRequest() as any, buildContext('pa_123'))
+    expect(response.status).toBe(404)
+    const body = await response.json()
+    expect(body.code).toBe('agent_unknown')
+  })
+
+  it('404 pending_action_not_found when the row does not exist for the caller', async () => {
+    repoGetByIdMock.mockResolvedValueOnce(null)
+
+    const response = await POST(buildRequest() as any, buildContext('pa_missing'))
+    expect(response.status).toBe(404)
+    const body = await response.json()
+    expect(body.code).toBe('pending_action_not_found')
+  })
+
+  it('403 forbidden when caller lacks ai_assistant.view', async () => {
+    loadAclMock.mockResolvedValueOnce({ features: ['catalog.view'], isSuperAdmin: false })
+
+    const response = await POST(buildRequest() as any, buildContext('pa_123'))
+    expect(response.status).toBe(403)
+    const body = await response.json()
+    expect(body.code).toBe('forbidden')
+  })
+
+  it('idempotent: second confirm on already-confirmed row returns 200 + prior executionResult without invoking handler', async () => {
+    const priorResult = { recordId: 'p-1', commandName: 'catalog.product.update' }
+    const priorRow = makeRow({
+      status: 'confirmed',
+      executionResult: priorResult,
+      resolvedAt: new Date('2026-04-18T10:30:00.000Z'),
+      resolvedByUserId: 'user-1',
+    })
+    repoGetByIdMock.mockResolvedValueOnce(priorRow)
+    const handlerSpy = jest.fn()
+    getToolMock.mockReturnValueOnce(makeTool({ handler: handlerSpy }))
+
+    const response = await POST(buildRequest() as any, buildContext('pa_123'))
+    expect(response.status).toBe(200)
+    const body = await response.json()
+    expect(body.ok).toBe(true)
+    expect(body.mutationResult).toEqual(priorResult)
+    expect(handlerSpy).not.toHaveBeenCalled()
+    expect(repoSetStatusMock).not.toHaveBeenCalled()
+  })
+
+  it('500 confirm_internal_error when the repo throws unexpectedly', async () => {
+    repoGetByIdMock.mockRejectedValueOnce(new Error('db down'))
+
+    const response = await POST(buildRequest() as any, buildContext('pa_123'))
+    expect(response.status).toBe(500)
+    const body = await response.json()
+    expect(body.code).toBe('confirm_internal_error')
+  })
+})

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

@@ -0,0 +1,229 @@
+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'
+import { getAgent, loadAgentRegistry } from '../../../../../lib/agent-registry'
+import { toolRegistry } from '../../../../../lib/tool-registry'
+import { loadAllModuleTools } from '../../../../../lib/tool-loader'
+import type { AiToolDefinition } from '../../../../../lib/types'
+import {
+  runPendingActionRechecks,
+  type PendingActionRecheckResult,
+} from '../../../../../lib/pending-action-recheck'
+import {
+  executePendingActionConfirm,
+  type PendingActionExecuteContext,
+} from '../../../../../lib/pending-action-executor'
+import { AiAgentMutationPolicyOverrideRepository } from '../../../../../data/repositories/AiAgentMutationPolicyOverrideRepository'
+import type { AiAgentMutationPolicy } from '../../../../../lib/ai-agent-definition'
+import { isKnownMutationPolicy } from '../../../../../lib/agent-policy'
+
+/**
+ * POST `/api/ai/actions/:id/confirm` — mutation approval gate confirm
+ * endpoint (spec §9.4, Step 5.8).
+ *
+ * Invariant: every check from spec §9.4 is re-run on the server before the
+ * tool handler executes. The original model-proposed tool arguments are
+ * re-parsed through the CURRENT tool `inputSchema` so that a schema
+ * migration between propose and confirm surfaces as `schema_drift`
+ * (412) instead of silently passing through invalid data.
+ *
+ * Idempotency: calling this endpoint twice on the same pending-action id
+ * returns the prior execution result without re-invoking the handler.
+ */
+
+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) confirm',
+  methods: {
+    POST: {
+      operationId: 'aiAssistantConfirmPendingAction',
+      summary: 'Confirm an AI pending action, re-running every server-side check before execution.',
+      description:
+        'Re-verifies the full contract from spec §9.4 (status, expiry, agent registration, ' +
+        'required features, mutation policy, tool whitelist, attachment tenant scope, record ' +
+        'version, and schema drift), flips the pending-action state machine to `executing`, ' +
+        'invokes the wrapped tool handler, and persists `executionResult`. Idempotent: a ' +
+        'second call on a row already in `confirmed` state returns the prior result without ' +
+        're-executing the handler.',
+      responses: [
+        {
+          status: 200,
+          description: 'Confirmation complete; body includes the serialized pending action and the mutation result.',
+          mediaType: 'application/json',
+        },
+      ],
+      errors: [
+        { status: 401, description: 'Unauthenticated caller.' },
+        { status: 403, description: 'Caller lacks `ai_assistant.view`, a required agent feature, tool whitelist, or accesses attachments outside their tenant.' },
+        { status: 404, description: 'Pending action or agent not found in the caller scope.' },
+        { status: 409, description: 'Pending action is not in `pending` status or has expired.' },
+        { status: 412, description: 'Record version changed between propose and confirm, or the input schema no longer accepts the stored payload.' },
+        { status: 500, description: 'Unexpected server failure during confirm.' },
+      ],
+    },
+  },
+}
+
+export const metadata = {
+  POST: { 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 })
+}
+
+function fromRecheckFailure(result: PendingActionRecheckResult & { ok: false }): NextResponse {
+  return jsonError(result.status, result.message, result.code, result.extra)
+}
+
+export async function POST(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',
+      )
+    }
+
+    // Idempotency short-circuit — a prior confirm already ran.
+    if (row.status === 'confirmed' || row.status === 'failed') {
+      const executionResult = row.executionResult ?? null
+      return NextResponse.json({
+        ok: row.status === 'confirmed',
+        pendingAction: serializePendingActionForClient(row),
+        mutationResult: executionResult,
+      })
+    }
+
+    await loadAgentRegistry()
+    await loadAllModuleTools()
+    const agent = getAgent(row.agentId)
+    const tool = toolRegistry.getTool(row.toolName) as AiToolDefinition | undefined
+
+    const policyOverrideRepo = new AiAgentMutationPolicyOverrideRepository(em)
+    const overrideRow = await policyOverrideRepo.get(row.agentId, {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId ?? null,
+    })
+    const rawOverridePolicy = overrideRow?.mutationPolicy ?? null
+    const mutationPolicyOverride: AiAgentMutationPolicy | null =
+      rawOverridePolicy && isKnownMutationPolicy(rawOverridePolicy) ? rawOverridePolicy : null
+
+    const recheckResult = await runPendingActionRechecks({
+      action: row,
+      agent,
+      tool,
+      ctx: {
+        tenantId: auth.tenantId,
+        organizationId: auth.orgId ?? null,
+        userId: auth.sub,
+        userFeatures: acl.features,
+        isSuperAdmin: acl.isSuperAdmin,
+        container,
+        em,
+      },
+      mutationPolicyOverride,
+    })
+    if (!recheckResult.ok) {
+      return fromRecheckFailure(recheckResult)
+    }
+
+    const executeCtx: PendingActionExecuteContext = {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId ?? null,
+      userId: auth.sub,
+      userFeatures: acl.features,
+      isSuperAdmin: acl.isSuperAdmin,
+      container,
+    }
+
+    const executed = await executePendingActionConfirm({
+      action: row,
+      agent: agent!,
+      tool: tool!,
+      ctx: executeCtx,
+      repo,
+      failedRecords: recheckResult.failedRecords ?? null,
+    })
+
+    return NextResponse.json({
+      ok: executed.ok,
+      pendingAction: serializePendingActionForClient(executed.action),
+      mutationResult: executed.executionResult,
+    })
+  } catch (error) {
+    console.error('[AI Pending Action CONFIRM] Failure:', error)
+    return jsonError(
+      500,
+      error instanceof Error ? error.message : 'Failed to confirm pending action.',
+      'confirm_internal_error',
+    )
+  }
+}