@outputai/core 0.1.13-dev.2f0a972.0 → 0.1.13-dev.59a1b6d.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.1.13-dev.2f0a972.0",
+  "version": "0.1.13-dev.59a1b6d.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -32,7 +32,7 @@
     "output-copy-assets": "./bin/copy_assets.js"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "3.1031.0",
+    "@aws-sdk/client-s3": "3.1024.0",
     "@babel/generator": "7.29.1",
     "@babel/parser": "7.29.2",
     "@babel/traverse": "7.29.0",
@@ -42,9 +42,9 @@
     "@temporalio/common": "1.15.0",
     "@temporalio/worker": "1.15.0",
     "@temporalio/workflow": "1.15.0",
-    "redis": "5.12.1",
+    "redis": "5.11.0",
     "stacktrace-parser": "0.1.11",
-    "undici": "8.1.0",
+    "undici": "8.0.2",
     "winston": "3.19.0",
     "zod": "4.3.6"
   },

package/src/worker/configs.js

@@ -26,7 +26,9 @@ const envVarSchema = z.object( {
   // Whether to send activity heartbeats (enabled by default)
   OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: z.transform( v => v === undefined ? true : isStringboolTrue( v ) ),
   // Time to allow for hooks to flush before shutdown
-  OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 3000 ) )
+  OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 3000 ) ),
+  // HTTP CONNECT proxy for Temporal gRPC connections (e.g. "proxy-host:8080")
+  TEMPORAL_GRPC_PROXY: z.string().optional()
 } );
 
 const { data: envVars, error } = envVarSchema.safeParse( process.env );
@@ -47,3 +49,4 @@ export const catalogId = envVars.OUTPUT_CATALOG_ID;
 export const activityHeartbeatIntervalMs = envVars.OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS;
 export const activityHeartbeatEnabled = envVars.OUTPUT_ACTIVITY_HEARTBEAT_ENABLED;
 export const processFailureShutdownDelay = envVars.OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY;
+export const grpcProxy = envVars.TEMPORAL_GRPC_PROXY;

package/src/worker/index.js

@@ -9,6 +9,7 @@ import { initInterceptors } from './interceptors.js';
 import { createChildLogger } from '#logger';
 import { registerShutdown } from './shutdown.js';
 import { startCatalog } from './start_catalog.js';
+import { bootstrapFetchProxy } from './proxy.js';
 import { messageBus } from '#bus';
 import './log_hooks.js';
 import { BusEventType } from '#consts';
@@ -24,6 +25,7 @@ const callerDir = process.argv[2];
     apiKey,
     namespace,
     taskQueue,
+    grpcProxy,
     maxConcurrentWorkflowTaskExecutions,
     maxConcurrentActivityTaskExecutions,
     maxCachedWorkflows,
@@ -41,6 +43,7 @@ const callerDir = process.argv[2];
   const activities = await loadActivities( callerDir, workflows );
 
   messageBus.emit( BusEventType.WORKER_BEFORE_START );
+  bootstrapFetchProxy();
 
   log.info( 'Creating worker entry point...' );
   const workflowsPath = createWorkflowsEntryPoint( workflows );
@@ -52,8 +55,8 @@ const callerDir = process.argv[2];
   const catalog = createCatalog( { workflows, activities } );
 
   log.info( 'Connecting Temporal...' );
