@auto-engineer/pipeline 1.74.0 → 1.76.0

package/package.json

@@ -13,8 +13,8 @@
     "get-port": "^7.1.0",
     "jose": "^5.9.6",
     "nanoid": "^5.0.0",
-    "@auto-engineer/file-store": "1.74.0",
-    "@auto-engineer/message-bus": "1.74.0"
+    "@auto-engineer/file-store": "1.76.0",
+    "@auto-engineer/message-bus": "1.76.0"
   },
   "devDependencies": {
     "@types/cors": "^2.8.17",
@@ -23,7 +23,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.74.0",
+  "version": "1.76.0",
   "scripts": {
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts",
     "test": "vitest run --reporter=dot",

package/src/projections/item-status-projection.specs.ts

@@ -126,5 +126,88 @@ describe('ItemStatusProjection', () => {
         attemptCount: 2,
       });
     });
+
+    it('sets startedAt when status becomes running', () => {
+      const now = new Date('2025-01-01T00:00:00Z');
+      const event: ItemStatusChangedEvent = {
+        type: 'ItemStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandType: 'ProcessItem',
+          itemKey: 'item-1',
+          requestId: 'req-1',
+          status: 'running',
+          attemptCount: 1,
+          timestamp: now.toISOString(),
+        },
+      };
+
+      const result = evolve(null, event);
+
+      expect(result.startedAt).toEqual(now.toISOString());
+      expect(result.endedAt).toBeUndefined();
+    });
+
+    it('sets endedAt when status becomes success', () => {
+      const startTime = new Date('2025-01-01T00:00:00Z');
+      const endTime = new Date('2025-01-01T00:00:05Z');
+      const existing: ItemStatusDocument = {
+        correlationId: 'c1',
+        commandType: 'ProcessItem',
+        itemKey: 'item-1',
+        currentRequestId: 'req-1',
+        status: 'running',
+        attemptCount: 1,
+        startedAt: startTime.toISOString(),
+      };
+      const event: ItemStatusChangedEvent = {
+        type: 'ItemStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandType: 'ProcessItem',
+          itemKey: 'item-1',
+          requestId: 'req-1',
+          status: 'success',
+          attemptCount: 1,
+          timestamp: endTime.toISOString(),
+        },
+      };
+
+      const result = evolve(existing, event);
+
+      expect(result.startedAt).toEqual(startTime.toISOString());
+      expect(result.endedAt).toEqual(endTime.toISOString());
+    });
+
+    it('sets endedAt when status becomes error', () => {
+      const startTime = new Date('2025-01-01T00:00:00Z');
+      const endTime = new Date('2025-01-01T00:00:03Z');
+      const existing: ItemStatusDocument = {
+        correlationId: 'c1',
+        commandType: 'ProcessItem',
+        itemKey: 'item-1',
+        currentRequestId: 'req-1',
+        status: 'running',
+        attemptCount: 1,
+        startedAt: startTime.toISOString(),
+      };
+      const event: ItemStatusChangedEvent = {
+        type: 'ItemStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandType: 'ProcessItem',
+          itemKey: 'item-1',
+          requestId: 'req-1',
+          status: 'error',
+          attemptCount: 1,
+          timestamp: endTime.toISOString(),
+        },
+      };
+
+      const result = evolve(existing, event);
+
+      expect(result.startedAt).toEqual(startTime.toISOString());
+      expect(result.endedAt).toEqual(endTime.toISOString());
+    });
   });
 });

package/src/projections/item-status-projection.ts

@@ -6,6 +6,8 @@ export interface ItemStatusDocument {
   currentRequestId: string;
   status: 'running' | 'success' | 'error';
   attemptCount: number;
+  startedAt?: string;
+  endedAt?: string;
 }
 
 export interface ItemStatusChangedEvent {
@@ -17,11 +19,12 @@ export interface ItemStatusChangedEvent {
     requestId: string;
     status: 'running' | 'success' | 'error';
     attemptCount: number;
+    timestamp?: string;
   };
 }
 
