@auto-engineer/pipeline 1.71.0 → 1.72.0

package/src/server/pipeline-server.ts

@@ -20,6 +20,7 @@ import type { EventDefinition } from '../runtime/event-command-map';
 import { EventCommandMapper } from '../runtime/event-command-map';
 import { PipelineRuntime } from '../runtime/pipeline-runtime';
 import { createPipelineEventStore, type PipelineEventStoreContext } from '../store/pipeline-event-store';
+import { type ConcurrencyConfig, createCommandGate } from './command-gate';
 import { createPhasedBridge } from './phased-bridge';
 import { SSEManager } from './sse-manager';
 import { createV2RuntimeBridge } from './v2-runtime-bridge';
@@ -60,6 +61,7 @@ export class PipelineServer {
   private readonly sseManager: SSEManager;
   private readonly eventStoreContext: PipelineEventStoreContext;
   private readonly itemKeyExtractors = new Map<string, (data: unknown) => string | undefined>();
+  private readonly commandGate: ReturnType<typeof createCommandGate>;
   private readonly middleware: express.RequestHandler[] = [];
   private readonly storeFileName?: string;
   private sqliteEventStore?: EventStore;
@@ -90,6 +92,7 @@ export class PipelineServer {
       },
     });
     this.sseManager = new SSEManager();
+    this.commandGate = createCommandGate();
   }
 
   get port(): number {
@@ -120,6 +123,10 @@ export class PipelineServer {
     this.itemKeyExtractors.set(commandType, extractor);
   }
 
+  registerConcurrency(commandType: string, config: ConcurrencyConfig): void {
+    this.commandGate.register(commandType, config);
+  }
+
   registerPipeline(pipeline: Pipeline): void {
     this.pipelines.set(pipeline.descriptor.name, pipeline);
     this.runtimes.set(pipeline.descriptor.name, new PipelineRuntime(pipeline.descriptor));
@@ -973,13 +980,23 @@ export class PipelineServer {
     const handler = this.commandHandlers.get(command.type);
     if (!handler) return;
 
+    await this.commandGate.run(command.type, command.data, async (signal) => {
+      await this.executeCommand(command, handler, signal);
+    });
+  }
+
+  private async executeCommand(
+    command: Command & { correlationId: string; requestId: string },
+    handler: CommandHandlerWithMetadata,
+    signal: AbortSignal,
+  ): Promise<void> {
     const itemKey = this.extractItemKey(command.type, command.data, command.requestId);
     await this.getOrCreateItemStatus(this.currentSessionId, command.type, itemKey, command.requestId);
 
     await this.updateNodeStatus(this.currentSessionId, command.type, 'running');
     this.settledBridge.onCommandStarted(command, this.currentSessionId);
 
-    const ctx = this.createContext(command.correlationId);
+    const ctx = this.createContext(command.correlationId, signal);
     let events: Event[];
     try {
       const resultEvent = await handler.handle(command, ctx);
@@ -1001,6 +1018,8 @@ export class PipelineServer {
       ];
     }
 
+    if (signal.aborted) return;
+
     const finalStatus = this.getStatusFromEvents(events);
     await this.updateItemStatus(this.currentSessionId, command.type, itemKey, finalStatus);
     await this.updateNodeStatus(this.currentSessionId, command.type, finalStatus);
@@ -1073,9 +1092,10 @@ export class PipelineServer {
     await Promise.all(runtimes.map((runtime) => runtime.handleEvent(event, ctx)));
   }
 
-  private createContext(correlationId: string): PipelineContext {
+  private createContext(correlationId: string, signal?: AbortSignal): PipelineContext {
     return {
       correlationId,
+      signal,
       emit: async (type: string, data: unknown) => {
         const requestId = `req-${nanoid()}`;
         const event: EventWithCorrelation = {