@kapeta/local-cluster-service 0.58.6 → 0.60.0

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

@@ -20,14 +20,48 @@ const codegen_1 = require("./codegen");
 const assetManager_1 = require("../assetManager");
 const node_uuid_1 = __importDefault(require("node-uuid"));
 const PromiseQueue_1 = require("./PromiseQueue");
+const page_utils_1 = require("./page-utils");
+const UIServer_1 = require("./UIServer");
+const UI_SERVERS = {};
 const router = (0, express_promise_router_1.default)();
 router.use('/', cors_1.corsHandler);
 router.use('/', stringBody_1.stringBody);
-router.post('/:handle/ui/screen', async (req, res) => {
-    const handle = req.params.handle;
+function convertPageEvent(screenData, innerConversationId, mainConversationId) {
+    if (screenData.type === 'PAGE') {
+        const server = UI_SERVERS[mainConversationId];
+        if (!server) {
+            console.warn('No server found for conversation', mainConversationId);
+        }
+        screenData.payload.conversationId = innerConversationId;
+        return {
+            type: 'PAGE_URL',
+            reason: screenData.reason,
+            created: screenData.created,
+            payload: {
+                id: node_uuid_1.default.v4(),
+                name: screenData.payload.name,
+                title: screenData.payload.title,
+                filename: screenData.payload.filename,
+                description: screenData.payload.description,
+                prompt: screenData.payload.prompt,
+                path: screenData.payload.path,
+                url: server ? server.resolveUrl(screenData) : '',
+                method: screenData.payload.method,
+                conversationId: innerConversationId,
+            },
+        };
+    }
+    return screenData;
+}
+router.all('/ui/:systemId/serve/:method/*', async (req, res) => {
+    (0, page_utils_1.readPageFromDisk)(req.params.systemId, req.params[0], req.params.method, res);
+});
+router.post('/ui/screen', async (req, res) => {
     try {
         const conversationId = req.headers[stormClient_1.ConversationIdHeader.toLowerCase()];
+        const systemId = req.headers[page_utils_1.SystemIdHeader.toLowerCase()];
         const aiRequest = JSON.parse(req.stringBody ?? '{}');
+        aiRequest.storage_prefix = systemId ? systemId + '_' : 'mock_';
         const screenStream = await stormClient_1.stormClient.createUIPage(aiRequest, conversationId);
         onRequestAborted(req, res, () => {
             screenStream.abort();
@@ -35,11 +69,21 @@ router.post('/:handle/ui/screen', async (req, res) => {
         res.set('Content-Type', 'application/x-ndjson');
         res.set('Access-Control-Expose-Headers', stormClient_1.ConversationIdHeader);
         res.set(stormClient_1.ConversationIdHeader, screenStream.getConversationId());
+        const promises = [];
         screenStream.on('data', (data) => {
-            console.log('Processing screen event', data);
+            switch (data.type) {
+                case 'PAGE':
+                    console.log('Processing page event', data);
+                    data.payload.conversationId = screenStream.getConversationId();
+                    if (systemId) {
+                        promises.push(sendPageEvent(systemId, data, res));
+                    }
+                    break;
+            }
             sendEvent(res, data);
         });
         await waitForStormStream(screenStream);
+        await Promise.allSettled(promises);
         sendDone(res);
     }
     catch (err) {
@@ -49,6 +93,18 @@ router.post('/:handle/ui/screen', async (req, res) => {
         }
     }
 });
+router.delete('/:handle/ui', async (req, res) => {
+    const conversationId = req.headers[stormClient_1.ConversationIdHeader.toLowerCase()];
+    if (!conversationId) {
+        res.status(400).send('Missing conversation id');
+        return;
+    }
+    const server = UI_SERVERS[conversationId];
+    if (server) {
+        server.close();
+        delete UI_SERVERS[conversationId];
+    }
+});
 router.post('/:handle/ui', async (req, res) => {
     const handle = req.params.handle;
     try {
@@ -62,10 +118,13 @@ router.post('/:handle/ui', async (req, res) => {
         res.set('Access-Control-Expose-Headers', stormClient_1.ConversationIdHeader);
         res.set(stormClient_1.ConversationIdHeader, userJourneysStream.getConversationId());
         const promises = {};
-        const queue = new PromiseQueue_1.PromiseQueue(10);
+        const queue = new PromiseQueue_1.PromiseQueue(5);
         onRequestAborted(req, res, () => {
             queue.cancel();
         });
+        const systemId = userJourneysStream.getConversationId();
+        UI_SERVERS[systemId] = new UIServer_1.UIServer(systemId);
+        await UI_SERVERS[systemId].start();
         userJourneysStream.on('data', async (data) => {
             try {
                 console.log('Processing user journey event', data);
@@ -91,15 +150,20 @@ router.post('/:handle/ui', async (req, res) => {
                                 name: screen.name,
                                 title: screen.title,
                                 filename: screen.filename,
+                                storage_prefix: userJourneysStream.getConversationId() + '_',
                             }, innerConversationId);
+                            const promises = [];
                             screenStream.on('data', (screenData) => {
                                 if (screenData.type === 'PAGE') {
                                     screenData.payload.conversationId = innerConversationId;
+                                    promises.push(sendPageEvent(userJourneysStream.getConversationId(), screenData, res));
+                                }
+                                else {
+                                    sendEvent(res, screenData);
                                 }
-                                sendEvent(res, screenData);
                             });
                             screenStream.on('end', () => {
-                                resolve();
+                                Promise.allSettled(promises).finally(resolve);
                             });
                         }
                         catch (e) {
@@ -131,16 +195,45 @@ router.post('/ui/edit', async (req, res) => {
     try {
         const conversationId = req.headers[stormClient_1.ConversationIdHeader.toLowerCase()];
         const aiRequest = JSON.parse(req.stringBody ?? '{}');
-        const editStream = await stormClient_1.stormClient.editPages(aiRequest.prompt, conversationId);
+        const pages = aiRequest.prompt.pages
+            .map((page) => {
+            const content = (0, page_utils_1.readPageFromDiskAsString)(conversationId, page.path, page.method);
+            if (!content) {
+                console.warn('Page not found', page);
+                return undefined;
+            }
+            return {
+                filename: page.filename,
+                path: page.path,
+                method: page.method,
+                title: page.title,
+                conversationId: page.conversationId,
+                prompt: page.prompt,
+                name: page.name,
+                description: page.description,
+                content,
+            };
+        })
+            .filter((page) => !!page);
+        const editStream = await stormClient_1.stormClient.editPages({
+            ...aiRequest.prompt,
+            pages,
+        }, conversationId);
         onRequestAborted(req, res, () => {
             editStream.abort();
         });
         res.set('Content-Type', 'application/x-ndjson');
         res.set('Access-Control-Expose-Headers', stormClient_1.ConversationIdHeader);
         res.set(stormClient_1.ConversationIdHeader, editStream.getConversationId());
+        const promises = [];
         editStream.on('data', (data) => {
             try {
-                sendEvent(res, data);
+                if (data.type === 'PAGE') {
+                    promises.push(sendPageEvent(editStream.getConversationId(), data, res));
+                }
+                else {
+                    sendEvent(res, data);
+                }
             }
             catch (e) {
                 console.error('Failed to process event', e);
@@ -150,6 +243,7 @@ router.post('/ui/edit', async (req, res) => {
         if (editStream.isAborted()) {
             return;
         }
+        await Promise.all(promises);
         sendDone(res);
     }
     catch (err) {
@@ -351,4 +445,13 @@ function onRequestAborted(req, res, onAborted) {
         onAborted();
     });
 }
+function sendPageEvent(mainConversationId, data, res) {
+    return (0, page_utils_1.writePageToDisk)(mainConversationId, data)
+        .catch((err) => {
+        console.error('Failed to write page to disk', err);
+    })
+        .then(() => {
+        sendEvent(res, convertPageEvent(data, data.payload.conversationId, mainConversationId));
+    });
+}
 exports.default = router;

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

@@ -1,4 +1,5 @@
 import { ConversationItem, StormFileImplementationPrompt, StormStream, StormUIImplementationPrompt, StormUIListPrompt } from './stream';
+import { Page, StormEventPageUrl } from './events';
 export declare const STORM_ID = "storm";
 export declare const ConversationIdHeader = "Conversation-Id";
 export interface UIPagePrompt {
@@ -9,14 +10,18 @@ export interface UIPagePrompt {
     path: string;
     method: string;
     description: string;
+    storage_prefix: string;
 }
 export interface UIPageEditPrompt {
     planDescription: string;
     blockDescription: string;
-    pages: {
-        filename: string;
-        content: string;
-    }[];
+    pages: Page[];
+    prompt: string;
+}
+export interface UIPageEditRequest {
+    planDescription: string;
+    blockDescription: string;
+    pages: StormEventPageUrl['payload'][];
     prompt: string;
 }
 declare class StormClient {

package/package.json

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

package/src/clusterService.ts

@@ -56,15 +56,24 @@ class ClusterService {
 
     /**
      * Gets next available port
-     * @return {Promise<number>}
      */
-    async getNextAvailablePort() {
+    public async getNextAvailablePort(startPort: number = -1) {
+        let receivedStartPort = startPort > 0;
+        if (!receivedStartPort) {
+            startPort = this._currentPort;
+        }
         while (true) {
-            while (this._reservedPorts.indexOf(this._currentPort) > -1) {
-                this._currentPort++;
+            while (this._reservedPorts.indexOf(startPort) > -1) {
+                startPort++;
+                if (!receivedStartPort) {
+                    this._currentPort = startPort;
+                }
             }
 
-            const nextPort = this._currentPort++;
+            const nextPort = startPort++;
+            if (!receivedStartPort) {
+                this._currentPort = startPort;
+            }
             const isUsed = await this._checkIfPortIsUsed(nextPort);
             if (!isUsed) {
                 return nextPort;

package/src/storm/UIServer.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import express, { Express, Request, Response } from 'express';
+import { readPageFromDisk } from './page-utils';
+import { clusterService } from '../clusterService';
+import { Server } from 'http';
+import { StormEventPage } from './events';
+
+export class UIServer {
+    private readonly express: Express;
+    private readonly systemId: string;
+
+    private port: number = 50000;
+    private server: Server | undefined;
+
+    constructor(systemId: string) {
+        this.systemId = systemId;
+        this.express = express();
+    }
+
+    public async start() {
+        this.port = await clusterService.getNextAvailablePort(this.port);
+
+        this.express.all('/*', async (req: Request, res: Response) => {
+            readPageFromDisk(this.systemId, req.params[0], req.method, res);
+        });
+
+        return new Promise<void>((resolve) => {
+            this.server = this.express.listen(this.port, () => {
+                console.log(`UI Server started on port ${this.port}`);
+                resolve();
+            });
+        });
+    }
+
+    public close() {
+        if (this.server) {
+            console.log('UI Server closed on port: %s', this.port);
+            this.server.close();
+            this.server = undefined;
+        }
+    }
+
+    resolveUrl(screenData: StormEventPage) {
+        const path = screenData.payload.path.startsWith('/') ? screenData.payload.path : `/${screenData.payload.path}`;
+        return `http://localhost:${this.port}${path}`;
+    }
+}

package/src/storm/events.ts

@@ -324,12 +324,14 @@ export interface StormEventPhases {
 
 export interface Page {
     name: string;
+    filename: string;
     title: string;
     description: string;
     content: string;
     path: string;
     method: string;
     conversationId: string;
+    prompt: string;
 }
 
 // Event for creating a page
@@ -340,6 +342,25 @@ export interface StormEventPage {
     payload: Page;
 }
 
+// Event for creating a page
+export interface StormEventPageUrl {
+    type: 'PAGE_URL';
+    reason: string;
+    created: number;
+    payload: {
+        id: string;
+        name: string;
+        filename: string;
+        title: string;
+        description: string;
+        path: string;
+        url: string;
+        method: string;
+        conversationId: string;
+        prompt: string;
+    };
+}
+
 export interface UserJourneyScreen {
     name: string;
     title: string;
@@ -389,4 +410,5 @@ export type StormEvent =
     | StormEventBlockStatus
     | StormEventCreateDSLRetry
     | StormEventUserJourney
-    | StormEventPage;
+    | StormEventPage
+    | StormEventPageUrl;

package/src/storm/page-utils.ts

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { StormEventPage } from './events';
+import { Response } from 'express';
+import os from 'node:os';
+import Path from 'path';
+import FS from 'fs-extra';
+
+export const SystemIdHeader = 'System-Id';
+
+export async function writePageToDisk(systemId: string, event: StormEventPage) {
+    const path = Path.join(
+        os.tmpdir(),
+        'ai-systems',
+        systemId,
+        event.payload.path,
+        event.payload.method.toLowerCase(),
+        'index.html'
+    );
+    await FS.ensureDir(Path.dirname(path));
+    await FS.writeFile(path, event.payload.content);
+
+    console.log(`Page written to disk: ${event.payload.title} > ${path}`);
+
+    return {
+        path,
+    };
+}
+
+export function readPageFromDiskAsString(systemId: string, path: string, method: string) {
+    const filePath = Path.join(os.tmpdir(), 'ai-systems', systemId, path, method.toLowerCase(), 'index.html');
+    if (!FS.existsSync(filePath)) {
+        return null;
+    }
+
+    return FS.readFileSync(filePath, 'utf8');
+}
+
+export function readPageFromDisk(systemId: string, path: string, method: string, res: Response) {
+    const filePath = Path.join(os.tmpdir(), 'ai-systems', systemId, path, method.toLowerCase(), 'index.html');
+    if (!FS.existsSync(filePath)) {
+        res.status(404).send('Page not found');
+        return;
+    }
+
+    res.type(filePath.split('.').pop() as string);
+
+    const content = FS.readFileSync(filePath, 'utf8');
+    res.write(content);
+    res.end();
+}

package/src/storm/routes.ts

@@ -12,8 +12,8 @@ import { corsHandler } from '../middleware/cors';
 import { stringBody } from '../middleware/stringBody';
 import { KapetaBodyRequest } from '../types';
 import { StormCodegenRequest, StormContextRequest, StormCreateBlockRequest, StormStream } from './stream';
-import { ConversationIdHeader, stormClient, UIPagePrompt, UIPageEditPrompt } from './stormClient';
-import { StormEvent, StormEventPhaseType } from './events';
+import { ConversationIdHeader, stormClient, UIPagePrompt, UIPageEditPrompt, UIPageEditRequest } from './stormClient';
+import { Page, StormEvent, StormEventPage, StormEventPhaseType } from './events';
 import {
     createPhaseEndEvent,
     createPhaseStartEvent,
@@ -25,18 +25,55 @@ import { StormCodegen } from './codegen';
 import { assetManager } from '../assetManager';
 import uuid from 'node-uuid';
 import { PromiseQueue } from './PromiseQueue';
+import { readPageFromDisk, readPageFromDiskAsString, SystemIdHeader, writePageToDisk } from './page-utils';
+import { UIServer } from './UIServer';
 
+const UI_SERVERS: { [key: string]: UIServer } = {};
 const router = Router();
 
 router.use('/', corsHandler);
 router.use('/', stringBody);
 
-router.post('/:handle/ui/screen', async (req: KapetaBodyRequest, res: Response) => {
-    const handle = req.params.handle as string;
+function convertPageEvent(screenData: StormEvent, innerConversationId: string, mainConversationId: string): StormEvent {
+    if (screenData.type === 'PAGE') {
+        const server: UIServer | undefined = UI_SERVERS[mainConversationId];
+        if (!server) {
+            console.warn('No server found for conversation', mainConversationId);
+        }
+        screenData.payload.conversationId = innerConversationId;
+        return {
+            type: 'PAGE_URL',
+            reason: screenData.reason,
+            created: screenData.created,
+            payload: {
+                id: uuid.v4(),
+                name: screenData.payload.name,
+                title: screenData.payload.title,
+                filename: screenData.payload.filename,
+                description: screenData.payload.description,
+                prompt: screenData.payload.prompt,
+                path: screenData.payload.path,
+                url: server ? server.resolveUrl(screenData) : '',
+                method: screenData.payload.method,
+                conversationId: innerConversationId,
+            },
+        };
+    }
+
+    return screenData;
+}
+
+router.all('/ui/:systemId/serve/:method/*', async (req: KapetaBodyRequest, res: Response) => {
+    readPageFromDisk(req.params.systemId, req.params[0], req.params.method, res);
+});
+
+router.post('/ui/screen', async (req: KapetaBodyRequest, res: Response) => {
     try {
         const conversationId = req.headers[ConversationIdHeader.toLowerCase()] as string | undefined;
+        const systemId = req.headers[SystemIdHeader.toLowerCase()] as string | undefined;
 
         const aiRequest: UIPagePrompt = JSON.parse(req.stringBody ?? '{}');
+        aiRequest.storage_prefix = systemId ? systemId + '_' : 'mock_';
 
         const screenStream = await stormClient.createUIPage(aiRequest, conversationId);
 
@@ -48,12 +85,22 @@ router.post('/:handle/ui/screen', async (req: KapetaBodyRequest, res: Response)
         res.set('Access-Control-Expose-Headers', ConversationIdHeader);
         res.set(ConversationIdHeader, screenStream.getConversationId());
 
+        const promises: Promise<void>[] = [];
         screenStream.on('data', (data: StormEvent) => {
-            console.log('Processing screen event', data);
+            switch (data.type) {
+                case 'PAGE':
+                    console.log('Processing page event', data);
+                    data.payload.conversationId = screenStream.getConversationId();
+                    if (systemId) {
+                        promises.push(sendPageEvent(systemId, data, res));
+                    }
+                    break;
+            }
             sendEvent(res, data);
         });
 
         await waitForStormStream(screenStream);
+        await Promise.allSettled(promises);
 
         sendDone(res);
     } catch (err: any) {
@@ -64,6 +111,20 @@ router.post('/:handle/ui/screen', async (req: KapetaBodyRequest, res: Response)
     }
 });
 
+router.delete('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
+    const conversationId = req.headers[ConversationIdHeader.toLowerCase()] as string | undefined;
+    if (!conversationId) {
+        res.status(400).send('Missing conversation id');
+        return;
+    }
+
+    const server = UI_SERVERS[conversationId];
+    if (server) {
+        server.close();
+        delete UI_SERVERS[conversationId];
+    }
+});
+
 router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
     const handle = req.params.handle as string;
     try {
@@ -83,11 +144,16 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
 
         const promises: { [key: string]: Promise<void> } = {};
 
-        const queue = new PromiseQueue(10);
+        const queue = new PromiseQueue(5);
         onRequestAborted(req, res, () => {
             queue.cancel();
         });
 
+        const systemId = userJourneysStream.getConversationId();
+
+        UI_SERVERS[systemId] = new UIServer(systemId);
+        await UI_SERVERS[systemId].start();
+
         userJourneysStream.on('data', async (data: StormEvent) => {
             try {
                 console.log('Processing user journey event', data);
@@ -118,18 +184,23 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
                                             name: screen.name,
                                             title: screen.title,
                                             filename: screen.filename,
+                                            storage_prefix: userJourneysStream.getConversationId() + '_',
                                         },
                                         innerConversationId
                                     );
+                                    const promises: Promise<void>[] = [];
                                     screenStream.on('data', (screenData: StormEvent) => {
                                         if (screenData.type === 'PAGE') {
                                             screenData.payload.conversationId = innerConversationId;
+                                            promises.push(
+                                                sendPageEvent(userJourneysStream.getConversationId(), screenData, res)
+                                            );
+                                        } else {
+                                            sendEvent(res, screenData);
                                         }
-
-                                        sendEvent(res, screenData);
                                     });
                                     screenStream.on('end', () => {
-                                        resolve();
+                                        Promise.allSettled(promises).finally(resolve);
                                     });
                                 } catch (e: any) {
                                     console.error('Failed to process screen', e);
@@ -163,9 +234,37 @@ router.post('/ui/edit', async (req: KapetaBodyRequest, res: Response) => {
     try {
         const conversationId = req.headers[ConversationIdHeader.toLowerCase()] as string | undefined;
 
-        const aiRequest: StormContextRequest<UIPageEditPrompt> = JSON.parse(req.stringBody ?? '{}');
+        const aiRequest: StormContextRequest<UIPageEditRequest> = JSON.parse(req.stringBody ?? '{}');
+
+        const pages = aiRequest.prompt.pages
+            .map((page) => {
+                const content = readPageFromDiskAsString(conversationId!, page.path, page.method);
+                if (!content) {
+                    console.warn('Page not found', page);
+                    return undefined;
+                }
 
-        const editStream = await stormClient.editPages(aiRequest.prompt, conversationId);
+                return {
+                    filename: page.filename,
+                    path: page.path,
+                    method: page.method,
+                    title: page.title,
+                    conversationId: page.conversationId,
+                    prompt: page.prompt,
+                    name: page.name,
+                    description: page.description,
+                    content,
+                } satisfies Page;
+            })
+            .filter((page: Page | undefined) => !!page) as UIPageEditPrompt['pages'];
+
+        const editStream = await stormClient.editPages(
+            {
+                ...aiRequest.prompt,
+                pages,
+            },
+            conversationId
+        );
 
         onRequestAborted(req, res, () => {
             editStream.abort();
@@ -175,19 +274,24 @@ router.post('/ui/edit', async (req: KapetaBodyRequest, res: Response) => {
         res.set('Access-Control-Expose-Headers', ConversationIdHeader);
         res.set(ConversationIdHeader, editStream.getConversationId());
 
+        const promises: Promise<void>[] = [];
         editStream.on('data', (data: StormEvent) => {
             try {
-                sendEvent(res, data);
+                if (data.type === 'PAGE') {
+                    promises.push(sendPageEvent(editStream.getConversationId(), data, res));
+                } else {
+                    sendEvent(res, data);
+                }
             } catch (e) {
                 console.error('Failed to process event', e);
             }
         });
 
         await waitForStormStream(editStream);
-
         if (editStream.isAborted()) {
             return;
         }
+        await Promise.all(promises);
 
         sendDone(res);
     } catch (err: any) {
@@ -428,4 +532,14 @@ function onRequestAborted(req: KapetaBodyRequest, res: Response, onAborted: () =
     });
 }
 
+function sendPageEvent(mainConversationId: string, data: StormEventPage, res: Response) {
+    return writePageToDisk(mainConversationId, data)
+        .catch((err) => {
+            console.error('Failed to write page to disk', err);
+        })
+        .then(() => {
+            sendEvent(res, convertPageEvent(data, data.payload.conversationId, mainConversationId));
+        });
+}
+
 export default router;