@outputai/core 0.1.12-next.ecd4dda.0 → 0.1.13-next.6e35f5c.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-next.6e35f5c.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -28,7 +28,8 @@
   "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",

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/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