@vertesia/workflow 1.5.0-dev.20260714.072725Z → 1.5.0-dev.20260722.120446Z

package/src/activities/renditions/generateVideoRendition.ts

@@ -1,16 +1,18 @@
-import { execFile as execFileCallback } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { promisify } from 'node:util';
 import { log } from '@temporalio/activity';
 import type { DSLActivityExecutionPayload, DSLActivitySpec } from '@vertesia/common';
 import { setupActivity } from '../../dsl/setup/ActivityContext.js';
 import { DocumentNotFoundError, WorkflowParamNotFoundError } from '../../errors.js';
 import { saveBlobToTempFile } from '../../utils/blobs.js';
 import { type ImageRenditionParams, uploadRenditionPages } from '../../utils/renditions.js';
-
-const execFileAsync = promisify(execFileCallback);
+import {
+    execActivityFile,
+    execActivityFileWithProgress,
+    initializeActivityCommandDeadline,
+    rethrowIfActivityStopped,
+} from '../media/exec.js';
 
 interface GenerateVideoRenditionParams extends ImageRenditionParams {}
 
@@ -32,7 +34,7 @@ interface VideoMetadata {
 async function getVideoMetadata(videoPath: string): Promise<VideoMetadata> {
     try {
         const args = ['-v', 'quiet', '-print_format', 'json', '-show_format', '-show_streams', videoPath];
-        const { stdout } = await execFileAsync('ffprobe', args);
+        const { stdout } = await execActivityFile('ffprobe', args);
         const metadata = JSON.parse(stdout.toString()) as {
             streams?: Array<{ codec_type?: string; width?: number; height?: number }>;
             format?: { duration?: string };
@@ -45,6 +47,7 @@ async function getVideoMetadata(videoPath: string): Promise<VideoMetadata> {
 
         return { duration, width, height };
     } catch (error) {
+        rethrowIfActivityStopped(error);
         log.error(`Failed to get video metadata: ${error instanceof Error ? error.message : 'Unknown error'}`);
         throw new Error(`Failed to probe video metadata: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
@@ -79,7 +82,7 @@ async function generateThumbnail(
     ];
     log.info(`Generating thumbnail at ${timestamp}s`, { command: 'ffmpeg', args: command });
     try {
-        const { stderr } = await execFileAsync('ffmpeg', command);
+        const { stderr } = await execActivityFileWithProgress('ffmpeg', command);
         const stderrText = stderr.toString();
 
         // Log any warnings from ffmpeg
@@ -96,6 +99,7 @@ async function generateThumbnail(
             return undefined;
         }
     } catch (error) {
+        rethrowIfActivityStopped(error);
         log.error(
             `Failed to generate thumbnail at ${timestamp}s: ${error instanceof Error ? error.message : 'Unknown error'}`,
         );
@@ -104,6 +108,7 @@ async function generateThumbnail(
 }
 
 export async function generateVideoRendition(payload: DSLActivityExecutionPayload<GenerateVideoRenditionParams>) {
+    initializeActivityCommandDeadline();
     const { client, objectId, params: originParams } = await setupActivity<GenerateVideoRenditionParams>(payload);
 
     // Fix: Use maxHeightWidth if max_hw is not provided
@@ -209,6 +214,7 @@ export async function generateVideoRendition(payload: DSLActivityExecutionPayloa
             requestedCount: thumbnailCount,
         });
     } catch (error) {
+        rethrowIfActivityStopped(error);
         log.error(`Error generating thumbnails for video: ${error instanceof Error ? error.message : 'Unknown error'}`);
         throw new Error(`Failed to generate thumbnails for video: ${objectId}`);
     } finally {

package/src/dsl/dsl-workflow.test.ts

@@ -8,6 +8,7 @@ describe('Workflow DSL', () => {
                 {},
                 {
                     startToCloseTimeout: 1000,
+                    heartbeatTimeout: 600,
                     scheduleToCloseTimeout: 2000,
                     scheduleToStartTimeout: 3000,
                     retry: {
@@ -21,6 +22,7 @@ describe('Workflow DSL', () => {
             ),
         ).toEqual({
             startToCloseTimeout: 1000,
+            heartbeatTimeout: 600,
             scheduleToCloseTimeout: 2000,
             scheduleToStartTimeout: 3000,
             retry: {
@@ -38,6 +40,7 @@ describe('Workflow DSL', () => {
             computeActivityOptions(
                 {
                     startToCloseTimeout: 100,
+                    heartbeatTimeout: 600,
                 },
                 {
                     startToCloseTimeout: 1000,
@@ -54,6 +57,7 @@ describe('Workflow DSL', () => {
             ),
         ).toEqual({
             startToCloseTimeout: `100ms`, // custom value
+            heartbeatTimeout: '600ms',
             scheduleToCloseTimeout: 2000,
             scheduleToStartTimeout: 3000,
             retry: {

package/src/dsl/dsl-workflow.ts

@@ -603,6 +603,9 @@ function convertDSLActivityOptions(options?: DSLActivityOptions): ActivityOption
     if (options.startToCloseTimeout) {
         result.startToCloseTimeout = ms(options.startToCloseTimeout as StringValue);
     }
+    if (options.heartbeatTimeout) {
+        result.heartbeatTimeout = ms(options.heartbeatTimeout as StringValue);
+    }
     if (options.scheduleToCloseTimeout) {
         result.scheduleToCloseTimeout = ms(options.scheduleToCloseTimeout as StringValue);
     }

package/src/dsl/dslProxyActivities.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { stripWorkflowContinuationFromVars } from './dslProxyActivities.js';
+
+describe('stripWorkflowContinuationFromVars', () => {
+    it('removes continue-as-new state from activity vars', () => {
+        const vars = {
+            interaction: 'sys:AppDeveloper',
+            _continuation: {
+                conversationState: { large: true },
+            },
+        };
+
+        expect(stripWorkflowContinuationFromVars(vars)).toEqual({
+            interaction: 'sys:AppDeveloper',
+        });
+        expect(vars).toHaveProperty('_continuation');
+    });
+
+    it('returns primitive and array vars unchanged', () => {
+        expect(stripWorkflowContinuationFromVars(undefined)).toBeUndefined();
+        expect(stripWorkflowContinuationFromVars(['a'])).toEqual(['a']);
+    });
+});

package/src/dsl/dslProxyActivities.ts

@@ -14,6 +14,16 @@ export type DslSimplifiedActivityFunction<ParamsT extends object = Record<string
     params: ParamsT,
 ) => Promise<ReturnT>;
 
+export function stripWorkflowContinuationFromVars<T>(vars: T): T {
+    if (!vars || typeof vars !== 'object' || Array.isArray(vars) || !('_continuation' in vars)) {
+        return vars;
+    }
+
+    const rest = { ...(vars as Record<string, unknown>) };
+    delete rest._continuation;
+    return rest as T;
+}
+
 export function dslProxyActivities<ActivitiesT extends object>(workflowName: string, options: ActivityOptions = {}) {
     type DslActivities = {
         [K in keyof ActivitiesT]: ActivitiesT[K] extends DslActivityFunction<infer ParamsT, infer ReturnT>
@@ -34,6 +44,7 @@ export function dslProxyActivities<ActivitiesT extends object>(workflowName: str
                 return (payload: WorkflowExecutionPayload, params: Record<string, unknown>) => {
                     return activityFn({
                         ...payload,
+                        vars: stripWorkflowContinuationFromVars(payload.vars),
                         activity: {
                             name: prop as string,
                         },

package/src/errors.ts

@@ -116,4 +116,9 @@ export const WF_NON_RETRYABLE_ERRORS = [
     'TokenExpiredError',
     'ZenoClientNotFoundError',
     'WorkflowExecutionError',
+    // Temporal raises NotFoundError when an activity isn't registered on the worker
+    // (e.g. a new tool whose activity barrel export was missed). Retrying can never
+    // make it appear within a worker version, and the retried failure carries the
+    // full activity list which blows the payload size limit — so fail fast.
+    'NotFoundError',
 ];