@kapeta/local-cluster-service 0.49.0 → 0.51.0

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/dist/esm/src/storm/codegen.d.ts

@@ -14,10 +14,12 @@ export declare class StormCodegen {
     private readonly conversationId;
     constructor(conversationId: string, userPrompt: string, blocks: BlockDefinitionInfo[], events: StormEvent[]);
     process(): Promise<void>;
+    isAborted(): boolean;
     getStream(): StormStream;
     private handleTemplateFileOutput;
     private handleUiOutput;
-    private handleFileOutput;
+    private handleFileEvents;
+    private handleFileDoneOutput;
     private getBasePath;
     /**
      * Generates the code for a block and sends it to the AI
@@ -33,7 +35,7 @@ export declare class StormCodegen {
     /**
      * Emits the text-based files to the stream
      */
-    private emitFiles;
+    private emitStaticFiles;
     private emitFile;
     /**
      * Sends the template to the AI and processes the response
@@ -47,4 +49,5 @@ export declare class StormCodegen {
      * Generates the code using codegen for a given block.
      */
     private generateBlock;
+    abort(): void;
 }

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

@@ -42,6 +42,49 @@ const path_1 = __importStar(require("path"));
 const node_os_1 = __importDefault(require("node:os"));
 const fs_1 = require("fs");
 const path_2 = __importDefault(require("path"));
