@outputai/core 0.1.12-next.ecd4dda.0 → 0.1.13-dev.01b8dea.0

package/bin/copy_assets.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { copyFileSync, mkdirSync, globSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+const srcDir = 'src';
+const destDir = 'dist';
+const matchers = [ '**/*.prompt', '**/*.yml.enc', '**/*.key', '**/*.md' ];
+
+for ( const pattern of matchers ) {
+  for ( const file of globSync( pattern, { cwd: srcDir } ) ) {
+    const src = join( srcDir, file );
+    const dest = join( destDir, file );
+    mkdirSync( dirname( dest ), { recursive: true } );
+    copyFileSync( src, dest );
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.1.12-next.ecd4dda.0",
+  "version": "0.1.13-dev.01b8dea.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -28,10 +28,11 @@
   "bin": {
     "output-worker": "./bin/worker.sh",
     "outputai": "./bin/worker.sh",
-    "output-healthcheck": "./bin/healthcheck.mjs"
+    "output-healthcheck": "./bin/healthcheck.mjs",
+    "output-copy-assets": "./bin/copy_assets.js"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "3.1018.0",
+    "@aws-sdk/client-s3": "3.1024.0",
     "@babel/generator": "7.29.1",
     "@babel/parser": "7.29.2",
     "@babel/traverse": "7.29.0",
@@ -43,7 +44,7 @@
     "@temporalio/workflow": "1.15.0",
     "redis": "5.11.0",
     "stacktrace-parser": "0.1.11",
-    "undici": "7.24.6",
+    "undici": "8.0.2",
     "winston": "3.19.0",
     "zod": "4.3.6"
   },

package/src/interface/validations/static.js

@@ -64,6 +64,7 @@ const baseSchema = z.strictObject( {
 const stepSchema = baseSchema;
 
 const workflowSchema = baseSchema.extend( {
+  aliases: z.array( z.string().regex( /^[a-z_][a-z0-9_]*$/i ) ).optional().default( [] ),
   options: baseSchema.shape.options.unwrap().extend( {
     disableTrace: z.boolean().optional().default( false )
   } ).optional()

package/src/interface/validations/static.spec.js

@@ -189,6 +189,37 @@ describe( 'interface/validator', () => {
     it( 'rejects non-boolean options.disableTrace', () => {
       expect( () => validateWorkflow( { ...validArgs, options: { disableTrace: 'yes' } } ) ).toThrow( StaticValidationError );
     } );
+
+    it( 'passes with valid aliases array', () => {
+      expect( () => validateWorkflow( { ...validArgs, aliases: [ 'old_name', 'legacy_v1' ] } ) ).not.toThrow();
+    } );
+
+    it( 'passes with empty aliases array', () => {
+      expect( () => validateWorkflow( { ...validArgs, aliases: [] } ) ).not.toThrow();
+    } );
+
+    it( 'passes without aliases (optional)', () => {
+      expect( () => validateWorkflow( { ...validArgs } ) ).not.toThrow();
+    } );
+
+    it( 'rejects aliases with invalid name pattern', () => {
+      expect( () => validateWorkflow( { ...validArgs, aliases: [ '-bad' ] } ) ).toThrow( StaticValidationError );
+    } );
+
+    it( 'rejects non-array aliases', () => {
+      expect( () => validateWorkflow( { ...validArgs, aliases: 'not_array' } ) ).toThrow( StaticValidationError );
+    } );
+  } );
+
+  describe( 'aliases rejected on steps and evaluators', () => {
+    it( 'validateStep rejects aliases due to strictObject', () => {
+      expect( () => validateStep( { ...validArgs, aliases: [ 'alias' ] } ) ).toThrow( StaticValidationError );
+    } );
+
+    it( 'validateEvaluator rejects aliases due to strictObject', () => {
+      const { outputSchema, ...evalArgs } = validArgs;
+      expect( () => validateEvaluator( { ...evalArgs, aliases: [ 'alias' ] } ) ).toThrow( StaticValidationError );
+    } );
   } );
 
   describe( 'validateEvaluator', () => {

package/src/interface/workflow.d.ts

@@ -270,4 +270,10 @@ export declare function workflow<
   outputSchema?: OutputSchema;
   fn: WorkflowFunction<InputSchema, OutputSchema>;
   options?: WorkflowOptions;
+
+  /**
+   * Alternative names that resolve to this workflow. Useful when renaming a workflow
+   * while maintaining backward compatibility with existing callers.
+   */
+  aliases?: string[];
 } ): WorkflowFunctionWrapper<WorkflowFunction<InputSchema, OutputSchema>>;

package/src/interface/workflow.js

@@ -22,8 +22,8 @@ const defaultOptions = {
   disableTrace: false
 };
 
-export function workflow( { name, description, inputSchema, outputSchema, fn, options = {} } ) {
-  validateWorkflow( { name, description, inputSchema, outputSchema, fn, options } );
+export function workflow( { name, description, inputSchema, outputSchema, fn, options = {}, aliases = [] } ) {
+  validateWorkflow( { name, description, inputSchema, outputSchema, fn, options, aliases } );
 
   const { disableTrace, activityOptions } = deepMerge( defaultOptions, options );
   const steps = proxyActivities( activityOptions );
@@ -123,6 +123,6 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
     }
   };
 
-  setMetadata( wrapper, { name, description, inputSchema, outputSchema } );
+  setMetadata( wrapper, { name, description, inputSchema, outputSchema, aliases } );
   return wrapper;
 };

package/src/interface/workflow.spec.js

@@ -140,7 +140,7 @@ describe( 'workflow()', () => {
       const symbols = Object.getOwnPropertySymbols( wf );
       expect( symbols ).toHaveLength( 1 );
       const meta = wf[symbols[0]];
-      expect( meta ).toEqual( { name: 'meta_wf', description: 'Meta workflow', inputSchema, outputSchema } );
+      expect( meta ).toEqual( { name: 'meta_wf', description: 'Meta workflow', inputSchema, outputSchema, aliases: [] } );
     } );
   } );
 

package/src/worker/catalog_workflow/catalog.js

@@ -97,6 +97,11 @@ export class CatalogWorkflow extends CatalogEntry {
    * @type {Array<CatalogActivity>}
    */
   activities;
+  /**
+   * Alternative names that resolve to this workflow.
+   * @type {Array<string>}
+   */
+  aliases;
 
   /**
    * @param {Object} params - Entry parameters.
@@ -106,9 +111,11 @@ export class CatalogWorkflow extends CatalogEntry {
    * @param {object} [params.outputSchema] - JSON schema describing the produced output.
    * @param {string} params.path - Absolute path of the entity in the file system.
    * @param {Array<CatalogActivity>} params.activities - Each activity of this workflow
+   * @param {Array<string>} [params.aliases] - Alternative names for this workflow
    */
-  constructor( { activities, ...args } ) {
+  constructor( { activities, aliases = [], ...args } ) {
     super( args );
     this.activities = activities;
+    this.aliases = aliases;
   };
 };

package/src/worker/catalog_workflow/index.spec.js

@@ -193,4 +193,27 @@ describe( 'createCatalog', () => {
     expect( workflows[0].path ).toBe( '/flows/flow1/workflow.js' );
     expect( workflows[1].path ).toBe( '/flows/flow2/workflow.js' );
   } );
+
+  it( 'includes aliases in catalog workflow entries', async () => {
+    const { createCatalog } = await import( './index.js' );
+
+    const workflows = [
+      {
+        name: 'flow1',
+        path: '/flows/flow1/workflow.js',
+        description: 'desc-flow1',
+        aliases: [ 'flow1_old', 'flow1_legacy' ]
+      },
+      {
+        name: 'flow2',
+        path: '/flows/flow2/workflow.js',
+        description: 'desc-flow2'
+      }
+    ];
+
+    const catalog = createCatalog( { workflows, activities: {} } );
+
+    expect( catalog.workflows[0].aliases ).toEqual( [ 'flow1_old', 'flow1_legacy' ] );
+    expect( catalog.workflows[1].aliases ).toEqual( [] );
+  } );
 } );

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/interceptors/activity.js

@@ -25,7 +25,13 @@ import { messageBus } from '#bus';
 export class ActivityExecutionInterceptor {
   constructor( { activities, workflows } ) {
     this.activities = activities;
-    this.workflowsMap = workflows.reduce( ( map, w ) => map.set( w.name, w ), new Map() );
+    this.workflowsMap = workflows.reduce( ( map, w ) => {
+      map.set( w.name, w );
+      for ( const alias of w.aliases ?? [] ) {
+        map.set( alias, w );
+      }
+      return map;
+    }, new Map() );
   };
 
   async execute( input, next ) {
@@ -33,11 +39,17 @@ export class ActivityExecutionInterceptor {
     const { workflowExecution: { workflowId }, activityId: id, activityType: name, workflowType: workflowName } = Context.current().info;
     const { executionContext } = headersToObject( input.headers );
     const { type: kind } = this.activities?.[name]?.[METADATA_ACCESS_SYMBOL];
-    const workflowFilename = this.workflowsMap.get( workflowName ).path;
 
     messageBus.emit( BusEventType.ACTIVITY_START, { id, name, kind, workflowId, workflowName } );
     Tracing.addEventStart( { id, name, kind, parentId: workflowId, details: input.args[0], executionContext } );
 
+    const workflowEntry = this.workflowsMap.get( workflowName );
+    if ( !workflowEntry ) {
+      const availableWorkflows = [ ...this.workflowsMap.keys() ].join( ', ' );
+      throw new Error( `Activity interceptor: workflow "${workflowName}" not found in workflowsMap. Available: [${availableWorkflows}]` );
+    }
+    const workflowFilename = workflowEntry.path;
+
     const intervals = { heartbeat: null };
     try {
       // Sends heartbeat to communicate that activity is still alive

package/src/worker/interceptors/activity.spec.js

@@ -191,6 +191,29 @@ describe( 'ActivityExecutionInterceptor', () => {
     expect( heartbeatMock ).not.toHaveBeenCalled();
   } );
 
+  it( 'resolves workflow alias in workflowsMap', async () => {
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const workflows = [ { name: 'myWorkflow', path: '/workflows/myWorkflow.js', aliases: [ 'myWorkflowOld' ] } ];
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows } );
+
+    // Override context to use alias as workflowType
+    contextInfoMock.workflowType = 'myWorkflowOld';
+    const next = vi.fn().mockResolvedValue( { result: 'ok' } );
+
+    const promise = interceptor.execute( makeInput(), next );
+    vi.advanceTimersByTime( 0 );
+    await promise;
+
+    // Should resolve to the correct path despite using the alias
+    expect( runWithContextMock ).toHaveBeenCalledWith(
+      expect.any( Function ),
+      expect.objectContaining( { workflowFilename: '/workflows/myWorkflow.js' } )
+    );
+
+    // Restore for other tests
+    contextInfoMock.workflowType = 'myWorkflow';
+  } );
+
   it( 'does not heartbeat when OUTPUT_ACTIVITY_HEARTBEAT_ENABLED is false', async () => {
     vi.stubEnv( 'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED', 'false' );
     const { ActivityExecutionInterceptor } = await import( './activity.js' );

package/src/worker/loader.js

@@ -132,6 +132,40 @@ export async function loadHooks( rootDir ) {
   }
 };
 
+/**
+ * Validates that all workflow names and aliases are unique across the project.
+ *
+ * @param {object[]} workflows
+ * @throws {Error} If any alias conflicts with a workflow name or another alias
+ */
+function validateWorkflowNames( workflows ) {
+  const allNames = new Map();
+
+  // Register primary names (case-insensitive to prevent confusing collisions)
+  for ( const { name } of workflows ) {
+    allNames.set( name.toLowerCase(), `workflow "${name}"` );
+  }
+
+  // Check the reserved catalog name
+  allNames.set( WORKFLOW_CATALOG.toLowerCase(), 'system workflow "$catalog"' );
+
+  // Check aliases against all names
+  for ( const { name, aliases = [] } of workflows ) {
+    const lowerCaseName = name.toLowerCase();
+    for ( const alias of aliases ) {
+      const lowerAliasName = alias.toLowerCase();
+      if ( lowerAliasName === lowerCaseName ) {
+        throw new Error( `Workflow "${name}" has an alias identical to its own name` );
+      }
+      const conflict = allNames.get( lowerAliasName );
+      if ( conflict ) {
+        throw new Error( `Alias "${alias}" on workflow "${name}" conflicts with ${conflict}` );
+      }
+      allNames.set( lowerAliasName, `alias "${alias}" on workflow "${name}"` );
+    }
+  }
+}
+
 /**
  * Creates a temporary index file importing all workflows for Temporal.
  *
@@ -139,11 +173,16 @@ export async function loadHooks( rootDir ) {
  * @returns
  */
 export function createWorkflowsEntryPoint( workflows ) {
+  validateWorkflowNames( workflows );
+
   const path = join( __dirname, 'temp', WORKFLOWS_INDEX_FILENAME );
 
   // default system catalog workflow
   const catalog = { name: WORKFLOW_CATALOG, path: join( __dirname, './catalog_workflow/workflow.js' ) };
-  const content = [ ... workflows, catalog ].map( ( { name, path } ) => `export { default as ${name} } from '${path}';` ).join( EOL );
+  const aliasExports = workflows.flatMap( ( { aliases = [], path } ) =>
+    aliases.map( alias => ( { name: alias, path } ) )
+  );
+  const content = [ ...workflows, ...aliasExports, catalog ].map( ( { name, path } ) => `export { default as ${name} } from '${path}';` ).join( EOL );
 
   mkdirSync( dirname( path ), { recursive: true } );
   writeFileSync( path, content, 'utf-8' );

package/src/worker/loader.spec.js

@@ -111,6 +111,65 @@ describe( 'worker/loader', () => {
     expect( fsMocks.mkdirSync ).toHaveBeenCalledTimes( 1 );
   } );
 
+  it( 'createWorkflowsEntryPoint generates alias exports', async () => {
+    const { createWorkflowsEntryPoint } = await import( './loader.js' );
+
+    const workflows = [ { name: 'W', path: '/abs/wf.js', aliases: [ 'W_old', 'W_legacy' ] } ];
+    createWorkflowsEntryPoint( workflows );
+
+    const [ , contents ] = fsMocks.writeFileSync.mock.calls[0];
+    expect( contents ).toContain( 'export { default as W } from \'/abs/wf.js\';' );
+    expect( contents ).toContain( 'export { default as W_old } from \'/abs/wf.js\';' );
+    expect( contents ).toContain( 'export { default as W_legacy } from \'/abs/wf.js\';' );
+  } );
+
+  it( 'createWorkflowsEntryPoint throws on alias conflicting with primary name', async () => {
+    const { createWorkflowsEntryPoint } = await import( './loader.js' );
+
+    const workflows = [
+      { name: 'alpha', path: '/a.js', aliases: [] },
+      { name: 'beta', path: '/b.js', aliases: [ 'alpha' ] }
+    ];
+    expect( () => createWorkflowsEntryPoint( workflows ) ).toThrow( /Alias "alpha" on workflow "beta" conflicts with workflow "alpha"/ );
+  } );
+
+  it( 'createWorkflowsEntryPoint throws on alias conflicting with another alias', async () => {
+    const { createWorkflowsEntryPoint } = await import( './loader.js' );
+
+    const workflows = [
+      { name: 'alpha', path: '/a.js', aliases: [ 'shared_alias' ] },
+      { name: 'beta', path: '/b.js', aliases: [ 'shared_alias' ] }
+    ];
+    expect( () => createWorkflowsEntryPoint( workflows ) ).toThrow( /Alias "shared_alias" on workflow "beta" conflicts with/ );
+  } );
+
+  it( 'createWorkflowsEntryPoint throws on alias identical to own name', async () => {
+    const { createWorkflowsEntryPoint } = await import( './loader.js' );
+
+    const workflows = [ { name: 'alpha', path: '/a.js', aliases: [ 'alpha' ] } ];
+    expect( () => createWorkflowsEntryPoint( workflows ) ).toThrow( /Workflow "alpha" has an alias identical to its own name/ );
+  } );
+
+  it( 'createWorkflowsEntryPoint catches case-insensitive alias collision with primary name', async () => {
+    const { createWorkflowsEntryPoint } = await import( './loader.js' );
+
+    const workflows = [
+      { name: 'Alpha', path: '/a.js', aliases: [] },
+      { name: 'beta', path: '/b.js', aliases: [ 'alpha' ] }
+    ];
+    expect( () => createWorkflowsEntryPoint( workflows ) ).toThrow( /Alias "alpha" on workflow "beta" conflicts with workflow "Alpha"/ );
+  } );
+
+  it( 'createWorkflowsEntryPoint catches case-insensitive alias-to-alias collision', async () => {
+    const { createWorkflowsEntryPoint } = await import( './loader.js' );
+
+    const workflows = [
+      { name: 'alpha', path: '/a.js', aliases: [ 'Legacy' ] },
+      { name: 'beta', path: '/b.js', aliases: [ 'legacy' ] }
+    ];
+    expect( () => createWorkflowsEntryPoint( workflows ) ).toThrow( /Alias "legacy" on workflow "beta" conflicts with/ );
+  } );
+
   it( 'loadActivities uses folder-based matchers for steps/evaluators and shared', async () => {
     const { loadActivities } = await import( './loader.js' );
     // First call (workflow dir): no results

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' );
   } );
 } );