@kapeta/local-cluster-service 0.49.0 → 0.50.0

package/dist/esm/src/storm/events.d.ts

@@ -184,4 +184,16 @@ export interface StormEventDefinitionChange {
     created: number;
     payload: StormDefinitions;
 }
-export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix | StormEventBlockReady;
+export declare enum StormEventPhaseType {
+    META = "META",
+    DEFINITIONS = "DEFINITIONS",
+    IMPLEMENTATION = "IMPLEMENTATION"
+}
+export interface StormEventPhases {
+    type: 'PHASE_START' | 'PHASE_END';
+    created: number;
+    payload: {
+        phaseType: StormEventPhaseType;
+    };
+}
+export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix | StormEventBlockReady | StormEventPhases;

package/dist/esm/src/storm/events.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StormEventPhaseType = void 0;
+var StormEventPhaseType;
+(function (StormEventPhaseType) {
+    StormEventPhaseType["META"] = "META";
+    StormEventPhaseType["DEFINITIONS"] = "DEFINITIONS";
+    StormEventPhaseType["IMPLEMENTATION"] = "IMPLEMENTATION";
+})(StormEventPhaseType || (exports.StormEventPhaseType = StormEventPhaseType = {}));

package/dist/esm/src/storm/routes.js

@@ -12,6 +12,7 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const cors_1 = require("../middleware/cors");
 const stringBody_1 = require("../middleware/stringBody");
 const stormClient_1 = require("./stormClient");
+const events_1 = require("./events");
 const event_parser_1 = require("./event-parser");
 const codegen_1 = require("./codegen");
 const assetManager_1 = require("../assetManager");