-export function evolve(_document: ItemStatusDocument | null, event: ItemStatusChangedEvent): ItemStatusDocument {
-  return {
+export function evolve(document: ItemStatusDocument | null, event: ItemStatusChangedEvent): ItemStatusDocument {
+  const base: ItemStatusDocument = {
     correlationId: event.data.correlationId,
     commandType: event.data.commandType,
     itemKey: event.data.itemKey,
@@ -29,4 +32,13 @@ export function evolve(_document: ItemStatusDocument | null, event: ItemStatusCh
     status: event.data.status,
     attemptCount: event.data.attemptCount,
   };
+
+  if (event.data.status === 'running') {
+    base.startedAt = event.data.timestamp;
+  } else {
+    base.startedAt = document?.startedAt;
+    base.endedAt = event.data.timestamp;
+  }
+
+  return base;
 }

package/src/projections/message-log-projection.ts

@@ -50,6 +50,7 @@ export interface NodeStatusChangedLogEvent {
     previousStatus: NodeStatus;
     pendingCount: number;
     endedCount: number;
+    lastDurationMs?: number;
   };
 }
 
@@ -107,6 +108,7 @@ export function evolve(_document: MessageLogDocument | null, event: MessageLogEv
       previousStatus: event.data.previousStatus,
       pendingCount: event.data.pendingCount,
       endedCount: event.data.endedCount,
+      lastDurationMs: event.data.lastDurationMs,
     },
     timestamp: new Date(),
   };

package/src/projections/node-status-projection.specs.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest';
+import type { NodeStatus } from '../graph/types';
+import { evolve, type NodeStatusChangedEvent, type NodeStatusDocument } from './node-status-projection';
+
+describe('NodeStatusProjection', () => {
+  describe('evolve', () => {
+    it('creates node document from event', () => {
+      const event: NodeStatusChangedEvent = {
+        type: 'NodeStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandName: 'RunCmd',
+          nodeId: 'cmd:RunCmd',
+          status: 'running' as NodeStatus,
+          previousStatus: 'idle' as NodeStatus,
+          pendingCount: 1,
+          endedCount: 0,
+        },
+      };
+
+      const result = evolve(null, event);
+
+      expect(result).toEqual({
+        correlationId: 'c1',
+        commandName: 'RunCmd',
+        status: 'running',
+        pendingCount: 1,
+        endedCount: 0,
+        lastDurationMs: undefined,
+      });
+    });
+
+    it('stores lastDurationMs when provided in event', () => {
+      const event: NodeStatusChangedEvent = {
+        type: 'NodeStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandName: 'RunCmd',
+          nodeId: 'cmd:RunCmd',
+          status: 'success' as NodeStatus,
+          previousStatus: 'running' as NodeStatus,
+          pendingCount: 0,
+          endedCount: 1,
+          lastDurationMs: 5000,
+        },
+      };
+
+      const result = evolve(null, event);
+
+      expect(result.lastDurationMs).toBe(5000);
+    });
+
+    it('preserves lastDurationMs from existing document when event has none', () => {
+      const existing: NodeStatusDocument = {
+        correlationId: 'c1',
+        commandName: 'RunCmd',
+        status: 'success' as NodeStatus,
+        pendingCount: 0,
+        endedCount: 1,
+        lastDurationMs: 3000,
+      };
+      const event: NodeStatusChangedEvent = {
+        type: 'NodeStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandName: 'RunCmd',
+          nodeId: 'cmd:RunCmd',
+          status: 'running' as NodeStatus,
+          previousStatus: 'success' as NodeStatus,
+          pendingCount: 1,
+          endedCount: 1,
+        },
+      };
+
+      const result = evolve(existing, event);
+
+      expect(result.lastDurationMs).toBe(3000);
+    });
+
+    it('overwrites lastDurationMs when event provides new value', () => {
+      const existing: NodeStatusDocument = {
+        correlationId: 'c1',
+        commandName: 'RunCmd',
+        status: 'success' as NodeStatus,
+        pendingCount: 0,
+        endedCount: 1,
+        lastDurationMs: 3000,
+      };
+      const event: NodeStatusChangedEvent = {
+        type: 'NodeStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandName: 'RunCmd',
+          nodeId: 'cmd:RunCmd',
+          status: 'success' as NodeStatus,
+          previousStatus: 'running' as NodeStatus,
+          pendingCount: 0,
+          endedCount: 2,
+          lastDurationMs: 7000,
+        },
+      };
+
+      const result = evolve(existing, event);
+
+      expect(result.lastDurationMs).toBe(7000);
+    });
+  });
+});

package/src/projections/node-status-projection.ts

@@ -7,6 +7,7 @@ export interface NodeStatusDocument {
   status: NodeStatus;
   pendingCount: number;
   endedCount: number;
+  lastDurationMs?: number;
 }
 
 export interface NodeStatusChangedEvent {
@@ -19,15 +20,17 @@ export interface NodeStatusChangedEvent {
     previousStatus: NodeStatus;
     pendingCount: number;
     endedCount: number;
+    lastDurationMs?: number;
   };
 }
 
