@open-mercato/core 0.10.1-develop.7815.1.94bb61610f → 0.10.1-develop.7821.1.e5115777cb

package/src/modules/workflows/api/definitions/route.ts

@@ -28,6 +28,12 @@ import {
 } from '../openapi'
 import { invalidateTriggerCache } from '../../lib/event-trigger-service'
 import { normalizeDefinitionValidationIssues } from '../../lib/definition-error-body'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import {
+  mappingTargetIssuesForApi,
+  UNSAFE_MAPPING_TARGET_MESSAGE,
+  UNSAFE_MAPPING_TARGET_MESSAGE_KEY,
+} from '../../lib/mapping-target-validation'
 import { getAllCodeWorkflows } from '../../lib/code-registry'
 import {
   authorizeWorkflowGrantChange,
@@ -262,6 +268,15 @@ export async function POST(request: NextRequest) {
     }
 
     const input: CreateWorkflowDefinitionApiInput = validation.data
+    const { translate } = await resolveTranslations()
+    const mappingMessage = translate(UNSAFE_MAPPING_TARGET_MESSAGE_KEY, UNSAFE_MAPPING_TARGET_MESSAGE)
+    const mappingIssues = mappingTargetIssuesForApi(input.definition, ['definition'], mappingMessage)
+    if (mappingIssues.length > 0) {
+      return NextResponse.json(
+        { error: 'Validation failed', details: mappingIssues },
+        { status: 400 }
+      )
+    }
 
     // New definitions default to strict interpolation (spec §3.6). The default
     // lives on the create path only — a schema-level default would flip

package/src/modules/workflows/i18n/de.json

@@ -2029,6 +2029,7 @@
   "workflows.validation.timerDurationOrUntilRequired": "„Auf Timer warten“ erfordert entweder „Dauer“ oder „Warten bis“.",
   "workflows.validation.timerDurationXorUntil": "„Auf Timer warten“ akzeptiert „Dauer“ oder „Warten bis“, nicht beides. Löschen Sie eines davon.",
   "workflows.validation.uniqueId": "ID muss eindeutig sein",
+  "workflows.validation.unsafeMappingTarget": "Zielpfade für Zuordnungen dürfen keine Segmente namens __proto__, constructor oder prototype enthalten",
   "workflows.validation.untilMustBeFuture": "„Warten bis“ muss ein Datum und eine Uhrzeit in der Zukunft sein.",
   "workflows.validation.workflowIdFormat": "Workflow-ID darf nur Kleinbuchstaben, Zahlen, Bindestriche und Unterstriche enthalten",
   "workflows.validation.workflowIdMaxLength": "Workflow-ID darf maximal 50 Zeichen lang sein",

package/src/modules/workflows/i18n/en.json

@@ -2029,6 +2029,7 @@
   "workflows.validation.timerDurationOrUntilRequired": "Wait For Timer requires either \"Duration\" or \"Wait Until\".",
   "workflows.validation.timerDurationXorUntil": "Wait For Timer accepts \"Duration\" or \"Wait Until\", not both. Clear one of them.",
   "workflows.validation.uniqueId": "ID must be unique",
+  "workflows.validation.unsafeMappingTarget": "Mapping target paths cannot contain __proto__, constructor, or prototype segments",
   "workflows.validation.untilMustBeFuture": "Wait Until must be a date and time in the future.",
   "workflows.validation.workflowIdFormat": "Workflow ID must contain only lowercase letters, numbers, hyphens, and underscores",
   "workflows.validation.workflowIdMaxLength": "Workflow ID must be 50 characters or less",

package/src/modules/workflows/i18n/es.json

@@ -2029,6 +2029,7 @@
   "workflows.validation.timerDurationOrUntilRequired": "Esperar temporizador requiere una Duración o Esperar hasta.",
   "workflows.validation.timerDurationXorUntil": "Esperar temporizador acepta Duración o Esperar hasta, no ambos. Borra uno de ellos.",
   "workflows.validation.uniqueId": "El ID debe ser unico",
+  "workflows.validation.unsafeMappingTarget": "Las rutas de destino de asignación no pueden contener segmentos __proto__, constructor o prototype",
   "workflows.validation.untilMustBeFuture": "Esperar hasta debe ser una fecha y hora futura.",
   "workflows.validation.workflowIdFormat": "El ID del flujo de trabajo solo puede contener letras minusculas, numeros, guiones y guiones bajos",
   "workflows.validation.workflowIdMaxLength": "El ID del flujo de trabajo debe tener 50 caracteres o menos",

package/src/modules/workflows/i18n/ko.json

@@ -2029,6 +2029,7 @@
   "workflows.validation.timerDurationOrUntilRequired": "Wait For Timer requires either \"Duration\" or \"Wait Until\".",
   "workflows.validation.timerDurationXorUntil": "Wait For Timer accepts \"Duration\" or \"Wait Until\", not both. Clear one of them.",
   "workflows.validation.uniqueId": "ID는 고유해야 합니다",
+  "workflows.validation.unsafeMappingTarget": "매핑 대상 경로에는 __proto__, constructor 또는 prototype 세그먼트를 포함할 수 없습니다",
   "workflows.validation.untilMustBeFuture": "대기 종료 시각은 미래의 날짜와 시간이어야 합니다.",
   "workflows.validation.workflowIdFormat": "워크플로우 ID는 소문자, 숫자, 하이픈, 밑줄만 포함해야 합니다",
   "workflows.validation.workflowIdMaxLength": "워크플로우 ID는 50자 이하여야 합니다",

package/src/modules/workflows/i18n/pl.json

@@ -2029,6 +2029,7 @@
   "workflows.validation.timerDurationOrUntilRequired": "Krok „Czekaj na timer” wymaga podania „Czasu trwania” lub „Czekaj do”.",
   "workflows.validation.timerDurationXorUntil": "Krok „Czekaj na timer” przyjmuje „Czas trwania” albo „Czekaj do”, nie oba naraz. Wyczyść jedno z nich.",
   "workflows.validation.uniqueId": "ID musi być unikalne",
+  "workflows.validation.unsafeMappingTarget": "Ścieżki docelowe mapowania nie mogą zawierać segmentów __proto__, constructor ani prototype",
   "workflows.validation.untilMustBeFuture": "„Czekaj do” musi być datą i godziną w przyszłości.",
   "workflows.validation.workflowIdFormat": "ID przepływu może zawierać tylko małe litery, cyfry, myślniki i podkreślenia",
   "workflows.validation.workflowIdMaxLength": "ID przepływu musi mieć 50 znaków lub mniej",

package/src/modules/workflows/lib/agent-result-mapping.ts

@@ -14,6 +14,7 @@
  */
 
 import { createLogger } from '@open-mercato/shared/lib/logger'
+import { safeGetNestedValue, safeSetNestedValue } from './safe-mapping-path'
 
 const logger = createLogger('workflows').child({ component: 'agent-result-mapping' })
 
@@ -27,20 +28,6 @@ export type AgentResultEnvelope = {
   artifacts?: unknown[]
 }
 
-function getNestedValue(obj: any, path: string): any {
-  return path.split('.').reduce((current, key) => current?.[key], obj)
-}
-
-function setNestedValue(obj: Record<string, any>, path: string, value: any): void {
-  const keys = path.split('.')
-  const lastKey = keys.pop()!
-  const target = keys.reduce<Record<string, any>>((current, key) => {
-    if (!(key in current)) current[key] = {}
-    return current[key]
-  }, obj)
-  target[lastKey] = value
-}
-
 function warnOnTemplateMapping(sourcePath: string): void {
   if (/\{\{.*\}\}/.test(sourcePath)) {
     logger.warn(
@@ -79,9 +66,9 @@ export function mapAgentResultToContext(
   const result: Record<string, any> = {}
   for (const [targetKey, sourcePath] of Object.entries(outputMapping)) {
     warnOnTemplateMapping(sourcePath)
-    const value = getNestedValue(source, sourcePath)
+    const value = safeGetNestedValue(source, sourcePath)
     if (value !== undefined) {
-      setNestedValue(result, targetKey, value)
+      safeSetNestedValue(result, targetKey, value)
     }
   }
   return result

package/src/modules/workflows/lib/definition-evaluation.ts

@@ -31,6 +31,12 @@ import {
 } from './definition-error-body'
 import { collectUnresolvedContextRefWarnings } from './expression-refs'
 import { definitionToGraph, validateWorkflowGraph } from './graph-utils'
+import {
+  collectUnsafeMappingTargetIssues,
+  mappingTargetIssuesForApi,
+  UNSAFE_MAPPING_TARGET_MESSAGE,
+  UNSAFE_MAPPING_TARGET_MESSAGE_KEY,
+} from './mapping-target-validation'
 
 /**
  * Problems-panel copy for an unresolved `{{context.*}}` reference. Shared so
@@ -75,6 +81,7 @@ export interface EvaluateWorkflowDefinitionOptions {
    * those warnings are skipped (they are advisory and never blocking).
    */
   ledger?: ContextLedger | null
+  translate?: WorkflowIssueTranslator
 }
 
 export interface WorkflowDefinitionEvaluation {
@@ -128,7 +135,14 @@ export function evaluateWorkflowDefinition(
   const { nodes, edges } = definitionToGraph(definition, { autoLayout: false })
   const graphErrors = validateWorkflowGraph(nodes, edges)
   const parsed = workflowDefinitionDataSchema.safeParse(definition)
-  const zodIssues: ZodIssueLike[] = parsed.success ? [] : parsed.error.issues
+  const mappingMessage = options.translate
+    ? options.translate(UNSAFE_MAPPING_TARGET_MESSAGE_KEY, UNSAFE_MAPPING_TARGET_MESSAGE, {})
+    : UNSAFE_MAPPING_TARGET_MESSAGE
+  const mappingIssues = collectUnsafeMappingTargetIssues(definition, mappingMessage)
+  const zodIssues: ZodIssueLike[] = [
+    ...(parsed.success ? [] : parsed.error.issues),
+    ...mappingIssues,
+  ]
   const ledger = options.ledger ?? null
   const configWarnings: ZodIssueLike[] = [
     ...collectActivityConfigWarnings(definition),
@@ -150,7 +164,10 @@ export function evaluateWorkflowDefinition(
     valid: errors === 0,
     errorCount: errors,
     warningCount: warnings,
-    issues: parsed.success ? [] : normalizeDefinitionValidationIssues(parsed.error),
+    issues: [
+      ...(parsed.success ? [] : normalizeDefinitionValidationIssues(parsed.error)),
+      ...mappingTargetIssuesForApi(definition, [], mappingMessage),
+    ],
     problems,
   }
 }

package/src/modules/workflows/lib/mapping-target-validation.ts

@@ -0,0 +1,113 @@
+import type { WorkflowDefinitionData } from '../data/entities'
+import type { DefinitionValidationIssue } from './definition-error-body'
+import type { ZodIssueLike } from './collect-validation-issues'
+import { isSafeMappingTargetPath } from './safe-mapping-path'
+
+export const UNSAFE_MAPPING_TARGET_MESSAGE_KEY = 'workflows.validation.unsafeMappingTarget'
+
+export const UNSAFE_MAPPING_TARGET_MESSAGE =
+  'Mapping target paths cannot contain __proto__, constructor, or prototype segments'
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function collectMappingIssues(
+  value: unknown,
+  path: Array<string | number>,
+  message: string,
+): ZodIssueLike[] {
+  if (!isRecord(value)) return []
+  return Object.keys(value)
+    .filter((targetPath) => !isSafeMappingTargetPath(targetPath))
+    .map((targetPath) => ({
+      path: [...path, targetPath],
+      message,
+    }))
+}
+
+function collectActivityIssues(
+  activities: unknown,
+  path: Array<string | number>,
+  message: string,
+): ZodIssueLike[] {
+  if (!Array.isArray(activities)) return []
+  return activities.flatMap((activity, activityIndex) => {
+    if (!isRecord(activity) || activity.activityType !== 'INVOKE_AGENT') return []
+    const config = isRecord(activity.config) ? activity.config : {}
+    return collectMappingIssues(config.outputMapping, [
+      ...path,
+      activityIndex,
+      'config',
+      'outputMapping',
+    ], message)
+  })
+}
+
+export function collectUnsafeMappingTargetIssues(
+  definition: WorkflowDefinitionData,
+  message = UNSAFE_MAPPING_TARGET_MESSAGE,
+): ZodIssueLike[] {
+  const stepIssues = Array.isArray(definition.steps)
+    ? definition.steps.flatMap((step, stepIndex) => {
+        if (!isRecord(step)) return []
+        const config = isRecord(step.config) ? step.config : {}
+        const subWorkflowConfig = isRecord(step.subWorkflowConfig) ? step.subWorkflowConfig : {}
+        const issues: ZodIssueLike[] = []
+
+        if (step.stepType === 'SUB_WORKFLOW') {
+          issues.push(
+            ...collectMappingIssues(config.inputMapping, ['steps', stepIndex, 'config', 'inputMapping'], message),
+            ...collectMappingIssues(config.outputMapping, ['steps', stepIndex, 'config', 'outputMapping'], message),
+            ...collectMappingIssues(subWorkflowConfig.inputMapping, [
+              'steps',
+              stepIndex,
+              'subWorkflowConfig',
+              'inputMapping',
+            ], message),
+            ...collectMappingIssues(subWorkflowConfig.outputMapping, [
+              'steps',
+              stepIndex,
+              'subWorkflowConfig',
+              'outputMapping',
+            ], message),
+          )
+        }
+        if (step.stepType === 'PARALLEL_JOIN') {
+          issues.push(
+            ...collectMappingIssues(config.outputMapping, ['steps', stepIndex, 'config', 'outputMapping'], message),
+          )
+        }
+        issues.push(...collectActivityIssues(step.activities, ['steps', stepIndex, 'activities'], message))
+        return issues
+      })
+    : []
+
+  const transitionIssues = Array.isArray(definition.transitions)
+    ? definition.transitions.flatMap((transition, transitionIndex) => {
+        if (!isRecord(transition)) return []
+        return collectActivityIssues(transition.activities, [
+          'transitions',
+          transitionIndex,
+          'activities',
+        ], message)
+      })
+    : []
+
+  return [...stepIssues, ...transitionIssues]
+}
+
+export function mappingTargetIssuesForApi(
+  definition: WorkflowDefinitionData,
+  prefix: Array<string | number> = [],
+  message = UNSAFE_MAPPING_TARGET_MESSAGE,
+): DefinitionValidationIssue[] {
+  return collectUnsafeMappingTargetIssues(definition, message).map((issue) => ({
+    path: [
+      ...prefix,
+      ...issue.path.map((segment) => (typeof segment === 'number' ? segment : String(segment))),
+    ],
+    code: 'custom',
+    message: issue.message,
+  }))
+}

package/src/modules/workflows/lib/parallel-handler.ts

@@ -38,6 +38,7 @@ import {
 import * as stepHandler from './step-handler'
 import { branchToken, mergeTokenContext, type ExecutionToken } from './execution-token'
 import { WORKFLOW_ERROR_CONTEXT_KEY, buildErrorContextEntry } from './error-routing'
+import { isSafeMappingTargetPath, safeGetNestedValue } from './safe-mapping-path'
 
 export interface AdvanceBranchesResult {
   outcome: 'joined' | 'waiting' | 'failed'
@@ -110,6 +111,17 @@ interface ParallelContext {
   userId?: string
 }
 
+export function applyParallelJoinOutputMapping(
+  context: Record<string, unknown>,
+  outputMapping: Record<string, string>,
+): void {
+  for (const [topKey, sourcePath] of Object.entries(outputMapping)) {
+    if (topKey === 'branches' || !isSafeMappingTargetPath(topKey)) continue
+    const value = safeGetNestedValue(context, sourcePath)
+    if (value !== undefined) context[topKey] = value
+  }
+}
+
 function normalizeWorkflowUserId(value: unknown): string | null {
   if (typeof value !== 'string') return null
   const trimmed = value.trim()
@@ -117,10 +129,6 @@ function normalizeWorkflowUserId(value: unknown): string | null {
   return trimmed
 }
 
-function getNestedValue(obj: any, path: string): any {
-  return path.split('.').reduce((current, key) => (current == null ? undefined : current[key]), obj)
-}
-
 /**
  * Open a PARALLEL_FORK: create one ACTIVE branch per outgoing `auto` transition
  * and mark the instance FORKED. Branch tokens start positioned ON the fork step
@@ -634,11 +642,7 @@ async function fireJoin(
   // mapping cannot clobber the per-branch namespaces.
   const outputMapping: Record<string, string> | undefined = joinStep?.config?.outputMapping
   if (outputMapping) {
-    for (const [topKey, sourcePath] of Object.entries(outputMapping)) {
-      if (topKey === 'branches') continue
-      const value = getNestedValue(nextContext, sourcePath)
-      if (value !== undefined) nextContext[topKey] = value
-    }
+    applyParallelJoinOutputMapping(nextContext, outputMapping)
   }
 
   // Park the root token ON the JOIN step (not its successor) and let the

package/src/modules/workflows/lib/safe-mapping-path.ts

@@ -0,0 +1,44 @@
+const FORBIDDEN_MAPPING_PATH_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype'])
+
+export function isSafeMappingTargetPath(path: string): boolean {
+  return !path.split('.').some((segment) => FORBIDDEN_MAPPING_PATH_SEGMENTS.has(segment))
+}
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
+export function safeGetNestedValue(source: unknown, path: string): unknown {
+  return path.split('.').reduce<unknown>((current, segment) => {
+    if (!isObjectRecord(current) || !Object.hasOwn(current, segment)) return undefined
+    return current[segment]
+  }, source)
+}
+
+function cloneMappingContainer(value: unknown): Record<string, unknown> {
+  if (Array.isArray(value)) return [...value] as unknown as Record<string, unknown>
+  if (isObjectRecord(value)) return { ...value }
+  return {}
+}
+
+export function safeSetNestedValue(
+  target: Record<string, unknown>,
+  path: string,
+  value: unknown,
+): boolean {
+  const segments = path.split('.')
+  if (!isSafeMappingTargetPath(path)) return false
+
+  const lastSegment = segments.pop()
+  if (lastSegment === undefined) return false
+
+  let current = target
+  for (const segment of segments) {
+    const existing = Object.hasOwn(current, segment) ? current[segment] : undefined
+    current[segment] = cloneMappingContainer(existing)
+    current = current[segment] as Record<string, unknown>
+  }
+
+  current[lastSegment] = value
+  return true
+}

package/src/modules/workflows/lib/step-handler.ts

@@ -54,6 +54,7 @@ import { createLogger } from '@open-mercato/shared/lib/logger'
 import { findWorkflowDefinition } from './find-definition'
 import { validateAgainstPorts } from './port-contract'
 import type { WorkflowIoContract } from '../data/validators'
+import { safeGetNestedValue, safeSetNestedValue } from './safe-mapping-path'
 
 const logger = createLogger('workflows')
 
@@ -1678,34 +1679,6 @@ async function logStepEvent(
   return workflowEvent
 }
 
-/**
- * Get nested value from object using dot notation
- *
- * @param obj - Source object
- * @param path - Dot-notation path (e.g., "user.email")
- * @returns Value at path or undefined
- */
-function getNestedValue(obj: any, path: string): any {
-  return path.split('.').reduce((current, key) => current?.[key], obj)
-}
-
-/**
- * Set nested value in object using dot notation
- *
- * @param obj - Target object
- * @param path - Dot-notation path (e.g., "user.email")
- * @param value - Value to set
- */
-function setNestedValue(obj: any, path: string, value: any): void {
-  const keys = path.split('.')
-  const lastKey = keys.pop()!
-  const target = keys.reduce((current, key) => {
-    if (!(key in current)) current[key] = {}
-    return current[key]
-  }, obj)
-  target[lastKey] = value
-}
-
 /**
  * Map data from source context using mapping configuration
  *
@@ -1720,9 +1693,9 @@ function mapInputData(
   const result: Record<string, any> = {}
 
   for (const [targetKey, sourcePath] of Object.entries(mapping)) {
-    const value = getNestedValue(sourceContext, sourcePath)
+    const value = safeGetNestedValue(sourceContext, sourcePath)
     if (value !== undefined) {
-      setNestedValue(result, targetKey, value)
+      safeSetNestedValue(result, targetKey, value)
     }
   }
 
@@ -1744,9 +1717,9 @@ function mapOutputData(
   const result: Record<string, any> = {}
 
   for (const [targetKey, sourcePath] of Object.entries(mapping)) {
-    const value = getNestedValue(childContext, sourcePath)
+    const value = safeGetNestedValue(childContext, sourcePath)
     if (value !== undefined) {
-      setNestedValue(result, targetKey, value)
+      safeSetNestedValue(result, targetKey, value)
     }
   }