@auto-engineer/pipeline 1.65.0 → 1.67.0

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

@@ -0,0 +1,91 @@
+import { createPipelineServerV2 } from './pipeline-server-v2.js';
+
+describe('PipelineServerV2', () => {
+  it('POST /command dispatches to engine', async () => {
+    const server = await createPipelineServerV2();
+    const calls: string[] = [];
+
+    server.engine.registerCommandHandler('TestCommand', (cmd) => {
+      calls.push(cmd.type);
+      return [{ type: 'TestResult', data: {} }];
+    });
+
+    const port = await server.start();
+
+    const response = await fetch(`http://localhost:${port}/command`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ type: 'TestCommand', data: { key: 'value' } }),
+    });
+
+    const body = await response.json();
+    expect(response.status).toBe(200);
+    expect(body).toEqual({ ok: true });
+    expect(calls).toEqual(['TestCommand']);
+
+    await server.stop();
+  });
+
+  it('GET /health returns ok', async () => {
+    const server = await createPipelineServerV2();
+    const port = await server.start();
+
+    const response = await fetch(`http://localhost:${port}/health`);
+    const body = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(body).toEqual(expect.objectContaining({ status: 'ok' }));
+
+    await server.stop();
+  });
+
+  it('GET /events returns SSE headers and streams events', async () => {
+    const server = await createPipelineServerV2();
+
+    server.engine.registerCommandHandler('Ping', () => [{ type: 'Pong', data: { value: 42 } }]);
+
+    const port = await server.start();
+
+    const controller = new AbortController();
+    const response = await fetch(`http://localhost:${port}/events`, {
+      signal: controller.signal,
+    });
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get('content-type')).toContain('text/event-stream');
+
+    const reader = response.body!.getReader();
+    const decoder = new TextDecoder();
+
+    await fetch(`http://localhost:${port}/command`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ type: 'Ping', data: {} }),
+    });
+
+    const { value } = await reader.read();
+    const text = decoder.decode(value);
+    const parsed = JSON.parse(text.replace('data: ', '').trim());
+
+    expect(parsed).toEqual({ type: 'Pong', data: { value: 42 } });
+
+    await reader.cancel().catch(() => {});
+    controller.abort();
+    await server.stop();
+  });
+
+  it('GET /registry returns registered handlers', async () => {
+    const server = await createPipelineServerV2();
+    server.engine.registerCommandHandler('A', () => []);
+    server.engine.registerCommandHandler('B', () => []);
+
+    const port = await server.start();
+    const response = await fetch(`http://localhost:${port}/registry`);
+    const body = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(body.commands).toEqual(expect.arrayContaining(['A', 'B']));
+
+    await server.stop();
+  });
+});

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

@@ -0,0 +1,70 @@
+import { createServer } from 'node:http';
+import cors from 'cors';
+import express from 'express';
+import { createPipelineEngine } from '../engine/pipeline-engine.js';
+
+export async function createPipelineServerV2(config?: { port?: number }) {
+  const engine = await createPipelineEngine();
+  const app = express();
+  app.use(cors());
+  app.use(express.json());
+  const server = createServer(app);
+
+  app.post('/command', async (req, res) => {
+    const { type, data } = req.body;
+    await engine.dispatch({ type, data });
+    res.json({ ok: true });
+  });
+
+  app.get('/health', (_req, res) => {
+    res.json({ status: 'ok', uptime: process.uptime() });
+  });
+
+  app.get('/registry', (_req, res) => {
+    res.json({ commands: engine.registeredCommands() });
+  });
+
+  app.get('/events', (req, res) => {
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+    });
+    res.flushHeaders();
+
+    let connected = true;
+
+    const listener = (event: { type: string; data: Record<string, unknown> }) => {
+      if (connected) {
+        res.write(`data: ${JSON.stringify(event)}\n\n`);
+      }
+    };
+
+    engine.onEvent(listener);
+
+    req.on('close', () => {
+      connected = false;
+    });
+  });
+
+  return {
+    engine,
+    app,
+    async start(): Promise<number> {
+      const port = config?.port ?? 0;
+      return new Promise((resolve) => {
+        server.listen(port, () => {
+          const addr = server.address();
+          const actualPort = typeof addr === 'object' && addr ? addr.port : port;
+          resolve(actualPort);
+        });
+      });
+    },
+    async stop(): Promise<void> {
+      await new Promise<void>((resolve) => {
+        server.close(() => resolve());
+      });
+      await engine.close();
+    },
+  };
+}