@open-mercato/core 0.10.1-develop.7707.1.61845a3ef7 → 0.10.1-develop.7709.1.046124599c

package/src/modules/workflows/lib/activity-executor.ts

@@ -382,7 +382,7 @@ export async function enqueueActivity(
     workflowContext,
     stepContext,
     retryPolicy: activity.retryPolicy,
-    timeoutMs: activity.timeoutMs,
+    timeoutMs: resolveActivityTimeoutMs(activity),
     tenantId: workflowInstance.tenantId,
     organizationId: workflowInstance.organizationId,
     userId: context.userId,
@@ -851,6 +851,7 @@ async function executeActivityByType(
     em: em as PostgreSqlEntityManager,
     container,
     signal,
+    timeoutMs: resolveActivityTimeoutMs(activity),
   })
 }
 
@@ -1215,6 +1216,38 @@ export type CallWebhookDeps = {
   allowPrivate?: boolean
   fetchImpl?: typeof fetch
   signal?: AbortSignal
+  timeoutMs?: number
+}
+
+const WEBHOOK_TIMEOUT_MS = 30_000
+const WEBHOOK_MAX_RESPONSE_BYTES = 1024 * 1024
+
+async function readWebhookResponse(response: Response, signal: AbortSignal): Promise<string> {
+  const declaredLength = Number(response.headers.get('content-length'))
+  if (declaredLength > WEBHOOK_MAX_RESPONSE_BYTES) {
+    throw new Error(`[internal] CALL_WEBHOOK response exceeds ${WEBHOOK_MAX_RESPONSE_BYTES} bytes`)
+  }
+  if (!response.body) return ''
+
+  const reader = response.body.getReader()
+  const chunks: Uint8Array[] = []
+  let totalBytes = 0
+  try {
+    for (;;) {
+      throwIfAborted(signal)
+      const { done, value } = await raceAbortable(reader.read(), signal)
+      if (done) break
+      totalBytes += value.byteLength
+      if (totalBytes > WEBHOOK_MAX_RESPONSE_BYTES) {
+        throw new Error(`[internal] CALL_WEBHOOK response exceeds ${WEBHOOK_MAX_RESPONSE_BYTES} bytes`)
+      }
+      chunks.push(value)
+    }
+    return new TextDecoder().decode(Buffer.concat(chunks, totalBytes))
+  } finally {
+    void reader.cancel().catch(() => undefined)
+    reader.releaseLock()
+  }
 }
 
 export async function executeCallWebhook(
@@ -1234,67 +1267,65 @@ export async function executeCallWebhook(
 
   const allowPrivate = deps.allowPrivate ?? isAllowPrivateWorkflowWebhookUrlsEnabled()
 
-  let response: Response
-  try {
-    response = await safeOutboundFetch(
-      url,
-      {
-        method,
-        headers: {
-          'Content-Type': 'application/json',
-          ...headers,
-        },
-        body: body !== undefined && body !== null ? JSON.stringify(body) : undefined,
-        redirect: 'manual',
-        signal: deps.signal,
-      },
-      {
-        subject: 'Workflow webhook URL',
-        allowPrivate,
-        lookupHost: deps.lookupHost,
-        fetchImpl: deps.fetchImpl,
-      },
-    )
-  } catch (error) {
-    if (error instanceof UnsafeOutboundUrlError) {
-      throw new Error(
-        `CALL_WEBHOOK rejected unsafe URL (reason=${error.reason}): ${error.message}`
-      )
-    }
-    throw error
-  }
-
-  if (response.status >= 300 && response.status < 400) {
-    const location = response.headers.get('location')
-    throw new Error(
-      `CALL_WEBHOOK refused to follow redirect ${response.status} to ${
-        location ?? '(no Location header)'
-      }`
-    )
-  }
+  return executeWithTimeout(async (deadlineSignal) => {
+    const signal = deps.signal
+      ? AbortSignal.any([deadlineSignal, deps.signal])
+      : deadlineSignal
+    throwIfAborted(signal)
 
-  // Parse response
-  let result: any
-  const contentType = response.headers.get('content-type')
+    let response: Response | undefined
+    try {
+      response = await raceAbortable(safeOutboundFetch(
+        url,
+        {
+          method,
+          headers: {
+            'Content-Type': 'application/json',
+            ...headers,
+          },
+          body: body !== undefined && body !== null ? JSON.stringify(body) : undefined,
+          redirect: 'manual',
+          signal,
+        },
+        {
+          subject: 'Workflow webhook URL',
+          allowPrivate,
+          lookupHost: deps.lookupHost,
+          fetchImpl: deps.fetchImpl,
+        },
+      ), signal)
+
+      if (response.status >= 300 && response.status < 400) {
+        const location = response.headers.get('location')
+        throw new Error(
+          `CALL_WEBHOOK refused to follow redirect ${response.status} to ${
+            location ?? '(no Location header)'
+          }`
+        )
+      }
 
-  if (contentType && contentType.includes('application/json')) {
-    result = await response.json()
-  } else {
-    result = await response.text()
-  }
+      const text = await readWebhookResponse(response, signal)
+      const contentType = response.headers.get('content-type')
+      const result: unknown = contentType?.includes('application/json') ? JSON.parse(text) : text
 
-  // Check for HTTP errors
-  if (!response.ok) {
-    throw new Error(
-      `Webhook request failed with status ${response.status}: ${JSON.stringify(result)}`
-    )
-  }
+      if (!response.ok) {
+        throw new Error(
+          `Webhook request failed with status ${response.status}: ${JSON.stringify(result)}`
+        )
+      }
 
-  return {
-    status: response.status,
-    statusText: response.statusText,
-    result,
-  }
+      return { status: response.status, statusText: response.statusText, result }
+    } catch (error) {
+      if (error instanceof UnsafeOutboundUrlError) {
+        throw new Error(
+          `CALL_WEBHOOK rejected unsafe URL (reason=${error.reason}): ${error.message}`
+        )
+      }
+      throw error
+    } finally {
+      void response?.body?.cancel().catch(() => undefined)
+    }
+  }, deps.timeoutMs && deps.timeoutMs > 0 ? deps.timeoutMs : WEBHOOK_TIMEOUT_MS)
 }
 
 /**

package/src/modules/workflows/lib/activity-registry.ts

@@ -38,6 +38,7 @@ export interface ActivityExecuteDeps {
   em: EntityManager
   container: AwilixContainer
   signal?: AbortSignal
+  timeoutMs?: number
 }
 
 export interface ActivityTypeEntry<TConfig = unknown> {

package/src/modules/workflows/lib/activity-types.ts

@@ -301,7 +301,10 @@ export function registerBuiltinActivityTypes(): void {
       { id: 'headers', component: 'keyValue' },
       { id: 'body', component: 'json' },
     ],
-    execute: async (config, ctx, deps) => (await loadExecutor()).executeCallWebhook(config, ctx, { signal: deps.signal }),
+    execute: async (config, ctx, deps) => (await loadExecutor()).executeCallWebhook(config, ctx, {
+      signal: deps.signal,
+      timeoutMs: deps.timeoutMs,
+    }),
     async: { capable: true },
     mock: (config) => {
       const record = asConfigRecord(config)

package/src/modules/workflows/lib/activity-worker-handler.ts

@@ -47,7 +47,7 @@ const INVOKE_AGENT_QUEUE_MAX_ATTEMPTS = 3
  * place, so callers never need their own side-effect imports.
  */
 export async function executeRegistryActivity(
-  payload: Pick<WorkflowActivityJobActivity, 'activityType' | 'activityConfig'>,
+  payload: Pick<WorkflowActivityJobActivity, 'activityType' | 'activityConfig' | 'timeoutMs'>,
   activityContext: ActivityContext,
   deps: ActivityExecuteDeps
 ): Promise<unknown> {
@@ -61,7 +61,7 @@ export async function executeRegistryActivity(
     )
   }
   const runActivity = entry.executeAsync ?? entry.execute
-  return await runActivity(payload.activityConfig, activityContext, deps)
+  return await runActivity(payload.activityConfig, activityContext, { ...deps, timeoutMs: payload.timeoutMs })
 }
 
 /**