@@ -27,15 +28,41 @@ router.post('/:handle/all', async (req, res) => {
         const conversationId = req.headers[stormClient_1.ConversationIdHeader.toLowerCase()];
         const aiRequest = JSON.parse(req.stringBody ?? '{}');
         const metaStream = await stormClient_1.stormClient.createMetadata(aiRequest.prompt, conversationId);
+        onRequestAborted(req, res, () => {
+            metaStream.abort();
+        });
         res.set('Content-Type', 'application/x-ndjson');
         res.set('Access-Control-Expose-Headers', stormClient_1.ConversationIdHeader);
         res.set(stormClient_1.ConversationIdHeader, metaStream.getConversationId());
+        let currentPhase = events_1.StormEventPhaseType.META;
         metaStream.on('data', (data) => {
             const result = eventParser.processEvent(req.params.handle, data);
+            switch (data.type) {
+                case 'CREATE_API':
+                case 'CREATE_MODEL':
+                case 'CREATE_TYPE':
+                    if (currentPhase !== events_1.StormEventPhaseType.DEFINITIONS) {
+                        sendEvent(res, (0, event_parser_1.createPhaseEndEvent)(events_1.StormEventPhaseType.META));
+                        currentPhase = events_1.StormEventPhaseType.DEFINITIONS;
+                        sendEvent(res, (0, event_parser_1.createPhaseStartEvent)(events_1.StormEventPhaseType.DEFINITIONS));
+                    }
+                    break;
+            }
             sendEvent(res, data);
             sendDefinitions(res, result);
         });
-        await waitForStormStream(metaStream);
+        try {
+            sendEvent(res, (0, event_parser_1.createPhaseStartEvent)(events_1.StormEventPhaseType.META));
+            await waitForStormStream(metaStream);
+        }
+        finally {
+            if (!metaStream.isAborted()) {
+                sendEvent(res, (0, event_parser_1.createPhaseEndEvent)(currentPhase));
+            }
+        }
+        if (metaStream.isAborted()) {
+            return;
+        }
         if (!eventParser.isValid()) {
             // We can't continue if the meta stream is invalid
             sendEvent(res, {
@@ -48,32 +75,45 @@ router.post('/:handle/all', async (req, res) => {
             return;
         }
         const result = eventParser.toResult(handle);
+        if (metaStream.isAborted()) {
+            return;
+        }
         sendDefinitions(res, result);
         if (!req.query.skipCodegen) {
-            const stormCodegen = new codegen_1.StormCodegen(metaStream.getConversationId(), aiRequest.prompt, result.blocks, eventParser.getEvents());
-            const codegenPromise = streamStormPartialResponse(stormCodegen.getStream(), res);
-            await stormCodegen.process();
-            await codegenPromise;
+            try {
+                sendEvent(res, (0, event_parser_1.createPhaseStartEvent)(events_1.StormEventPhaseType.IMPLEMENTATION));
+                const stormCodegen = new codegen_1.StormCodegen(metaStream.getConversationId(), aiRequest.prompt, result.blocks, eventParser.getEvents());
+                onRequestAborted(req, res, () => {
+                    stormCodegen.abort();
+                });
+                const codegenPromise = streamStormPartialResponse(stormCodegen.getStream(), res);
+                await stormCodegen.process();
+                await codegenPromise;
+            }
+            finally {
+                if (!metaStream.isAborted()) {
+                    sendEvent(res, (0, event_parser_1.createPhaseEndEvent)(events_1.StormEventPhaseType.IMPLEMENTATION));
+                }
+            }
         }
         sendDone(res);
     }
     catch (err) {
         sendError(err, res);
-        res.end();
+        if (!res.closed) {
+            res.end();
+        }
     }
 });
 router.post('/block/create', async (req, res) => {
     const createRequest = JSON.parse(req.stringBody ?? '{}');
     try {
         const ymlPath = path_1.default.join(createRequest.newPath, 'kapeta.yml');
-        console.log('Creating block at', ymlPath);
         const [asset] = await assetManager_1.assetManager.createAsset(ymlPath, createRequest.definition);
         if (await fs_extra_1.default.pathExists(createRequest.tmpPath)) {
-            console.log('Moving block from', createRequest.tmpPath, 'to', createRequest.newPath);
             await fs_extra_1.default.move(createRequest.tmpPath, createRequest.newPath, {
                 overwrite: true,
             });
-            console.log('Updating asset', asset.ref);
             res.send(await assetManager_1.assetManager.updateAsset(asset.ref, createRequest.definition));
         }
         else {
@@ -93,6 +133,9 @@ function sendDefinitions(res, result) {
     });
 }
 function sendDone(res) {
+    if (res.closed) {
+        return;
+    }
     sendEvent(res, {
         type: 'DONE',
         created: Date.now(),
@@ -100,6 +143,9 @@ function sendDone(res) {
     res.end();
 }
 function sendError(err, res) {
+    if (res.closed) {
+        return;
+    }
     console.error('Failed to send prompt', err);
     if (res.headersSent) {
         sendEvent(res, {
@@ -137,6 +183,17 @@ function streamStormPartialResponse(result, res) {
     });
 }
 function sendEvent(res, evt) {
+    if (res.closed) {
+        return;
+    }
     res.write(JSON.stringify(evt) + '\n');
 }
+function onRequestAborted(req, res, onAborted) {
+    req.on('close', () => {
+        onAborted();
+    });
+    res.on('close', () => {
+        onAborted();
+    });
+}
 exports.default = router;

package/dist/esm/src/storm/stormClient.js

@@ -46,12 +46,13 @@ class StormClient {
             prompt: stringPrompt,
             conversationId: body.conversationId,
         });
+        const abort = new AbortController();
+        options.signal = abort.signal;
         const response = await fetch(options.url, options);
         if (response.status !== 200) {
             throw new Error(`Got error response from ${options.url}: ${response.status}\nContent: ${await response.text()}`);
         }
         const conversationId = response.headers.get(exports.ConversationIdHeader);
-        console.log('Received conversationId', conversationId);
         const out = new stream_1.StormStream(stringPrompt, conversationId);
         const jsonLStream = promises_1.default.createInterface(node_stream_1.Readable.fromWeb(response.body));
         jsonLStream.on('line', (line) => {
@@ -63,6 +64,9 @@ class StormClient {
         jsonLStream.on('close', () => {
             out.end();
         });
+        out.on('aborted', () => {
+            abort.abort();
+        });
         return out;
     }
     createMetadata(prompt, conversationId) {

package/dist/esm/src/storm/stream.d.ts

@@ -10,17 +10,22 @@ import { BlockDefinition } from '@kapeta/schemas';
 export declare class StormStream extends EventEmitter {
     private conversationId;
     private lines;
+    private aborted;
     constructor(prompt?: string, conversationId?: string | null);
     getConversationId(): string;
+    isAborted(): boolean;
     addJSONLine(line: string): void;
     end(): void;
     on(event: 'end', listener: () => void): this;
+    on(event: 'aborted', listener: () => void): this;
     on(event: 'error', listener: (e: Error) => void): this;
     on(event: 'data', listener: (data: StormEvent) => void): this;
     emit(event: 'end'): boolean;
+    emit(event: 'aborted'): void;
     emit(event: 'error', e: Error): boolean;
     emit(event: 'data', data: StormEvent): boolean;
     waitForDone(): Promise<void>;
+    abort(): void;
 }
 export interface ConversationItem {
     role: 'user' | 'model';

package/dist/esm/src/storm/stream.js

@@ -9,6 +9,7 @@ const node_events_1 = require("node:events");
 class StormStream extends node_events_1.EventEmitter {
     conversationId = '';
     lines = [];
+    aborted = false;
     constructor(prompt = '', conversationId) {
         super();
         this.conversationId = conversationId || '';
@@ -16,6 +17,9 @@ class StormStream extends node_events_1.EventEmitter {
     getConversationId() {
         return this.conversationId;
     }
+    isAborted() {
+        return this.aborted;
+    }
     addJSONLine(line) {
         try {
             this.lines.push(line);
@@ -48,5 +52,12 @@ class StormStream extends node_events_1.EventEmitter {
             });
         });
     }
+    abort() {
+        if (this.aborted) {
+            return;
+        }
+        this.aborted = true;
+        this.emit('aborted');
+    }
 }
 exports.StormStream = StormStream;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.49.0",
+    "version": "0.50.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

package/src/storm/codegen.ts

@@ -51,6 +51,10 @@ export class StormCodegen {
         this.out.end();
     }
 
+    isAborted() {
+        return this.out.isAborted();
+    }
+
     public getStream() {
         return this.out;
     }
@@ -110,6 +114,9 @@ export class StormCodegen {
      * Generates the code for a block and sends it to the AI
      */
     private async processBlockCode(block: BlockDefinitionInfo) {
+        if (this.isAborted()) {
+            return;
+        }
         // Generate the code for the block using the standard codegen templates
         const generatedResult = await this.generateBlock(block.content);
         if (!generatedResult) {
@@ -121,6 +128,10 @@ export class StormCodegen {
         // Send all the non-ai files to the stream
         this.emitFiles(parseKapetaUri(block.uri), block.aiName, allFiles);
 
+        if (this.isAborted()) {
+            return;
+        }
+
         const relevantFiles: StormFileInfo[] = allFiles.filter(
             (file) => file.type !== AIFileTypes.IGNORE && file.type !== AIFileTypes.WEB_SCREEN
         );
@@ -138,9 +149,17 @@ export class StormCodegen {
                 this.handleUiOutput(parseKapetaUri(block.uri), block.aiName, evt);
             });
 
+            this.out.on('aborted', () => {
+                uiStream.abort();
+            });
+
             await uiStream.waitForDone();
         }
 
+        if (this.isAborted()) {
+            return;
+        }
+
         // Gather the context files for implementation. These will be all be passed to the AI
         const contextFiles: StormFileInfo[] = relevantFiles.filter(
             (file) => ![AIFileTypes.SERVICE, AIFileTypes.WEB_SCREEN].includes(file.type)
@@ -160,6 +179,10 @@ export class StormCodegen {
 
         const basePath = this.getBasePath(block.content.metadata.name);
 
+        if (this.isAborted()) {
+            return;
+        }
+
         for (const serviceFile of serviceFiles) {
             const filePath = join(basePath, serviceFile.filename);
             await writeFile(filePath, serviceFile.content);
@@ -216,6 +239,10 @@ export class StormCodegen {
                     const errorStream = await stormClient.createErrorClassification(result.error, []);
                     const fixes = new Map<string, Promise<string>>();
 
+                    this.out.on('aborted', () => {
+                        errorStream.abort();
+                    });
+
                     errorStream.on('data', (evt) => {
                         if (evt.type === 'ERROR_CLASSIFIER') {
                             // find the file that caused the error
@@ -232,8 +259,8 @@ export class StormCodegen {
                             const fix = `${evt.payload.potentialFix}\n---\n${knownFiles
                                 .map((e) => e.filename)
                                 .join('\n')}\n---\n${content}`;
-                            console.log(`trying to fix the code in ${eventFileName}`);
-                            console.debug(`with the fix:\n${fix}`);
+                            //console.log(`trying to fix the code in ${eventFileName}`);
+                            //console.debug(`with the fix:\n${fix}`);
                             const code = this.codeFix(fix);
                             fixes.set(join(basePath, eventFileName), code);
                         }
@@ -278,6 +305,9 @@ export class StormCodegen {
                     resolve(evt.payload.content);
                 }
             });
+            this.out.on('aborted', () => {
+                fixStream.abort();
+            });
             fixStream.on('error', (err) => {
                 reject(err);
             });
@@ -353,6 +383,10 @@ export class StormCodegen {
 
             const files: StormEventFile[] = [];
 
+            this.out.on('aborted', () => {
+                stream.abort();
+            });
+
             stream.on('data', (evt) => {
                 const file = this.handleTemplateFileOutput(blockUri, aiName, templateFile, evt);
                 if (file) {
@@ -411,6 +445,9 @@ export class StormCodegen {
      * Generates the code using codegen for a given block.
      */
     private async generateBlock(yamlContent: Definition) {
+        if (this.isAborted()) {
+            return;
+        }
         if (!yamlContent.spec.target?.kind) {
             //Not all block types have targets
             return;
@@ -427,4 +464,8 @@ export class StormCodegen {
         new CodeWriter(basePath).write(generatedResult);
         return generatedResult;
     }
+
+    abort() {
+        this.out.abort();
+    }
 }

package/src/storm/event-parser.ts

@@ -3,7 +3,15 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { StormBlockInfoFilled, StormBlockType, StormConnection, StormEvent, StormResourceType } from './events';
+import {
+    StormBlockInfoFilled,
+    StormBlockType,
+    StormConnection,
+    StormEvent,
+    StormEventPhases,
+    StormEventPhaseType,
+    StormResourceType,
+} from './events';
 import {
     BlockDefinition,
     BlockInstance,
@@ -87,6 +95,24 @@ function prettifyKaplang(source: string) {
     }
 }
 
+export function createPhaseStartEvent(type: StormEventPhaseType): StormEventPhases {
+    return createPhaseEvent(true, type);
+}
+
+export function createPhaseEndEvent(type: StormEventPhaseType): StormEventPhases {
+    return createPhaseEvent(false, type);
+}
+
+export function createPhaseEvent(start: boolean, type: StormEventPhaseType): StormEventPhases {
+    return {
+        type: start ? 'PHASE_START' : 'PHASE_END',
+        created: Date.now(),
+        payload: {
+            phaseType: type,
+        },
+    };
+}
+
 export async function resolveOptions(): Promise<StormOptions> {
     // Predefined types for now - TODO: Allow user to select / change
 
@@ -325,7 +351,7 @@ export class StormEventParser {
     }
 
     public toResult(handle: string): StormDefinitions {
-        const planRef = StormEventParser.toRef(handle, this.planName ?? 'undefined');
+        const planRef = StormEventParser.toRef(handle, this.planName || 'undefined');
         const blockDefinitions = this.toBlockDefinitions(handle);
         const refIdMap: { [key: string]: string } = {};
         const blocks = Object.entries(blockDefinitions).map(([ref, block]) => {
@@ -337,7 +363,7 @@ export class StormEventParser {
                 block: {
                     ref,
                 },
-                name: block.content.metadata.title ?? block.content.metadata.name,
+                name: block.content.metadata.title || block.content.metadata.name,
                 dimensions: {
                     left: 0,
                     top: 0,

package/src/storm/events.ts

@@ -220,6 +220,20 @@ export interface StormEventDefinitionChange {
     payload: StormDefinitions;
 }
 
+export enum StormEventPhaseType {
+    META = 'META',
+    DEFINITIONS = 'DEFINITIONS',
+    IMPLEMENTATION = 'IMPLEMENTATION',
+}
+
+export interface StormEventPhases {
+    type: 'PHASE_START' | 'PHASE_END';
+    created: number;
+    payload: {
+        phaseType: StormEventPhaseType;
+    };
+}
+
 export type StormEvent =
     | StormEventCreateBlock
     | StormEventCreateConnection
@@ -236,4 +250,5 @@ export type StormEvent =
     | StormEventDefinitionChange
     | StormEventErrorClassifier
     | StormEventCodeFix
-    | StormEventBlockReady;
+    | StormEventBlockReady
+    | StormEventPhases;

package/src/storm/routes.ts

@@ -11,12 +11,17 @@ import { stringBody } from '../middleware/stringBody';
 import { KapetaBodyRequest } from '../types';
 import { StormContextRequest, StormCreateBlockRequest, StormStream } from './stream';
 import { ConversationIdHeader, stormClient } from './stormClient';
-import { StormEvent } from './events';
-import { resolveOptions, StormDefinitions, StormEventParser } from './event-parser';
+import { StormEvent, StormEventPhaseType } from './events';
+import {
+    createPhaseEndEvent,
+    createPhaseStartEvent,
+    resolveOptions,
+    StormDefinitions,
+    StormEventParser,
+} from './event-parser';
 import { StormCodegen } from './codegen';
 import { assetManager } from '../assetManager';
 import Path from 'path';
-import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
 
 const router = Router();
 
@@ -36,18 +41,48 @@ router.post('/:handle/all', async (req: KapetaBodyRequest, res: Response) => {
         const aiRequest: StormContextRequest = JSON.parse(req.stringBody ?? '{}');
         const metaStream = await stormClient.createMetadata(aiRequest.prompt, conversationId);
 
+        onRequestAborted(req, res, () => {
+            metaStream.abort();
+        });
+
         res.set('Content-Type', 'application/x-ndjson');
         res.set('Access-Control-Expose-Headers', ConversationIdHeader);
         res.set(ConversationIdHeader, metaStream.getConversationId());
 
+        let currentPhase = StormEventPhaseType.META;
+
         metaStream.on('data', (data: StormEvent) => {
             const result = eventParser.processEvent(req.params.handle, data);
 
+            switch (data.type) {
+                case 'CREATE_API':
+                case 'CREATE_MODEL':
+                case 'CREATE_TYPE':
+                    if (currentPhase !== StormEventPhaseType.DEFINITIONS) {
+                        sendEvent(res, createPhaseEndEvent(StormEventPhaseType.META));
+                        currentPhase = StormEventPhaseType.DEFINITIONS;
+                        sendEvent(res, createPhaseStartEvent(StormEventPhaseType.DEFINITIONS));
+                    }
+                    break;
+            }
+
             sendEvent(res, data);
             sendDefinitions(res, result);
         });
 
-        await waitForStormStream(metaStream);
+        try {
+            sendEvent(res, createPhaseStartEvent(StormEventPhaseType.META));
+
+            await waitForStormStream(metaStream);
+        } finally {
+            if (!metaStream.isAborted()) {
+                sendEvent(res, createPhaseEndEvent(currentPhase));
+            }
+        }
+
+        if (metaStream.isAborted()) {
+            return;
+        }
 
         if (!eventParser.isValid()) {
             // We can't continue if the meta stream is invalid
@@ -63,27 +98,44 @@ router.post('/:handle/all', async (req: KapetaBodyRequest, res: Response) => {
 
         const result = eventParser.toResult(handle);
 
+        if (metaStream.isAborted()) {
+            return;
+        }
+
         sendDefinitions(res, result);
 
         if (!req.query.skipCodegen) {
-            const stormCodegen = new StormCodegen(
-                metaStream.getConversationId(),
-                aiRequest.prompt,
-                result.blocks,
-                eventParser.getEvents()
-            );
-
-            const codegenPromise = streamStormPartialResponse(stormCodegen.getStream(), res);
-
-            await stormCodegen.process();
-
-            await codegenPromise;
+            try {
+                sendEvent(res, createPhaseStartEvent(StormEventPhaseType.IMPLEMENTATION));
+                const stormCodegen = new StormCodegen(
+                    metaStream.getConversationId(),
+                    aiRequest.prompt,
+                    result.blocks,
+                    eventParser.getEvents()
+                );
+
+                onRequestAborted(req, res, () => {
+                    stormCodegen.abort();
+                });
+
+                const codegenPromise = streamStormPartialResponse(stormCodegen.getStream(), res);
+
+                await stormCodegen.process();
+
+                await codegenPromise;
+            } finally {
+                if (!metaStream.isAborted()) {
+                    sendEvent(res, createPhaseEndEvent(StormEventPhaseType.IMPLEMENTATION));
+                }
+            }
         }
 
         sendDone(res);
     } catch (err: any) {
         sendError(err, res);
-        res.end();
+        if (!res.closed) {
+            res.end();
+        }
     }
 });
 
@@ -93,19 +145,13 @@ router.post('/block/create', async (req: KapetaBodyRequest, res: Response) => {
     try {
         const ymlPath = Path.join(createRequest.newPath, 'kapeta.yml');
 
-        console.log('Creating block at', ymlPath);
-
         const [asset] = await assetManager.createAsset(ymlPath, createRequest.definition);
 
         if (await FS.pathExists(createRequest.tmpPath)) {
-            console.log('Moving block from', createRequest.tmpPath, 'to', createRequest.newPath);
-
             await FS.move(createRequest.tmpPath, createRequest.newPath, {
                 overwrite: true,
             });
 
-            console.log('Updating asset', asset.ref);
-
             res.send(await assetManager.updateAsset(asset.ref, createRequest.definition));
         } else {
             res.send(asset);
@@ -125,6 +171,9 @@ function sendDefinitions(res: Response, result: StormDefinitions) {
 }
 
 function sendDone(res: Response) {
+    if (res.closed) {
+        return;
+    }
     sendEvent(res, {
         type: 'DONE',
         created: Date.now(),
@@ -134,6 +183,9 @@ function sendDone(res: Response) {
 }
 
 function sendError(err: Error, res: Response) {
+    if (res.closed) {
+        return;
+    }
     console.error('Failed to send prompt', err);
     if (res.headersSent) {
         sendEvent(res, {
@@ -175,7 +227,19 @@ function streamStormPartialResponse(result: StormStream, res: Response) {
 }
 
 function sendEvent(res: Response, evt: StormEvent) {
+    if (res.closed) {
+        return;
+    }
     res.write(JSON.stringify(evt) + '\n');
 }
 
+function onRequestAborted(req: KapetaBodyRequest, res: Response, onAborted: () => void) {
+    req.on('close', () => {
+        onAborted();
+    });
+    res.on('close', () => {
+        onAborted();
+    });
+}
+
 export default router;