@vertesia/workflow 1.3.0 → 1.4.0-dev.20260615.042549Z

package/src/activities/renditions/generateVideoRendition.ts

@@ -1,25 +1,26 @@
-import { log } from "@temporalio/activity";
-import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
-import { exec } from "child_process";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { promisify } from "util";
-import { setupActivity } from "../../dsl/setup/ActivityContext.js";
-import { DocumentNotFoundError, WorkflowParamNotFoundError } from "../../errors.js";
-import { saveBlobToTempFile } from "../../utils/blobs.js";
-import {
-    ImageRenditionParams,
-    uploadRenditionPages,
-} from "../../utils/renditions.js";
-
-const execAsync = promisify(exec);
-
-interface GenerateVideoRenditionParams extends ImageRenditionParams { }
-
-export interface GenerateVideoRendition
-    extends DSLActivitySpec<GenerateVideoRenditionParams> {
-    name: "generateImageRendition";
+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);
+
+interface GenerateVideoRenditionParams extends ImageRenditionParams {}
+
+interface LegacyVideoRenditionParams {
+    maxHeightWidth?: number;
+    format_output?: ImageRenditionParams['format'];
+}
+
+export interface GenerateVideoRendition extends DSLActivitySpec<GenerateVideoRenditionParams> {
+    name: 'generateImageRendition';
 }
 
 interface VideoMetadata {
@@ -30,25 +31,22 @@ interface VideoMetadata {
 
 async function getVideoMetadata(videoPath: string): Promise<VideoMetadata> {
     try {
-        const command = `ffprobe -v quiet -print_format json -show_format -show_streams "${videoPath}"`;
-        const { stdout } = await execAsync(command);
-        const metadata = JSON.parse(stdout);
+        const args = ['-v', 'quiet', '-print_format', 'json', '-show_format', '-show_streams', videoPath];
+        const { stdout } = await execFileAsync('ffprobe', args);
+        const metadata = JSON.parse(stdout.toString()) as {
+            streams?: Array<{ codec_type?: string; width?: number; height?: number }>;
+            format?: { duration?: string };
+        };
 
-        const videoStream = metadata.streams.find(
-            (stream: any) => stream.codec_type === "video",
-        );
-        const duration = parseFloat(metadata.format.duration) || 0;
+        const videoStream = metadata.streams?.find((stream) => stream.codec_type === 'video');
+        const duration = parseFloat(metadata.format?.duration ?? '') || 0;
         const width = videoStream?.width || 0;
         const height = videoStream?.height || 0;
 
         return { duration, width, height };
     } catch (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"}`,
-        );
+        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'}`);
     }
 }
 
@@ -59,39 +57,34 @@ async function generateThumbnail(
     maxSize: number,
 ): Promise<string | undefined> {
     //pad timestamp to 5 digits as filename
-    const outputFile = path.join(
-        outputDir,
-        `thumb-${timestamp.toString().padStart(5, "0")}.jpg`,
-    );
+    const outputFile = path.join(outputDir, `thumb-${timestamp.toString().padStart(5, '0')}.jpg`);
 
     // FFmpeg command to extract thumbnail at specific timestamp
     // Use proper scale filter syntax: scale=w:h:force_original_aspect_ratio=decrease
     const scaleFilter = `scale=${maxSize}:${maxSize}:force_original_aspect_ratio=decrease`;
 
     const command = [
-        "ffmpeg",
-        "-y", // Overwrite output files
-        "-ss",
+        '-y', // Overwrite output files
+        '-ss',
         timestamp.toString(), // Seek to timestamp
-        "-i",
-        `"${videoPath}"`, // Input file
-        "-vframes",
-        "1", // Extract only 1 frame
-        "-vf",
-        `"${scaleFilter}"`, // Scale maintaining aspect ratio
-        "-q:v",
-        "2", // High quality
-        `"${outputFile}"`,
-    ].join(" ");
-    log.info(`Generating thumbnail at ${timestamp}s`), { command };
+        '-i',
+        videoPath, // Input file
+        '-vframes',
+        '1', // Extract only 1 frame
+        '-vf',
+        scaleFilter, // Scale maintaining aspect ratio
+        '-q:v',
+        '2', // High quality
+        outputFile,
+    ];
+    log.info(`Generating thumbnail at ${timestamp}s`, { command: 'ffmpeg', args: command });
     try {
-        const { stderr } = await execAsync(command);
+        const { stderr } = await execFileAsync('ffmpeg', command);
+        const stderrText = stderr.toString();
 
         // Log any warnings from ffmpeg
-        if (stderr && !stderr.includes("frame=")) {
-            log.debug(
-                `FFmpeg stderr for thumbnail at ${timestamp}s: ${stderr}`,
-            );
+        if (stderrText && !stderrText.includes('frame=')) {
+            log.debug(`FFmpeg stderr for thumbnail at ${timestamp}s: ${stderrText}`);
         }
 
         // Verify the file was created
@@ -104,28 +97,21 @@ async function generateThumbnail(
         }
     } catch (error) {
         log.error(
-            `Failed to generate thumbnail at ${timestamp}s: ${error instanceof Error ? error.message : "Unknown error"}`,
+            `Failed to generate thumbnail at ${timestamp}s: ${error instanceof Error ? error.message : 'Unknown error'}`,
         );
         return undefined;
     }
 }
 
-export async function generateVideoRendition(
-    payload: DSLActivityExecutionPayload<GenerateVideoRenditionParams>,
-) {
-    const {
-        client,
-        objectId,
-        params: originParams,
-    } = await setupActivity<GenerateVideoRenditionParams>(payload);
+export async function generateVideoRendition(payload: DSLActivityExecutionPayload<GenerateVideoRenditionParams>) {
+    const { client, objectId, params: originParams } = await setupActivity<GenerateVideoRenditionParams>(payload);
 
     // Fix: Use maxHeightWidth if max_hw is not provided
+    const legacyParams = originParams as LegacyVideoRenditionParams;
     const params = {
         ...originParams,
-        max_hw:
-            originParams.max_hw || (originParams as any).maxHeightWidth || 1024, // Default to 1024 if both are missing
-        format:
-            originParams.format || (originParams as any).format_output || "png", // Default to png if format is missing
+        max_hw: originParams.max_hw || legacyParams.maxHeightWidth || 1024, // Default to 1024 if both are missing
+        format: originParams.format || legacyParams.format_output || 'png', // Default to png if format is missing
     };
 
     log.info(`Generating video rendition for ${objectId}`, {
@@ -133,12 +119,11 @@ export async function generateVideoRendition(
         params,
     });
 
-    const inputObject = await client.objects.retrieve(objectId).catch((err) => {
+    const inputObject = await client.objects.retrieve(objectId).catch((err: unknown) => {
+        const message = err instanceof Error ? err.message : String(err);
         log.error(`Failed to retrieve document ${objectId}`, { err });
-        if (err.message.includes("not found")) {
-            throw new DocumentNotFoundError(`Document ${objectId} not found`, [
-                objectId,
-            ]);
+        if (message.includes('not found')) {
+            throw new DocumentNotFoundError(`Document ${objectId} not found`, [objectId]);
         }
         throw err;
     });
@@ -150,34 +135,19 @@ export async function generateVideoRendition(
 
     if (!inputObject.content?.source) {
         log.error(`Document ${objectId} has no source`);
-        throw new DocumentNotFoundError(`Document ${objectId} has no source`, [
-            objectId,
-        ]);
+        throw new DocumentNotFoundError(`Document ${objectId} has no source`, [objectId]);
     }
 
-    if (
-        !inputObject.content.type ||
-        !inputObject.content.type?.startsWith("video/")
-    ) {
-        log.error(
-            `Document ${objectId} is not a video: ${inputObject.content.type}`,
-        );
-        throw new DocumentNotFoundError(
-            `Document ${objectId} is not a video: ${inputObject.content.type}`,
-            [objectId],
-        );
+    if (!inputObject.content.type?.startsWith('video/')) {
+        log.error(`Document ${objectId} is not a video: ${inputObject.content.type}`);
+        throw new DocumentNotFoundError(`Document ${objectId} is not a video: ${inputObject.content.type}`, [objectId]);
     }
 
     //array of rendition files to upload
-    let renditionPages: string[] = [];
+    const renditionPages: string[] = [];
 
-    const videoFile = await saveBlobToTempFile(
-        client,
-        inputObject.content.source,
-    );
-    const tempOutputDir = fs.mkdtempSync(
-        path.join(os.tmpdir(), "video-rendition-"),
-    );
+    const videoFile = await saveBlobToTempFile(client, inputObject.content.source);
+    const tempOutputDir = fs.mkdtempSync(path.join(os.tmpdir(), 'video-rendition-'));
 
     try {
         // Get video metadata using command line ffprobe
@@ -208,26 +178,18 @@ export async function generateVideoRendition(
             timestamps.push(Math.max(timestamp, 1));
         }
 
-        log.info(
-            `Generating ${thumbnailCount} thumbnails for ${duration}s video`,
-            {
-                objectId,
-                duration,
-                thumbnailCount,
-                timestamps: timestamps.map((t) => Math.round(t)),
-                tempOutputDir,
-            },
-        );
+        log.info(`Generating ${thumbnailCount} thumbnails for ${duration}s video`, {
+            objectId,
+            duration,
+            thumbnailCount,
+            timestamps: timestamps.map((t) => Math.round(t)),
+            tempOutputDir,
+        });
 
         // Generate thumbnails using command line ffmpeg
         const generatedThumbnails = await Promise.all(
             timestamps.map(async (timestamp) => {
-                return await generateThumbnail(
-                    videoFile,
-                    tempOutputDir,
-                    timestamp,
-                    params.max_hw,
-                );
+                return await generateThumbnail(videoFile, tempOutputDir, timestamp, params.max_hw);
             }),
         );
 
@@ -237,28 +199,17 @@ export async function generateVideoRendition(
                 thumbnailCount,
                 tempOutputDir,
             });
-            throw new Error(
-                `No thumbnails were generated for video ${objectId}`,
-            );
+            throw new Error(`No thumbnails were generated for video ${objectId}`);
         }
 
-        renditionPages.push(
-            ...generatedThumbnails.filter(
-                (thumbnail) => thumbnail !== undefined,
-            ),
-        );
-        log.info(
-            `Successfully generated ${generatedThumbnails.length} thumbnails for ${objectId}`,
-            {
-                objectId,
-                generatedCount: generatedThumbnails.length,
-                requestedCount: thumbnailCount,
-            },
-        );
+        renditionPages.push(...generatedThumbnails.filter((thumbnail) => thumbnail !== undefined));
+        log.info(`Successfully generated ${generatedThumbnails.length} thumbnails for ${objectId}`, {
+            objectId,
+            generatedCount: generatedThumbnails.length,
+            requestedCount: thumbnailCount,
+        });
     } catch (error) {
-        log.error(
-            `Error generating thumbnails for video: ${error instanceof Error ? error.message : "Unknown 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 {
         // Clean up temporary video file
@@ -266,7 +217,7 @@ export async function generateVideoRendition(
             if (fs.existsSync(videoFile)) {
                 fs.unlinkSync(videoFile);
             }
-        } catch (cleanupError) {
+        } catch {
             log.warn(`Failed to cleanup temporary video file: ${videoFile}`);
         }
     }
@@ -277,17 +228,12 @@ export async function generateVideoRendition(
     const etag = inputObject.content.etag ?? inputObject.id;
 
     // Update the final upload call to handle multiple thumbnails
-    const uploaded = await uploadRenditionPages(
-        client,
-        etag,
-        renditionPages,
-        params,
-    );
+    const uploaded = await uploadRenditionPages(client, etag, renditionPages, params);
 
     return {
         uploads: uploaded.map((u) => u),
         format: params.format,
         thumbnailCount: renditionPages.length,
-        status: "success",
+        status: 'success',
     };
 }

package/src/activities/resolveRemoteActivities.test.ts

@@ -1,16 +1,20 @@
-import { MockActivityEnvironment } from "@temporalio/testing";
-import { ContentEventName, DSLActivityExecutionPayload } from "@vertesia/common";
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { resolveRemoteActivities, type RemoteActivityMap, ResolveRemoteActivitiesParams } from "./resolveRemoteActivities.js";
+import { MockActivityEnvironment } from '@temporalio/testing';
+import { ContentEventName, type DSLActivityExecutionPayload } from '@vertesia/common';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+    type RemoteActivityMap,
+    type ResolveRemoteActivitiesParams,
+    resolveRemoteActivities,
+} from './resolveRemoteActivities.js';
 
-vi.stubGlobal("fetch", vi.fn());
+vi.stubGlobal('fetch', vi.fn());
 
 // Mock getVertesiaClient
 const mockGetInstalledApps = vi.fn();
-vi.mock("../utils/client.js", () => ({
+vi.mock('../utils/client.js', () => ({
     getVertesiaClient: vi.fn().mockReturnValue({
         apps: {
-            getInstalledApps: (...args: any[]) => mockGetInstalledApps(...args),
+            getInstalledApps: (...args: unknown[]) => mockGetInstalledApps(...args),
             validateUrl: vi.fn().mockResolvedValue({ valid: true }),
         },
     }),
@@ -28,187 +32,191 @@ beforeEach(() => {
 });
 
 const createPayload = (): DSLActivityExecutionPayload<ResolveRemoteActivitiesParams> => ({
-    auth_token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.sig",
-    account_id: "acc-123",
-    project_id: "proj-456",
-    params: {},
+    auth_token:
+        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.sig',
+    account_id: 'acc-123',
+    project_id: 'proj-456',
+    params: {} satisfies ResolveRemoteActivitiesParams,
     config: {
-        studio_url: "http://mock-studio",
-        store_url: "http://mock-store",
+        studio_url: 'http://mock-studio',
+        store_url: 'http://mock-store',
     },
-    workflow_name: "TestWorkflow",
+    workflow_name: 'TestWorkflow',
     event: ContentEventName.create,
     objectIds: [],
     vars: {},
-    activity: { name: "resolveRemoteActivities", params: {} },
+    activity: { name: 'resolveRemoteActivities', params: {} satisfies ResolveRemoteActivitiesParams },
 });
 
-describe("resolveRemoteActivities", () => {
-    it("returns empty map when no apps installed", async () => {
+describe('resolveRemoteActivities', () => {
+    it('should return empty map when no apps installed', async () => {
         mockGetInstalledApps.mockResolvedValueOnce([]);
 
         const result: RemoteActivityMap = await testEnv.run(resolveRemoteActivities, createPayload());
         expect(result).toEqual({});
-        expect(mockGetInstalledApps).toHaveBeenCalledWith("tools");
+        expect(mockGetInstalledApps).toHaveBeenCalledWith('tools');
     });
 
-    it("returns qualified activity map from single app", async () => {
-        mockGetInstalledApps.mockResolvedValueOnce([{
-            id: "install-1",
-            manifest: {
-                name: "my-nlp-app",
-                endpoint: "https://nlp-server.test/api/package",
+    it('should return qualified activity map from single app', async () => {
+        mockGetInstalledApps.mockResolvedValueOnce([
+            {
+                id: 'install-1',
+                manifest: {
+                    name: 'my-nlp-app',
+                    endpoint: 'https://nlp-server.test/api/package',
+                },
+                settings: { api_key: 'test' },
             },
-            settings: { api_key: "test" },
-        }]);
+        ]);
 
         mockFetch.mockResolvedValueOnce(
             new Response(
                 JSON.stringify({
                     activities: [
-                        { name: "analyze_sentiment", description: "Analyze sentiment", collection: "nlp" },
-                        { name: "extract_entities", description: "Extract entities", collection: "nlp" },
+                        { name: 'analyze_sentiment', description: 'Analyze sentiment', collection: 'nlp' },
+                        { name: 'extract_entities', description: 'Extract entities', collection: 'nlp' },
                     ],
                 }),
-                { status: 200, headers: { "Content-Type": "application/json" } },
+                { status: 200, headers: { 'Content-Type': 'application/json' } },
             ),
         );
 
         const result: RemoteActivityMap = await testEnv.run(resolveRemoteActivities, createPayload());
 
         expect(Object.keys(result)).toHaveLength(2);
-        expect(result["app:my-nlp-app:nlp:analyze_sentiment"]).toBeDefined();
-        expect(result["app:my-nlp-app:nlp:extract_entities"]).toBeDefined();
-
-        const entry = result["app:my-nlp-app:nlp:analyze_sentiment"];
-        expect(entry.activity_name).toBe("analyze_sentiment");
-        expect(entry.app_name).toBe("my-nlp-app");
-        expect(entry.app_install_id).toBe("install-1");
-        expect(entry.app_settings).toEqual({ api_key: "test" });
+        expect(result['app:my-nlp-app:nlp:analyze_sentiment']).toBeDefined();
+        expect(result['app:my-nlp-app:nlp:extract_entities']).toBeDefined();
+
+        const entry = result['app:my-nlp-app:nlp:analyze_sentiment'];
+        expect(entry.activity_name).toBe('analyze_sentiment');
+        expect(entry.app_name).toBe('my-nlp-app');
+        expect(entry.app_install_id).toBe('install-1');
+        expect(entry.app_settings).toEqual({ api_key: 'test' });
         // URL should target the collection-specific endpoint
-        expect(entry.url).toBe("https://nlp-server.test/api/activities/nlp");
+        expect(entry.url).toBe('https://nlp-server.test/api/activities/nlp');
     });
 
-    it("merges activities from multiple apps", async () => {
+    it('should merge activities from multiple apps', async () => {
         mockGetInstalledApps.mockResolvedValueOnce([
             {
-                id: "install-1",
-                manifest: { name: "app-one", endpoint: "https://one.test/api/package" },
+                id: 'install-1',
+                manifest: { name: 'app-one', endpoint: 'https://one.test/api/package' },
             },
             {
-                id: "install-2",
-                manifest: { name: "app-two", endpoint: "https://two.test/api/package" },
+                id: 'install-2',
+                manifest: { name: 'app-two', endpoint: 'https://two.test/api/package' },
             },
         ]);
 
         mockFetch
             .mockResolvedValueOnce(
-                new Response(JSON.stringify({ activities: [{ name: "task_a", collection: "main" }] }), { status: 200 }),
+                new Response(JSON.stringify({ activities: [{ name: 'task_a', collection: 'main' }] }), { status: 200 }),
             )
             .mockResolvedValueOnce(
-                new Response(JSON.stringify({ activities: [{ name: "task_b", collection: "main" }] }), { status: 200 }),
+                new Response(JSON.stringify({ activities: [{ name: 'task_b', collection: 'main' }] }), { status: 200 }),
             );
 
         const result: RemoteActivityMap = await testEnv.run(resolveRemoteActivities, createPayload());
 
         expect(Object.keys(result)).toHaveLength(2);
-        expect(result["app:app-one:main:task_a"]).toBeDefined();
-        expect(result["app:app-two:main:task_b"]).toBeDefined();
+        expect(result['app:app-one:main:task_a']).toBeDefined();
+        expect(result['app:app-two:main:task_b']).toBeDefined();
     });
 
-    it("skips app with no activities", async () => {
-        mockGetInstalledApps.mockResolvedValueOnce([{
-            id: "install-1",
-            manifest: { name: "empty-app", endpoint: "https://empty.test/api/package" },
-        }]);
+    it('should skip app with no activities', async () => {
+        mockGetInstalledApps.mockResolvedValueOnce([
+            {
+                id: 'install-1',
+                manifest: { name: 'empty-app', endpoint: 'https://empty.test/api/package' },
+            },
+        ]);
 
-        mockFetch.mockResolvedValueOnce(
-            new Response(JSON.stringify({ activities: [] }), { status: 200 }),
-        );
+        mockFetch.mockResolvedValueOnce(new Response(JSON.stringify({ activities: [] }), { status: 200 }));
 
         const result: RemoteActivityMap = await testEnv.run(resolveRemoteActivities, createPayload());
         expect(result).toEqual({});
     });
 
-    it("skips app with no endpoint", async () => {
-        mockGetInstalledApps.mockResolvedValueOnce([{
-            id: "install-1",
-            manifest: { name: "no-endpoint" },
-        }]);
+    it('should skip app with no endpoint', async () => {
+        mockGetInstalledApps.mockResolvedValueOnce([
+            {
+                id: 'install-1',
+                manifest: { name: 'no-endpoint' },
+            },
+        ]);
 
         const result: RemoteActivityMap = await testEnv.run(resolveRemoteActivities, createPayload());
         expect(result).toEqual({});
         expect(mockFetch).not.toHaveBeenCalled();
     });
 
-    it("handles duplicate qualified names across apps (first wins)", async () => {
+    it('should handle duplicate qualified names across apps (first wins)', async () => {
         mockGetInstalledApps.mockResolvedValueOnce([
             {
-                id: "install-1",
-                manifest: { name: "same-app", endpoint: "https://one.test/api/package" },
+                id: 'install-1',
+                manifest: { name: 'same-app', endpoint: 'https://one.test/api/package' },
             },
             {
-                id: "install-2",
-                manifest: { name: "same-app", endpoint: "https://two.test/api/package" },
+                id: 'install-2',
+                manifest: { name: 'same-app', endpoint: 'https://two.test/api/package' },
             },
         ]);
 
         mockFetch
             .mockResolvedValueOnce(
-                new Response(JSON.stringify({ activities: [{ name: "task", collection: "main" }] }), { status: 200 }),
+                new Response(JSON.stringify({ activities: [{ name: 'task', collection: 'main' }] }), { status: 200 }),
             )
             .mockResolvedValueOnce(
-                new Response(JSON.stringify({ activities: [{ name: "task", collection: "main" }] }), { status: 200 }),
+                new Response(JSON.stringify({ activities: [{ name: 'task', collection: 'main' }] }), { status: 200 }),
             );
 
         const result: RemoteActivityMap = await testEnv.run(resolveRemoteActivities, createPayload());
         expect(Object.keys(result)).toHaveLength(1);
-        expect(result["app:same-app:main:task"].app_install_id).toBe("install-1");
+        expect(result['app:same-app:main:task'].app_install_id).toBe('install-1');
     });
 
-    it("continues with other apps when one fetch fails", async () => {
+    it('should continue with other apps when one fetch fails', async () => {
         mockGetInstalledApps.mockResolvedValueOnce([
             {
-                id: "install-1",
-                manifest: { name: "failing-app", endpoint: "https://fail.test/api/package" },
+                id: 'install-1',
+                manifest: { name: 'failing-app', endpoint: 'https://fail.test/api/package' },
             },
             {
-                id: "install-2",
-                manifest: { name: "working-app", endpoint: "https://work.test/api/package" },
+                id: 'install-2',
+                manifest: { name: 'working-app', endpoint: 'https://work.test/api/package' },
             },
         ]);
 
         mockFetch
-            .mockRejectedValueOnce(new Error("Connection refused"))
+            .mockRejectedValueOnce(new Error('Connection refused'))
             .mockResolvedValueOnce(
-                new Response(JSON.stringify({ activities: [{ name: "task", collection: "main" }] }), { status: 200 }),
+                new Response(JSON.stringify({ activities: [{ name: 'task', collection: 'main' }] }), { status: 200 }),
             );
 
         const result: RemoteActivityMap = await testEnv.run(resolveRemoteActivities, createPayload());
         expect(Object.keys(result)).toHaveLength(1);
-        expect(result["app:working-app:main:task"]).toBeDefined();
+        expect(result['app:working-app:main:task']).toBeDefined();
     });
 
-    it("returns empty map when getInstalledApps fails", async () => {
-        mockGetInstalledApps.mockRejectedValueOnce(new Error("API error"));
+    it('should return empty map when getInstalledApps fails', async () => {
+        mockGetInstalledApps.mockRejectedValueOnce(new Error('API error'));
 
         const result: RemoteActivityMap = await testEnv.run(resolveRemoteActivities, createPayload());
         expect(result).toEqual({});
     });
 
-    it("skips activities without collection", async () => {
-        mockGetInstalledApps.mockResolvedValueOnce([{
-            id: "install-1",
-            manifest: { name: "bad-app", endpoint: "https://bad.test/api/package" },
-        }]);
+    it('should skip activities without collection', async () => {
+        mockGetInstalledApps.mockResolvedValueOnce([
+            {
+                id: 'install-1',
+                manifest: { name: 'bad-app', endpoint: 'https://bad.test/api/package' },
+            },
+        ]);
 
         mockFetch.mockResolvedValueOnce(
             new Response(
                 JSON.stringify({
-                    activities: [
-                        { name: "no_collection" },
-                        { name: "has_collection", collection: "main" },
-                    ],
+                    activities: [{ name: 'no_collection' }, { name: 'has_collection', collection: 'main' }],
                 }),
                 { status: 200 },
             ),
@@ -216,6 +224,6 @@ describe("resolveRemoteActivities", () => {
 
         const result: RemoteActivityMap = await testEnv.run(resolveRemoteActivities, createPayload());
         expect(Object.keys(result)).toHaveLength(1);
-        expect(result["app:bad-app:main:has_collection"]).toBeDefined();
+        expect(result['app:bad-app:main:has_collection']).toBeDefined();
     });
 });