-  // Enable TLS when connecting to remote Temporal (API key present)
-  const connection = await NativeConnection.connect( { address, tls: Boolean( apiKey ), apiKey } );
+  const proxy = grpcProxy ? { type: 'http-connect', targetHost: grpcProxy } : undefined;
+  const connection = await NativeConnection.connect( { address, tls: Boolean( apiKey ), apiKey, proxy } );
 
   log.info( 'Creating worker...' );
   const worker = await Worker.create( {

package/src/worker/index.spec.js

@@ -16,6 +16,7 @@ const configValues = {
   namespace: 'default',
   taskQueue: 'test-queue',
   catalogId: 'test-catalog',
+  grpcProxy: undefined,
   maxConcurrentWorkflowTaskExecutions: 200,
   maxConcurrentActivityTaskExecutions: 40,
   maxCachedWorkflows: 1000,
@@ -52,6 +53,9 @@ vi.mock( './interceptors.js', () => ( { initInterceptors: initInterceptorsMock }
 const startCatalogMock = vi.fn().mockResolvedValue( undefined );
 vi.mock( './start_catalog.js', () => ( { startCatalog: startCatalogMock } ) );
 
+const bootstrapFetchProxyMock = vi.fn();
+vi.mock( './proxy.js', () => ( { bootstrapFetchProxy: bootstrapFetchProxyMock } ) );
+
 const registerShutdownMock = vi.fn();
 vi.mock( './shutdown.js', () => ( { registerShutdown: registerShutdownMock } ) );
 
@@ -104,7 +108,8 @@ describe( 'worker/index', () => {
     expect( NativeConnection.connect ).toHaveBeenCalledWith( {
       address: configValues.address,
       tls: false,
-      apiKey: undefined
+      apiKey: undefined,
+      proxy: undefined
     } );
     expect( Worker.create ).toHaveBeenCalledWith( expect.objectContaining( {
       namespace: configValues.namespace,

package/src/worker/proxy.js

@@ -0,0 +1,16 @@
+import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
+import { createChildLogger } from '#logger';
+
+const log = createChildLogger( 'Proxy' );
+
+export const bootstrapFetchProxy = () => {
+  const proxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy ||
+    process.env.HTTP_PROXY || process.env.http_proxy;
+
+  if ( !proxyUrl ) {
+    return;
+  }
+
+  log.info( 'Routing fetch() through HTTP proxy', { proxyUrl } );
+  setGlobalDispatcher( new EnvHttpProxyAgent() );
+};

package/src/worker/proxy.spec.js

@@ -0,0 +1,63 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const mockSetGlobalDispatcher = vi.fn();
+const MockEnvHttpProxyAgent = vi.fn();
+
+vi.mock( 'undici', () => ( {
+  EnvHttpProxyAgent: MockEnvHttpProxyAgent,
+  setGlobalDispatcher: mockSetGlobalDispatcher
+} ) );
+
+vi.mock( '#logger', () => ( {
+  createChildLogger: () => ( { info: vi.fn(), warn: vi.fn(), error: vi.fn() } )
+} ) );
+
+describe( 'worker/proxy', () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach( () => {
+    vi.clearAllMocks();
+    delete process.env.HTTPS_PROXY;
+    delete process.env.https_proxy;
+    delete process.env.HTTP_PROXY;
+    delete process.env.http_proxy;
+  } );
+
+  afterEach( () => {
+    process.env = { ...originalEnv };
+  } );
+
+  it( 'does nothing when no proxy env vars are set', async () => {
+    const { bootstrapFetchProxy } = await import( './proxy.js' );
+    bootstrapFetchProxy();
+
+    expect( mockSetGlobalDispatcher ).not.toHaveBeenCalled();
+  } );
+
+  it( 'sets global dispatcher when HTTPS_PROXY is set', async () => {
+    process.env.HTTPS_PROXY = 'http://proxy:8080';
+    const { bootstrapFetchProxy } = await import( './proxy.js' );
+    bootstrapFetchProxy();
+
+    expect( MockEnvHttpProxyAgent ).toHaveBeenCalled();
+    expect( mockSetGlobalDispatcher ).toHaveBeenCalledTimes( 1 );
+  } );
+
+  it( 'sets global dispatcher when HTTP_PROXY is set', async () => {
+    process.env.HTTP_PROXY = 'http://proxy:8080';
+    const { bootstrapFetchProxy } = await import( './proxy.js' );
+    bootstrapFetchProxy();
+
+    expect( MockEnvHttpProxyAgent ).toHaveBeenCalled();
+    expect( mockSetGlobalDispatcher ).toHaveBeenCalledTimes( 1 );
+  } );
+
+  it( 'prefers HTTPS_PROXY over HTTP_PROXY for detection', async () => {
+    process.env.HTTPS_PROXY = 'http://secure-proxy:8080';
+    process.env.HTTP_PROXY = 'http://plain-proxy:8080';
+    const { bootstrapFetchProxy } = await import( './proxy.js' );
+    bootstrapFetchProxy();
+
+    expect( mockSetGlobalDispatcher ).toHaveBeenCalledTimes( 1 );
+  } );
+} );

package/src/worker/start_catalog.js

@@ -1,4 +1,4 @@
-import { Client, WorkflowNotFoundError } from '@temporalio/client';
+import { Client } from '@temporalio/client';
 import { WorkflowIdConflictPolicy } from '@temporalio/common';
 import { WORKFLOW_CATALOG } from '#consts';
 import { catalogId, taskQueue } from './configs.js';
@@ -8,29 +8,12 @@ const log = createChildLogger( 'Catalog' );
 
 export const startCatalog = async ( { connection, namespace, catalog } ) => {
   const client = new Client( { connection, namespace } );
-  const catalogWorkflowHandle = client.workflow.getHandle( catalogId );
-
-  try {
-    const catalogWorkflowDescription = await catalogWorkflowHandle.describe();
-    if ( !catalogWorkflowDescription.closeTime ) {
-      log.info( 'Completing previous catalog workflow...' );
-      await catalogWorkflowHandle.executeUpdate( 'complete', { args: [] } );
-    }
-  } catch ( error ) {
-    // When "not found", it's either a cold start or the catalog was already stopped/terminated, ignore it.
-    // Otherwise, create a log and try the next operation:
-    // A. If the workflow is still running, the start() will fail and throw;
-    // B. If the workflow is no running, the start() will succeed, and the error was transient;
-    if ( !( error instanceof WorkflowNotFoundError ) ) {
-      log.warn( 'Error interacting with previous catalog workflow', { error } );
-    }
-  }
 
   log.info( 'Starting catalog workflow...' );
   await client.workflow.start( WORKFLOW_CATALOG, {
     taskQueue,
-    workflowId: catalogId, // use the name of the task queue as the catalog name, ensuring uniqueness
-    workflowIdConflictPolicy: WorkflowIdConflictPolicy.FAIL,
+    workflowId: catalogId,
+    workflowIdConflictPolicy: WorkflowIdConflictPolicy.TERMINATE_EXISTING,
     args: [ catalog ]
   } );
 };

package/src/worker/start_catalog.spec.js

@@ -1,5 +1,4 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { WorkflowNotFoundError } from '@temporalio/client';
 
 const mockLog = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
 vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
@@ -10,25 +9,18 @@ const catalogId = 'test-catalog';
 const taskQueue = 'test-queue';
 vi.mock( './configs.js', () => ( { catalogId, taskQueue } ) );
 
-const describeMock = vi.fn();
-const executeUpdateMock = vi.fn();
 const workflowStartMock = vi.fn().mockResolvedValue( undefined );
 vi.mock( '@temporalio/client', async importOriginal => {
   const actual = await importOriginal();
   return {
     ...actual,
     Client: vi.fn().mockImplementation( function () {
-      return {
-        workflow: {
-          start: workflowStartMock,
-          getHandle: () => ( { describe: describeMock, executeUpdate: executeUpdateMock } )
-        }
-      };
+      return { workflow: { start: workflowStartMock } };
     } )
   };
 } );
 
-vi.mock( '@temporalio/common', () => ( { WorkflowIdConflictPolicy: { FAIL: 'FAIL' } } ) );
+vi.mock( '@temporalio/common', () => ( { WorkflowIdConflictPolicy: { TERMINATE_EXISTING: 'TERMINATE_EXISTING' } } ) );
 
 describe( 'worker/start_catalog', () => {
   const mockConnection = {};
@@ -40,79 +32,24 @@ describe( 'worker/start_catalog', () => {
     workflowStartMock.mockResolvedValue( undefined );
   } );
 
-  it( 'when previous catalog still running: completes it then starts catalog workflow', async () => {
-    describeMock.mockResolvedValue( { closeTime: undefined } );
-    executeUpdateMock.mockResolvedValue( undefined );
-
-    const { startCatalog } = await import( './start_catalog.js' );
-    await startCatalog( { connection: mockConnection, namespace, catalog } );
-
-    expect( describeMock ).toHaveBeenCalled();
-    expect( mockLog.info ).toHaveBeenCalledWith( 'Completing previous catalog workflow...' );
-    expect( executeUpdateMock ).toHaveBeenCalledWith( 'complete', { args: [] } );
-    expect( mockLog.info ).toHaveBeenCalledWith( 'Starting catalog workflow...' );
-    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', {
-      taskQueue,
-      workflowId: catalogId,
-      workflowIdConflictPolicy: 'FAIL',
-      args: [ catalog ]
-    } );
-  } );
-
-  it( 'when no previous catalog: ignores and starts catalog workflow', async () => {
-    describeMock.mockRejectedValue( new WorkflowNotFoundError( 'not found' ) );
-
-    const { startCatalog } = await import( './start_catalog.js' );
-    await startCatalog( { connection: mockConnection, namespace, catalog } );
-
-    expect( describeMock ).toHaveBeenCalled();
-    expect( mockLog.warn ).not.toHaveBeenCalled();
-    expect( mockLog.info ).toHaveBeenCalledWith( 'Starting catalog workflow...' );
-    expect( executeUpdateMock ).not.toHaveBeenCalled();
-    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', {
-      taskQueue,
-      workflowId: catalogId,
-      workflowIdConflictPolicy: 'FAIL',
-      args: [ catalog ]
-    } );
-  } );
-
-  it( 'when previous catalog already closed: skips complete and starts catalog workflow', async () => {
-    describeMock.mockResolvedValue( { closeTime: '2024-01-01T00:00:00Z' } );
-
+  it( 'starts catalog workflow with TERMINATE_EXISTING policy', async () => {
     const { startCatalog } = await import( './start_catalog.js' );
     await startCatalog( { connection: mockConnection, namespace, catalog } );
 
-    expect( describeMock ).toHaveBeenCalled();
-    expect( mockLog.info ).not.toHaveBeenCalledWith( 'Completing previous catalog workflow...' );
-    expect( executeUpdateMock ).not.toHaveBeenCalled();
     expect( mockLog.info ).toHaveBeenCalledWith( 'Starting catalog workflow...' );
     expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', {
       taskQueue,
       workflowId: catalogId,
-      workflowIdConflictPolicy: 'FAIL',
+      workflowIdConflictPolicy: 'TERMINATE_EXISTING',
       args: [ catalog ]
     } );
   } );
 
-  it( 'when describe or complete fails with other error: logs warn and still starts catalog workflow', async () => {
-    describeMock.mockResolvedValue( { closeTime: undefined } );
-    executeUpdateMock.mockRejectedValue( new Error( 'Connection refused' ) );
+  it( 'propagates errors from workflow.start', async () => {
+    workflowStartMock.mockRejectedValue( new Error( 'Connection refused' ) );
 
     const { startCatalog } = await import( './start_catalog.js' );
-    await startCatalog( { connection: mockConnection, namespace, catalog } );
-
-    expect( describeMock ).toHaveBeenCalled();
-    expect( executeUpdateMock ).toHaveBeenCalledWith( 'complete', { args: [] } );
-    expect( mockLog.warn ).toHaveBeenCalledWith( 'Error interacting with previous catalog workflow', {
-      error: expect.any( Error )
-    } );
-    expect( mockLog.info ).toHaveBeenCalledWith( 'Starting catalog workflow...' );
-    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', {
-      taskQueue,
-      workflowId: catalogId,
-      workflowIdConflictPolicy: 'FAIL',
-      args: [ catalog ]
-    } );
+    await expect( startCatalog( { connection: mockConnection, namespace, catalog } ) )
+      .rejects.toThrow( 'Connection refused' );
   } );
 } );