+const SIMULATED_DELAY = 1000;
+class SimulatedFileDelay {
+    file;
+    stream;
+    constructor(file, stream) {
+        this.file = file;
+        this.stream = stream;
+    }
+    async start() {
+        const commonPayload = {
+            filename: this.file.payload.filename,
+            path: this.file.payload.path,
+            blockName: this.file.payload.blockName,
+            blockRef: this.file.payload.blockRef,
+            instanceId: this.file.payload.instanceId,
+        };
+        this.stream.emit('data', {
+            type: 'FILE_START',
+            created: Date.now(),
+            reason: 'File start',
+            payload: commonPayload,
+        });
+        const lines = this.file.payload.content.split('\n');
+        const delayPerLine = SIMULATED_DELAY / lines.length;
+        for (const line of lines) {
+            await new Promise((resolve) => {
+                setTimeout(() => {
+                    this.stream.emit('data', {
+                        type: 'FILE_CHUNK',
+                        created: Date.now(),
+                        reason: 'File chunk',
+                        payload: {
+                            ...commonPayload,
+                            content: line,
+                        },
+                    });
+                    resolve();
+                }, delayPerLine);
+            });
+        }
+        this.stream.emit('data', this.file);
+    }
+}
 class StormCodegen {
     userPrompt;
     blocks;
@@ -63,46 +106,139 @@ class StormCodegen {
         await Promise.all(promises);
         this.out.end();
     }
+    isAborted() {
+        return this.out.isAborted();
+    }
     getStream() {
         return this.out;
     }
     handleTemplateFileOutput(blockUri, aiName, template, data) {
+        if (this.handleFileEvents(blockUri, aiName, data)) {
+            return;
+        }
         switch (data.type) {
-            case 'FILE':
+            case 'FILE_DONE':
                 template.filename = data.payload.filename;
                 template.content = data.payload.content;
-                return this.handleFileOutput(blockUri, aiName, data);
+                this.handleFileDoneOutput(blockUri, aiName, data);
+                break;
         }
     }
-    handleUiOutput(blockUri, aiName, data) {
+    handleUiOutput(blockUri, blockName, data) {
+        const blockRef = blockUri.toNormalizedString();
+        const instanceId = event_parser_1.StormEventParser.toInstanceIdFromRef(blockRef);
+        if (this.handleFileEvents(blockUri, blockName, data)) {
+            return;
+        }
         switch (data.type) {
             case 'SCREEN':
-                const ref = blockUri.toNormalizedString();
                 this.out.emit('data', {
                     type: 'SCREEN',
                     reason: data.reason,
                     created: Date.now(),
                     payload: {
                         ...data.payload,
-                        blockName: aiName,
-                        blockRef: ref,
-                        instanceId: event_parser_1.StormEventParser.toInstanceIdFromRef(ref),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                break;
+            case 'FILE_START':
+            case 'FILE_CHUNK_RESET':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                break;
+            case 'FILE_CHUNK':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        blockName,
+                        blockRef,
+                        instanceId,
                     },
                 });
-            case 'FILE':
-                return this.handleFileOutput(blockUri, aiName, data);
+                break;
+            case 'FILE_STATE':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                break;
+            case 'FILE_DONE':
+                this.handleFileDoneOutput(blockUri, blockName, data);
+                break;
         }
     }
-    handleFileOutput(blockUri, aiName, data) {
+    handleFileEvents(blockUri, blockName, data) {
+        const blockRef = blockUri.toNormalizedString();
+        const instanceId = event_parser_1.StormEventParser.toInstanceIdFromRef(blockRef);
+        const basePath = this.getBasePath(blockUri.fullName);
         switch (data.type) {
-            case 'FILE':
+            case 'FILE_START':
+            case 'FILE_CHUNK_RESET':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        path: (0, path_1.join)(basePath, data.payload.filename),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                return true;
+            case 'FILE_CHUNK':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        path: (0, path_1.join)(basePath, data.payload.filename),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                return true;
+            case 'FILE_STATE':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        path: (0, path_1.join)(basePath, data.payload.filename),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                return true;
+        }
+        return false;
+    }
+    handleFileDoneOutput(blockUri, aiName, data) {
+        switch (data.type) {
+            case 'FILE_DONE':
                 const ref = blockUri.toNormalizedString();
                 this.emitFile(blockUri, aiName, data.payload.filename, data.payload.content, data.reason);
                 return {
-                    type: 'FILE',
+                    type: 'FILE_DONE',
                     created: Date.now(),
                     payload: {
                         filename: data.payload.filename,
+                        path: (0, path_1.join)(this.getBasePath(blockUri.fullName), data.payload.filename),
                         content: data.payload.content,
                         blockRef: ref,
                         instanceId: event_parser_1.StormEventParser.toInstanceIdFromRef(ref),
@@ -117,6 +253,9 @@ class StormCodegen {
      * Generates the code for a block and sends it to the AI
      */
     async processBlockCode(block) {
+        if (this.isAborted()) {
+            return;
+        }
         // Generate the code for the block using the standard codegen templates
         const generatedResult = await this.generateBlock(block.content);
         if (!generatedResult) {
@@ -124,7 +263,10 @@ class StormCodegen {
         }
         const allFiles = this.toStormFiles(generatedResult);
         // Send all the non-ai files to the stream
-        this.emitFiles((0, nodejs_utils_1.parseKapetaUri)(block.uri), block.aiName, allFiles);
+        await this.emitStaticFiles((0, nodejs_utils_1.parseKapetaUri)(block.uri), block.aiName, allFiles);
+        if (this.isAborted()) {
+            return;
+        }
         const relevantFiles = allFiles.filter((file) => file.type !== codegen_1.AIFileTypes.IGNORE && file.type !== codegen_1.AIFileTypes.WEB_SCREEN);
         const uiTemplates = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.WEB_SCREEN);
         if (uiTemplates.length > 0) {
@@ -138,8 +280,14 @@ class StormCodegen {
             uiStream.on('data', (evt) => {
                 this.handleUiOutput((0, nodejs_utils_1.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 = relevantFiles.filter((file) => ![codegen_1.AIFileTypes.SERVICE, codegen_1.AIFileTypes.WEB_SCREEN].includes(file.type));
         // Send the service and UI templates to the AI. These will be send one-by-one in addition to the context files
@@ -148,6 +296,9 @@ class StormCodegen {
             await this.processTemplates((0, nodejs_utils_1.parseKapetaUri)(block.uri), block.aiName, stormClient_1.stormClient.createServiceImplementation.bind(stormClient_1.stormClient), serviceFiles, contextFiles);
         }
         const basePath = this.getBasePath(block.content.metadata.name);
+        if (this.isAborted()) {
+            return;
+        }
         for (const serviceFile of serviceFiles) {
             const filePath = (0, path_1.join)(basePath, serviceFile.filename);
             await (0, promises_1.writeFile)(filePath, serviceFile.content);
@@ -192,6 +343,9 @@ class StormCodegen {
                     console.debug('Validation error:', result);
                     const errorStream = await stormClient_1.stormClient.createErrorClassification(result.error, []);
                     const fixes = new Map();
+                    this.out.on('aborted', () => {
+                        errorStream.abort();
+                    });
                     errorStream.on('data', (evt) => {
                         if (evt.type === 'ERROR_CLASSIFIER') {
                             // find the file that caused the error
@@ -206,8 +360,8 @@ 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((0, path_1.join)(basePath, eventFileName), code);
                         }
@@ -252,6 +406,9 @@ class StormCodegen {
                     resolve(evt.payload.content);
                 }
             });
+            this.out.on('aborted', () => {
+                fixStream.abort();
+            });
             fixStream.on('error', (err) => {
                 reject(err);
             });
@@ -261,8 +418,8 @@ class StormCodegen {
     /**
      * Emits the text-based files to the stream
      */
-    emitFiles(uri, aiName, files) {
-        files.forEach((file) => {
+    async emitStaticFiles(uri, aiName, files) {
+        const promises = files.map((file) => {
             if (!file.content || typeof file.content !== 'string') {
                 return;
             }
@@ -276,14 +433,30 @@ class StormCodegen {
                 // They will need to be implemented by the AI
                 return;
             }
-            this.emitFile(uri, aiName, file.filename, file.content);
+            const basePath = this.getBasePath(uri.fullName);
+            const ref = uri.toNormalizedString();
+            const fileEvent = {
+                type: 'FILE_DONE',
+                reason: 'File generated',
+                created: Date.now(),
+                payload: {
+                    filename: file.filename,
+                    path: (0, path_1.join)(basePath, file.filename),
+                    content: file.content,
+                    blockName: aiName,
+                    blockRef: ref,
+                    instanceId: event_parser_1.StormEventParser.toInstanceIdFromRef(ref),
+                },
+            };
+            return new SimulatedFileDelay(fileEvent, this.out).start();
         });
+        return Promise.all(promises);
     }
     emitFile(uri, blockName, filename, content, reason = 'File generated') {
         const basePath = this.getBasePath(uri.fullName);
         const ref = uri.toNormalizedString();
         this.out.emit('data', {
-            type: 'FILE',
+            type: 'FILE_DONE',
             reason,
             created: Date.now(),
             payload: {
@@ -306,18 +479,15 @@ class StormCodegen {
                 template: templateFile,
                 prompt: this.userPrompt,
             });
-            const files = [];
+            this.out.on('aborted', () => {
+                stream.abort();
+            });
             stream.on('data', (evt) => {
-                const file = this.handleTemplateFileOutput(blockUri, aiName, templateFile, evt);
-                if (file) {
-                    files.push(file);
-                }
+                this.handleTemplateFileOutput(blockUri, aiName, templateFile, evt);
             });
             await stream.waitForDone();
-            return files;
         });
-        const fileChunks = await Promise.all(promises);
-        return fileChunks.flat();
+        await Promise.all(promises);
     }
     /**
      * Converts the generated files to a format that can be sent to the AI
@@ -357,6 +527,9 @@ class StormCodegen {
      * Generates the code using codegen for a given block.
      */
     async generateBlock(yamlContent) {
+        if (this.isAborted()) {
+            return;
+        }
         if (!yamlContent.spec.target?.kind) {
             //Not all block types have targets
             return;
@@ -371,5 +544,8 @@ class StormCodegen {
         new codegen_1.CodeWriter(basePath).write(generatedResult);
         return generatedResult;
     }
+    abort() {
+        this.out.abort();
+    }
 }
 exports.StormCodegen = StormCodegen;

package/dist/esm/src/storm/event-parser.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { StormEvent } from './events';
+import { StormEvent, StormEventPhases, StormEventPhaseType } from './events';
 import { BlockDefinition, Plan } from '@kapeta/schemas';
 import { KapetaURI } from '@kapeta/nodejs-utils';
 export interface BlockDefinitionInfo {
@@ -39,6 +39,9 @@ export interface StormOptions {
     desktopLanguage: string;
     gatewayKind: string;
 }
+export declare function createPhaseStartEvent(type: StormEventPhaseType): StormEventPhases;
+export declare function createPhaseEndEvent(type: StormEventPhaseType): StormEventPhases;
+export declare function createPhaseEvent(start: boolean, type: StormEventPhaseType): StormEventPhases;
 export declare function resolveOptions(): Promise<StormOptions>;
 export declare class StormEventParser {
     static toInstanceId(handle: string, blockName: string): string;