-export function evolve(_document: NodeStatusDocument | null, event: NodeStatusChangedEvent): NodeStatusDocument {
+export function evolve(document: NodeStatusDocument | null, event: NodeStatusChangedEvent): NodeStatusDocument {
   return {
     correlationId: event.data.correlationId,
     commandName: event.data.commandName,
     status: event.data.status,
     pendingCount: event.data.pendingCount,
     endedCount: event.data.endedCount,
+    lastDurationMs: event.data.lastDurationMs ?? document?.lastDurationMs,
   };
 }

package/src/server/pipeline-server.specs.ts

@@ -33,6 +33,7 @@ interface GraphNode {
   status?: string;
   pendingCount?: number;
   endedCount?: number;
+  lastDurationMs?: number;
 }
 
 interface PipelineResponse {
@@ -1852,6 +1853,81 @@ describe('PipelineServer', () => {
       await server.stop();
     });
 
+    it('should include lastDurationMs in pipeline graph after command completes', async () => {
+      const handler = {
+        name: 'DurationCmd',
+        events: ['DurationDone'],
+        handle: async () => {
+          await new Promise((r) => setTimeout(r, 10));
+          return { type: 'DurationDone', data: {} };
+        },
+      };
+      const pipeline = define('test').on('Trigger').emit('DurationCmd', {}).build();
+      const server = new PipelineServer({ port: 0 });
+      server.registerCommandHandlers([handler]);
+      server.registerPipeline(pipeline);
+      server.registerItemKeyExtractor('DurationCmd', (d) => (d as { id?: string }).id);
+      await server.start();
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'DurationCmd', data: { id: 'item-1' } }),
+      });
+
+      await new Promise((r) => setTimeout(r, 200));
+
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
+      const cmdNode = data.nodes.find((n) => n.id === 'cmd:DurationCmd');
+      expect(cmdNode).toBeDefined();
+      expect(cmdNode?.lastDurationMs).toBeTypeOf('number');
+      expect(cmdNode?.lastDurationMs).toBeGreaterThanOrEqual(0);
+
+      await server.stop();
+    });
+
+    it('should include lastDurationMs in NodeStatusChanged events on completion', async () => {
+      const handler = {
+        name: 'DurationEvtCmd',
+        events: ['DurationEvtDone'],
+        handle: async () => {
+          await new Promise((r) => setTimeout(r, 10));
+          return { type: 'DurationEvtDone', data: {} };
+        },
+      };
+      const pipeline = define('test').on('Trigger').emit('DurationEvtCmd', {}).build();
+      const server = new PipelineServer({ port: 0 });
+      server.registerCommandHandlers([handler]);
+      server.registerPipeline(pipeline);
+      server.registerItemKeyExtractor('DurationEvtCmd', (d) => (d as { id?: string }).id);
+      await server.start();
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'DurationEvtCmd', data: { id: 'item-1' } }),
+      });
+
+      await new Promise((r) => setTimeout(r, 200));
+
+      const msgs = await fetchAs<StoredMessage[]>(`http://localhost:${server.port}/messages`);
+      type NodeStatusChangedMessage = {
+        type: string;
+        data?: {
+          status?: string;
+          lastDurationMs?: number;
+        };
+      };
+      const nodeStatusChanged = msgs.filter((m) => m.message.type === 'NodeStatusChanged');
+      const successEvent = nodeStatusChanged.find(
+        (m) => (m.message as NodeStatusChangedMessage).data?.status === 'success',
+      );
+      expect(successEvent).toBeDefined();
+      expect((successEvent?.message as NodeStatusChangedMessage).data?.lastDurationMs).toBeTypeOf('number');
+
+      await server.stop();
+    });
+
     it('should use requestId as fallback when no itemKey extractor is registered', async () => {
       const handler = {
         name: 'NoExtractorCmd',

package/src/server/pipeline-server.ts

@@ -46,6 +46,10 @@ interface EventWithCorrelation extends Event {
   correlationId: string;
 }
 
+interface GraphNodeWithDuration extends GraphNode {
+  lastDurationMs?: number;
+}
+
 export class PipelineServer {
   private app: express.Application;
   private httpServer: HttpServer;
@@ -370,6 +374,7 @@ export class PipelineServer {
           messageType: m.messageType,
           revision: String(index),
           position: String(index),
+          timestamp: m.timestamp,
         }));
         res.json(serialized);
       })();
@@ -494,17 +499,19 @@ export class PipelineServer {
     };
   }
 
-  private async addStatusToCommandNode(node: GraphNode, correlationId?: string): Promise<GraphNode> {
+  private async addStatusToCommandNode(node: GraphNode, correlationId?: string): Promise<GraphNodeWithDuration> {
     const commandName = node.id.replace(/^cmd:/, '');
     if (correlationId === undefined) {
       return { ...node, status: 'idle' as NodeStatus, pendingCount: 0, endedCount: 0 };
     }
     const stats = await this.computeCommandStats(correlationId, commandName);
+    const nodeStatus = await this.eventStoreContext.readModel.getNodeStatus(correlationId, commandName);
     return {
       ...node,
       status: stats.aggregateStatus,
       pendingCount: stats.pendingCount,
       endedCount: stats.endedCount,
+      lastDurationMs: nodeStatus?.lastDurationMs,
     };
   }
 
@@ -541,6 +548,7 @@ export class PipelineServer {
           requestId,
           status,
           attemptCount,
+          timestamp: new Date().toISOString(),
         },
       },
     ]);
@@ -551,6 +559,7 @@ export class PipelineServer {
     commandName: string,
     status: NodeStatus,
     previousStatus: NodeStatus,
+    lastDurationMs?: number,
   ): Promise<void> {
     const stats = await this.computeCommandStats(correlationId, commandName);
     await this.eventStoreContext.eventStore.appendToStream(`pipeline-${correlationId}`, [
@@ -564,6 +573,7 @@ export class PipelineServer {
           previousStatus,
           pendingCount: stats.pendingCount,
           endedCount: stats.endedCount,
+          lastDurationMs,
         },
       },
     ]);
@@ -621,11 +631,16 @@ export class PipelineServer {
     ]);
   }
 
-  private async updateNodeStatus(correlationId: string, commandName: string, status: NodeStatus): Promise<void> {
+  private async updateNodeStatus(
+    correlationId: string,
+    commandName: string,
+    status: NodeStatus,
+    lastDurationMs?: number,
+  ): Promise<void> {
     const existing = await this.eventStoreContext.readModel.getNodeStatus(correlationId, commandName);
     const previousStatus: NodeStatus = existing?.status ?? 'idle';
-    await this.emitNodeStatusChanged(correlationId, commandName, status, previousStatus);
-    await this.broadcastNodeStatusChanged(correlationId, commandName, status, previousStatus);
+    await this.emitNodeStatusChanged(correlationId, commandName, status, previousStatus, lastDurationMs);
+    await this.broadcastNodeStatusChanged(correlationId, commandName, status, previousStatus, lastDurationMs);
   }
 
   private async broadcastNodeStatusChanged(
@@ -633,6 +648,7 @@ export class PipelineServer {
     commandName: string,
     status: NodeStatus,
     previousStatus: NodeStatus,
+    lastDurationMs?: number,
   ): Promise<void> {
     const stats = await this.computeCommandStats(correlationId, commandName);
     const event: Event & { correlationId: string } = {
@@ -643,6 +659,7 @@ export class PipelineServer {
         previousStatus,
         pendingCount: stats.pendingCount,
         endedCount: stats.endedCount,
+        lastDurationMs,
       },
       correlationId,
     };
@@ -1022,7 +1039,16 @@ export class PipelineServer {
 
     const finalStatus = this.getStatusFromEvents(events);
     await this.updateItemStatus(this.currentSessionId, command.type, itemKey, finalStatus);
-    await this.updateNodeStatus(this.currentSessionId, command.type, finalStatus);
+    const completedItem = await this.eventStoreContext.readModel.getItemStatus(
+      this.currentSessionId,
+      command.type,
+      itemKey,
+    );
+    let durationMs: number | undefined;
+    if (completedItem?.startedAt && completedItem?.endedAt) {
+      durationMs = new Date(completedItem.endedAt).getTime() - new Date(completedItem.startedAt).getTime();
+    }
+    await this.updateNodeStatus(this.currentSessionId, command.type, finalStatus, durationMs);
 
     const eventsWithIds: EventWithCorrelation[] = events.map((event) => ({
       ...event,

package/src/store/pipeline-read-model.ts

@@ -91,6 +91,7 @@ export class PipelineReadModel {
       status: node.status,
       pendingCount: node.pendingCount,
       endedCount: node.endedCount,
+      lastDurationMs: node.lastDurationMs,
     };
   }
 
@@ -109,6 +110,8 @@ export class PipelineReadModel {
       currentRequestId: item.currentRequestId,
       status: item.status,
       attemptCount: item.attemptCount,
+      startedAt: item.startedAt,
+      endedAt: item.endedAt,
     };
   }